Index: amd64/amd64/trap.c
===================================================================
--- amd64/amd64/trap.c	(revision 225284)
+++ amd64/amd64/trap.c	(working copy)
@@ -77,6 +77,8 @@
 #include <sys/pmckern.h>
 #endif
 
+#include <security/audit/audit.h>
+
 #include <vm/vm.h>
 #include <vm/vm_param.h>
 #include <vm/pmap.h>
@@ -889,6 +891,155 @@
 	return (error);
 }
 
+#if 1
+#define	syscallenter		_syscallenter
+#define	syscallret		_syscallret
+
+static __inline int
+syscallenter(struct thread *td, struct syscall_args *sa)
+{
+	struct proc *p;
+	int error, traced;
+
+	PCPU_INC(cnt.v_syscall);
+	p = td->td_proc;
+	td->td_syscalls++;
+
+	td->td_pticks = 0;
+	if (td->td_ucred != p->p_ucred)
+		cred_update_thread(td);
+	if (p->p_flag & P_TRACED) {
+		traced = 1;
+		PROC_LOCK(p);
+		td->td_dbgflags &= ~TDB_USERWR;
+		td->td_dbgflags |= TDB_SCE;
+		PROC_UNLOCK(p);
+	} else
+		traced = 0;
+	error = (p->p_sysent->sv_fetch_syscall_args)(td, sa);
+#ifdef KTRACE
+	if (KTRPOINT(td, KTR_SYSCALL))
+		ktrsyscall(sa->code, sa->narg, sa->args);
+#endif
+
+	CTR6(KTR_SYSC,
+"syscall: td=%p pid %d %s (%#lx, %#lx, %#lx)",
+	    td, td->td_proc->p_pid, syscallname(p, sa->code),
+	    sa->args[0], sa->args[1], sa->args[2]);
+
+	if (error == 0) {
+		STOPEVENT(p, S_SCE, sa->narg);
+		PTRACESTOP_SC(p, td, S_PT_SCE);
+		if (td->td_dbgflags & TDB_USERWR) {
+			/*
+			 * Reread syscall number and arguments if
+			 * debugger modified registers or memory.
+			 */
+			error = (p->p_sysent->sv_fetch_syscall_args)(td, sa);
+#ifdef KTRACE
+			if (KTRPOINT(td, KTR_SYSCALL))
+				ktrsyscall(sa->code, sa->narg, sa->args);
+#endif
+			if (error != 0)
+				goto retval;
+		}
+
+#ifdef KDTRACE_HOOKS
+		/*
+		 * If the systrace module has registered it's probe
+		 * callback and if there is a probe active for the
+		 * syscall 'entry', process the probe.
+		 */
+		if (systrace_probe_func != NULL && sa->callp->sy_entry != 0)
+			(*systrace_probe_func)(sa->callp->sy_entry, sa->code,
+			    sa->callp, sa->args, 0);
+#endif
+
+		AUDIT_SYSCALL_ENTER(sa->code, td);
+		error = (sa->callp->sy_call)(td, sa->args);
+		AUDIT_SYSCALL_EXIT(error, td);
+
+		/* Save the latest error return value. */
+		td->td_errno = error;
+
+#ifdef KDTRACE_HOOKS
+		/*
+		 * If the systrace module has registered it's probe
+		 * callback and if there is a probe active for the
+		 * syscall 'return', process the probe.
+		 */
+		if (systrace_probe_func != NULL && sa->callp->sy_return != 0)
+			(*systrace_probe_func)(sa->callp->sy_return, sa->code,
+			    sa->callp, NULL, (error) ? -1 : td->td_retval[0]);
+#endif
+		CTR4(KTR_SYSC, "syscall: p=%p error=%d return %#lx %#lx",
+		    p, error, td->td_retval[0], td->td_retval[1]);
+	}
+ retval:
+	if (traced) {
+		PROC_LOCK(p);
+		td->td_dbgflags &= ~TDB_SCE;
+		PROC_UNLOCK(p);
+	}
+	(p->p_sysent->sv_set_syscall_retval)(td, error);
+	return (error);
+}
+
+static __inline void
+syscallret(struct thread *td, int error, struct syscall_args *sa __unused)
+{
+	struct proc *p;
+	int traced;
+
+	p = td->td_proc;
+
+	/*
+	 * Check for misbehavior.
+	 */
+	WITNESS_WARN(WARN_PANIC, NULL, "System call %s returning",
+	    syscallname(p, sa->code));
+	KASSERT(td->td_critnest == 0,
+	    ("System call %s returning in a critical section",
+	    syscallname(p, sa->code)));
+	KASSERT(td->td_locks == 0,
+	    ("System call %s returning with %d locks held",
+	     syscallname(p, sa->code), td->td_locks));
+
+	/*
+	 * Handle reschedule and other end-of-syscall issues
+	 */
+	userret(td, td->td_frame);
+
+	CTR4(KTR_SYSC, "syscall %s exit thread %p pid %d proc %s",
+	    syscallname(p, sa->code), td, td->td_proc->p_pid, td->td_name);
+
+#ifdef KTRACE
+	if (KTRPOINT(td, KTR_SYSRET))
+		ktrsysret(sa->code, error, td->td_retval[0]);
+#endif
+
+	if (p->p_flag & P_TRACED) {
+		traced = 1;
+		PROC_LOCK(p);
+		td->td_dbgflags |= TDB_SCX;
+		PROC_UNLOCK(p);
+	} else
+		traced = 0;
+	/*
+	 * This works because errno is findable through the
+	 * register set.  If we ever support an emulation where this
+	 * is not the case, this code will need to be revisited.
+	 */
+	STOPEVENT(p, S_SCX, sa->code);
+	PTRACESTOP_SC(p, td, S_PT_SCX);
+	if (traced || (td->td_dbgflags & (TDB_EXEC | TDB_FORK)) != 0) {
+		PROC_LOCK(p);
+		td->td_dbgflags &= ~(TDB_SCX | TDB_EXEC | TDB_FORK);
+		PROC_UNLOCK(p);
+	}
+}
+#endif
+
 /*
  *	syscall -	system call request C handler
  *