diff -Naur linux-source-2.6.38.orig/arch/mips/kernel/syscall.c linux-source-2.6.38.modif/arch/mips/kernel/syscall.c
--- linux-source-2.6.38.orig/arch/mips/kernel/syscall.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/arch/mips/kernel/syscall.c	2011-12-16 12:41:45.000000000 +0100
@@ -272,6 +272,9 @@
 {
 	struct thread_info *ti = task_thread_info(current);
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|set_thread_area");
+
 	ti->tp_value = addr;
 	if (cpu_has_userlocal)
 		write_c0_userlocal(addr);
diff -Naur linux-source-2.6.38.orig/arch/x86/kernel/signal.c linux-source-2.6.38.modif/arch/x86/kernel/signal.c
--- linux-source-2.6.38.orig/arch/x86/kernel/signal.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/arch/x86/kernel/signal.c	2011-12-16 12:37:27.000000000 +0100
@@ -485,6 +485,9 @@
 asmlinkage int
 sys_sigsuspend(int history0, int history1, old_sigset_t mask)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|sigsuspend");
+
 	mask &= _BLOCKABLE;
 	spin_lock_irq(&current->sighand->siglock);
 	current->saved_sigmask = current->blocked;
@@ -506,6 +509,9 @@
 	struct k_sigaction new_ka, old_ka;
 	int ret = 0;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|sigaction");
+
 	if (act) {
 		old_sigset_t mask;
 
@@ -549,6 +555,9 @@
 sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss,
 		struct pt_regs *regs)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|sigaltstack");
+
 	return do_sigaltstack(uss, uoss, regs->sp);
 }
 
@@ -562,6 +571,9 @@
 	unsigned long ax;
 	sigset_t set;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|sigreturn");
+
 	frame = (struct sigframe __user *)(regs->sp - 8);
 
 	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
@@ -594,6 +606,9 @@
 	unsigned long ax;
 	sigset_t set;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|rt_sigreturn");
+
 	frame = (struct rt_sigframe __user *)(regs->sp - sizeof(long));
 	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 		goto badframe;
diff -Naur linux-source-2.6.38.orig/fs/aio.c linux-source-2.6.38.modif/fs/aio.c
--- linux-source-2.6.38.orig/fs/aio.c	2011-09-28 16:24:41.000000000 +0200
+++ linux-source-2.6.38.modif/fs/aio.c	2011-12-16 12:44:23.000000000 +0100
@@ -1252,6 +1252,9 @@
 	unsigned long ctx;
 	long ret;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|io_setup");
+
 	ret = get_user(ctx, ctxp);
 	if (unlikely(ret))
 		goto out;
@@ -1287,6 +1290,9 @@
 SYSCALL_DEFINE1(io_destroy, aio_context_t, ctx)
 {
 	struct kioctx *ioctx = lookup_ioctx(ctx);
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|io_destroy");
+
 	if (likely(NULL != ioctx)) {
 		io_destroy(ioctx);
 		return 0;
@@ -1747,6 +1753,9 @@
 SYSCALL_DEFINE3(io_submit, aio_context_t, ctx_id, long, nr,
 		struct iocb __user * __user *, iocbpp)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|io_submit");
+
 	return do_io_submit(ctx_id, nr, iocbpp, 0);
 }
 
@@ -1788,6 +1797,9 @@
 	u32 key;
 	int ret;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|io_cancel");
+
 	ret = get_user(key, &iocb->aio_key);
 	if (unlikely(ret))
 		return -EFAULT;
@@ -1851,6 +1863,9 @@
 	struct kioctx *ioctx = lookup_ioctx(ctx_id);
 	long ret = -EINVAL;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|io_getevents");
+
 	if (likely(ioctx)) {
 		if (likely(min_nr <= nr && min_nr >= 0))
 			ret = read_events(ioctx, min_nr, nr, events, timeout);
diff -Naur linux-source-2.6.38.orig/fs/buffer.c linux-source-2.6.38.modif/fs/buffer.c
--- linux-source-2.6.38.orig/fs/buffer.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/fs/buffer.c	2011-12-16 12:48:31.000000000 +0100
@@ -3160,6 +3160,9 @@
 {
 	static int msg_count;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|bdflush");
+
 	if (!capable(CAP_SYS_ADMIN))
 		return -EPERM;
 
diff -Naur linux-source-2.6.38.orig/fs/dcache.c linux-source-2.6.38.modif/fs/dcache.c
--- linux-source-2.6.38.orig/fs/dcache.c	2011-09-28 16:24:41.000000000 +0200
+++ linux-source-2.6.38.modif/fs/dcache.c	2011-12-16 12:49:14.000000000 +0100
@@ -2800,6 +2800,9 @@
 	struct path pwd, root;
 	char *page = (char *) __get_free_page(GFP_USER);
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|getcwd");
+
 	if (!page)
 		return -ENOMEM;
 
diff -Naur linux-source-2.6.38.orig/fs/eventfd.c linux-source-2.6.38.modif/fs/eventfd.c
--- linux-source-2.6.38.orig/fs/eventfd.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/fs/eventfd.c	2011-12-16 12:51:51.000000000 +0100
@@ -412,6 +412,9 @@
 	int fd, error;
 	struct file *file;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|eventfd2");
+
 	error = get_unused_fd_flags(flags & EFD_SHARED_FCNTL_FLAGS);
 	if (error < 0)
 		return error;
@@ -434,6 +437,9 @@
 
 SYSCALL_DEFINE1(eventfd, unsigned int, count)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|eventfd");
+
 	return sys_eventfd2(count, 0);
 }
 
diff -Naur linux-source-2.6.38.orig/fs/eventpoll.c linux-source-2.6.38.modif/fs/eventpoll.c
--- linux-source-2.6.38.orig/fs/eventpoll.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/fs/eventpoll.c	2011-12-16 12:53:21.000000000 +0100
@@ -1272,6 +1272,9 @@
 	int error;
 	struct eventpoll *ep = NULL;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|epoll_create1");
+
 	/* Check the EPOLL_* constant for consistency.  */
 	BUILD_BUG_ON(EPOLL_CLOEXEC != O_CLOEXEC);
 
@@ -1297,6 +1300,9 @@
 
 SYSCALL_DEFINE1(epoll_create, int, size)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|epoll_create");
+
 	if (size <= 0)
 		return -EINVAL;
 
@@ -1318,6 +1324,9 @@
 	struct epitem *epi;
 	struct epoll_event epds;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|epoll_ctl");
+
 	error = -EFAULT;
 	if (ep_op_has_event(op) &&
 	    copy_from_user(&epds, event, sizeof(struct epoll_event)))
@@ -1430,6 +1439,9 @@
 	struct file *file;
 	struct eventpoll *ep;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|epoll_wait");
+
 	/* The maximum number of event must be greater than zero */
 	if (maxevents <= 0 || maxevents > EP_MAX_EVENTS)
 		return -EINVAL;
@@ -1483,6 +1495,9 @@
 	int error;
 	sigset_t ksigmask, sigsaved;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|epoll_pwait");
+
 	/*
 	 * If the caller wants a certain signal mask to be set during the wait,
 	 * we apply it here.
diff -Naur linux-source-2.6.38.orig/fs/exec.c linux-source-2.6.38.modif/fs/exec.c
--- linux-source-2.6.38.orig/fs/exec.c	2011-09-28 16:24:41.000000000 +0200
+++ linux-source-2.6.38.modif/fs/exec.c	2011-12-16 12:55:16.000000000 +0100
@@ -118,6 +118,9 @@
 	char *tmp = getname(library);
 	int error = PTR_ERR(tmp);
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|uselib");
+
 	if (IS_ERR(tmp))
 		goto out;
 
diff -Naur linux-source-2.6.38.orig/fs/fcntl.c linux-source-2.6.38.modif/fs/fcntl.c
--- linux-source-2.6.38.orig/fs/fcntl.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/fs/fcntl.c	2011-12-16 12:56:54.000000000 +0100
@@ -57,6 +57,9 @@
 	struct files_struct * files = current->files;
 	struct fdtable *fdt;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|dup3");
+
 	if ((flags & ~O_CLOEXEC) != 0)
 		return -EINVAL;
 
@@ -115,6 +118,9 @@
 
 SYSCALL_DEFINE2(dup2, unsigned int, oldfd, unsigned int, newfd)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|dup2");
+
 	if (unlikely(newfd == oldfd)) { /* corner case */
 		struct files_struct *files = current->files;
 		int retval = oldfd;
@@ -133,6 +139,9 @@
 	int ret = -EBADF;
 	struct file *file = fget(fildes);
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|dup");
+
 	if (file) {
 		ret = get_unused_fd();
 		if (ret >= 0)
@@ -431,6 +440,9 @@
 	struct file *filp;
 	long err = -EBADF;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|fcntl");
+
 	filp = fget(fd);
 	if (!filp)
 		goto out;
@@ -455,6 +467,9 @@
 	struct file * filp;
 	long err;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|fcntl64");
+
 	err = -EBADF;
 	filp = fget(fd);
 	if (!filp)
diff -Naur linux-source-2.6.38.orig/fs/ioctl.c linux-source-2.6.38.modif/fs/ioctl.c
--- linux-source-2.6.38.orig/fs/ioctl.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/fs/ioctl.c	2011-12-16 13:00:32.000000000 +0100
@@ -612,6 +612,9 @@
 	int error = -EBADF;
 	int fput_needed;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|ioctl");
+
 	filp = fget_light(fd, &fput_needed);
 	if (!filp)
 		goto out;
diff -Naur linux-source-2.6.38.orig/fs/ioprio.c linux-source-2.6.38.modif/fs/ioprio.c
--- linux-source-2.6.38.orig/fs/ioprio.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/fs/ioprio.c	2011-12-16 13:01:09.000000000 +0100
@@ -82,6 +82,9 @@
 	struct pid *pgrp;
 	int ret;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|ioprio_set");
+
 	switch (class) {
 		case IOPRIO_CLASS_RT:
 			if (!capable(CAP_SYS_ADMIN))
@@ -192,6 +195,9 @@
 	int ret = -ESRCH;
 	int tmpio;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|ioprio_get");
+
 	rcu_read_lock();
 	switch (which) {
 		case IOPRIO_WHO_PROCESS:
diff -Naur linux-source-2.6.38.orig/fs/locks.c linux-source-2.6.38.modif/fs/locks.c
--- linux-source-2.6.38.orig/fs/locks.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/fs/locks.c	2011-12-16 13:02:43.000000000 +0100
@@ -1609,6 +1609,9 @@
 	int can_sleep, unlock;
 	int error;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|flock");
+
 	error = -EBADF;
 	filp = fget(fd);
 	if (!filp)
diff -Naur linux-source-2.6.38.orig/fs/namei.c linux-source-2.6.38.modif/fs/namei.c
--- linux-source-2.6.38.orig/fs/namei.c	2011-09-28 16:24:41.000000000 +0200
+++ linux-source-2.6.38.modif/fs/namei.c	2011-12-16 13:08:31.000000000 +0100
@@ -2691,6 +2691,9 @@
 	struct dentry *dentry;
 	struct nameidata nd;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|mknodat");
+
 	if (S_ISDIR(mode))
 		return -EPERM;
 
@@ -2740,6 +2743,9 @@
 
 SYSCALL_DEFINE3(mknod, const char __user *, filename, int, mode, unsigned, dev)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|mknod");
+
 	return sys_mknodat(AT_FDCWD, filename, mode, dev);
 }
 
@@ -2771,6 +2777,9 @@
 	struct dentry *dentry;
 	struct nameidata nd;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|mkdirat");
+
 	error = user_path_parent(dfd, pathname, &nd, &tmp);
 	if (error)
 		goto out_err;
@@ -2803,6 +2812,9 @@
 
 SYSCALL_DEFINE2(mkdir, const char __user *, pathname, int, mode)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|mkdir");
+
 	return sys_mkdirat(AT_FDCWD, pathname, mode);
 }
 
@@ -2915,6 +2927,9 @@
 
 SYSCALL_DEFINE1(rmdir, const char __user *, pathname)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|rmdir");
+
 	return do_rmdir(AT_FDCWD, pathname);
 }
 
@@ -3012,6 +3027,9 @@
 
 SYSCALL_DEFINE3(unlinkat, int, dfd, const char __user *, pathname, int, flag)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|unlinkat");
+
 	if ((flag & ~AT_REMOVEDIR) != 0)
 		return -EINVAL;
 
@@ -3023,6 +3041,9 @@
 
 SYSCALL_DEFINE1(unlink, const char __user *, pathname)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|unlink");
+
 	return do_unlinkat(AT_FDCWD, pathname);
 }
 
@@ -3055,6 +3076,9 @@
 	struct dentry *dentry;
 	struct nameidata nd;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|symlinkat");
+
 	from = getname(oldname);
 	if (IS_ERR(from))
 		return PTR_ERR(from);
@@ -3090,6 +3114,9 @@
 
 SYSCALL_DEFINE2(symlink, const char __user *, oldname, const char __user *, newname)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|symlink");
+
 	return sys_symlinkat(oldname, AT_FDCWD, newname);
 }
 
@@ -3148,6 +3175,9 @@
 	int error;
 	char *to;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|linkat");
+
 	if ((flags & ~AT_SYMLINK_FOLLOW) != 0)
 		return -EINVAL;
 
@@ -3191,6 +3221,9 @@
 
 SYSCALL_DEFINE2(link, const char __user *, oldname, const char __user *, newname)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|link");
+
 	return sys_linkat(AT_FDCWD, oldname, AT_FDCWD, newname, 0);
 }
 
@@ -3351,6 +3384,9 @@
 	char *to;
 	int error;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|renameat");
+
 	error = user_path_parent(olddfd, oldname, &oldnd, &from);
 	if (error)
 		goto exit;
@@ -3436,6 +3472,9 @@
 
 SYSCALL_DEFINE2(rename, const char __user *, oldname, const char __user *, newname)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|rename");
+
 	return sys_renameat(AT_FDCWD, oldname, AT_FDCWD, newname);
 }
 
diff -Naur linux-source-2.6.38.orig/fs/namespace.c linux-source-2.6.38.modif/fs/namespace.c
--- linux-source-2.6.38.orig/fs/namespace.c	2011-09-28 16:24:41.000000000 +0200
+++ linux-source-2.6.38.modif/fs/namespace.c	2011-12-16 13:08:58.000000000 +0100
@@ -2464,6 +2464,9 @@
 	struct path new, old, parent_path, root_parent, root;
 	int error;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|pivot_root");
+
 	if (!capable(CAP_SYS_ADMIN))
 		return -EPERM;
 
diff -Naur linux-source-2.6.38.orig/fs/nfsctl.c linux-source-2.6.38.modif/fs/nfsctl.c
--- linux-source-2.6.38.orig/fs/nfsctl.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/fs/nfsctl.c	2011-12-16 16:07:19.000000000 +0100
@@ -91,6 +91,9 @@
 	int version;
 	int err;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|nfsservctl");
+
 	if (copy_from_user(&version, &arg->ca_version, sizeof(int)))
 		return -EFAULT;
 
diff -Naur linux-source-2.6.38.orig/fs/notify/inotify/inotify_user.c linux-source-2.6.38.modif/fs/notify/inotify/inotify_user.c
--- linux-source-2.6.38.orig/fs/notify/inotify/inotify_user.c	2011-09-28 16:24:41.000000000 +0200
+++ linux-source-2.6.38.modif/fs/notify/inotify/inotify_user.c	2011-12-16 13:10:53.000000000 +0100
@@ -726,6 +726,9 @@
 	struct fsnotify_group *group;
 	int ret;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|inotify_init1");
+
 	/* Check the IN_* constants for consistency.  */
 	BUILD_BUG_ON(IN_CLOEXEC != O_CLOEXEC);
 	BUILD_BUG_ON(IN_NONBLOCK != O_NONBLOCK);
@@ -748,6 +751,9 @@
 
 SYSCALL_DEFINE0(inotify_init)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|inotify_init");
+
 	return sys_inotify_init1(0);
 }
 
@@ -761,6 +767,9 @@
 	int ret, fput_needed;
 	unsigned flags = 0;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|inotify_add_watch");
+
 	filp = fget_light(fd, &fput_needed);
 	if (unlikely(!filp))
 		return -EBADF;
@@ -799,6 +808,9 @@
 	struct file *filp;
 	int ret = 0, fput_needed;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|inotify_rm_watch");
+
 	filp = fget_light(fd, &fput_needed);
 	if (unlikely(!filp))
 		return -EBADF;
diff -Naur linux-source-2.6.38.orig/fs/open.c linux-source-2.6.38.modif/fs/open.c
--- linux-source-2.6.38.orig/fs/open.c	2011-09-28 16:24:41.000000000 +0200
+++ linux-source-2.6.38.modif/fs/open.c	2011-12-16 13:19:16.000000000 +0100
@@ -131,6 +131,9 @@
 
 SYSCALL_DEFINE2(truncate, const char __user *, path, long, length)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|truncate");
+
 	return do_sys_truncate(path, length);
 }
 
@@ -181,6 +184,9 @@
 
 SYSCALL_DEFINE2(ftruncate, unsigned int, fd, unsigned long, length)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|ftruncate");
+
 	long ret = do_sys_ftruncate(fd, length, 1);
 	/* avoid REGPARM breakage on x86: */
 	asmlinkage_protect(2, ret, fd, length);
@@ -308,6 +314,9 @@
 	struct inode *inode;
 	int res;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|faccessat");
+
 	if (mode & ~S_IRWXO)	/* where's F_OK, X_OK, W_OK, R_OK? */
 		return -EINVAL;
 
@@ -372,11 +381,17 @@
 
 SYSCALL_DEFINE2(access, const char __user *, filename, int, mode)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|access");
+
 	return sys_faccessat(AT_FDCWD, filename, mode);
 }
 
 SYSCALL_DEFINE1(chdir, const char __user *, filename)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|chdir");
+
 	struct path path;
 	int error;
 
@@ -402,6 +417,9 @@
 	struct inode *inode;
 	int error;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|fchdir");
+
 	error = -EBADF;
 	file = fget(fd);
 	if (!file)
@@ -427,6 +445,9 @@
 	struct path path;
 	int error;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|chroot");
+
 	error = user_path_dir(filename, &path);
 	if (error)
 		goto out;
@@ -458,6 +479,9 @@
 	int err = -EBADF;
 	struct iattr newattrs;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|fchmod");
+
 	file = fget(fd);
 	if (!file)
 		goto out;
@@ -495,6 +519,9 @@
 	int error;
 	struct iattr newattrs;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|fchmodat");
+
 	error = user_path_at(dfd, filename, LOOKUP_FOLLOW, &path);
 	if (error)
 		goto out;
@@ -523,6 +550,9 @@
 
 SYSCALL_DEFINE2(chmod, const char __user *, filename, mode_t, mode)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|chmod");
+
 	return sys_fchmodat(AT_FDCWD, filename, mode);
 }
 
@@ -558,6 +588,9 @@
 	struct path path;
 	int error;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|chown");
+
 	error = user_path(filename, &path);
 	if (error)
 		goto out;
@@ -579,6 +612,9 @@
 	int error = -EINVAL;
 	int follow;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|fchownat");
+
 	if ((flag & ~AT_SYMLINK_NOFOLLOW) != 0)
 		goto out;
 
@@ -602,6 +638,9 @@
 	struct path path;
 	int error;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|lchown");
+
 	error = user_lpath(filename, &path);
 	if (error)
 		goto out;
@@ -622,6 +661,9 @@
 	int error = -EBADF;
 	struct dentry * dentry;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|fchown");
+
 	file = fget(fd);
 	if (!file)
 		goto out;
@@ -921,6 +963,9 @@
 {
 	long ret;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|open");
+
 	if (force_o_largefile())
 		flags |= O_LARGEFILE;
 
@@ -935,6 +980,9 @@
 {
 	long ret;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|openat");
+
 	if (force_o_largefile())
 		flags |= O_LARGEFILE;
 
@@ -952,6 +1000,9 @@
  */
 SYSCALL_DEFINE2(creat, const char __user *, pathname, int, mode)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|creat");
+
 	return sys_open(pathname, O_CREAT | O_WRONLY | O_TRUNC, mode);
 }
 
@@ -988,6 +1039,9 @@
  */
 SYSCALL_DEFINE1(close, unsigned int, fd)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|close");
+
 	struct file * filp;
 	struct files_struct *files = current->files;
 	struct fdtable *fdt;
@@ -1027,6 +1081,9 @@
  */
 SYSCALL_DEFINE0(vhangup)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|vhangup");
+
 	if (capable(CAP_SYS_TTY_CONFIG)) {
 		tty_vhangup_self();
 		return 0;
diff -Naur linux-source-2.6.38.orig/fs/pipe.c linux-source-2.6.38.modif/fs/pipe.c
--- linux-source-2.6.38.orig/fs/pipe.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/fs/pipe.c	2011-12-16 15:45:20.000000000 +0100
@@ -1104,6 +1104,9 @@
 	int fd[2];
 	int error;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|pipe2");
+
 	error = do_pipe_flags(fd, flags);
 	if (!error) {
 		if (copy_to_user(fildes, fd, sizeof(fd))) {
@@ -1117,6 +1120,9 @@
 
 SYSCALL_DEFINE1(pipe, int __user *, fildes)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|pipe");
+
 	return sys_pipe2(fildes, 0);
 }
 
diff -Naur linux-source-2.6.38.orig/fs/quota/quota.c linux-source-2.6.38.modif/fs/quota/quota.c
--- linux-source-2.6.38.orig/fs/quota/quota.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/fs/quota/quota.c	2011-12-16 16:05:12.000000000 +0100
@@ -335,6 +335,9 @@
 	struct path path, *pathp = NULL;
 	int ret;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|quotactl");
+
 	cmds = cmd >> SUBCMDSHIFT;
 	type = cmd & SUBCMDMASK;
 
diff -Naur linux-source-2.6.38.orig/fs/readdir.c linux-source-2.6.38.modif/fs/readdir.c
--- linux-source-2.6.38.orig/fs/readdir.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/fs/readdir.c	2011-12-16 13:26:21.000000000 +0100
@@ -109,6 +109,9 @@
 	struct file * file;
 	struct readdir_callback buf;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|old_readdir");
+
 	error = -EBADF;
 	file = fget(fd);
 	if (!file)
@@ -197,6 +200,9 @@
 	struct getdents_callback buf;
 	int error;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|getdents");
+
 	error = -EFAULT;
 	if (!access_ok(VERIFY_WRITE, dirent, count))
 		goto out;
@@ -280,6 +286,9 @@
 	struct getdents_callback64 buf;
 	int error;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|getdents64");
+
 	error = -EFAULT;
 	if (!access_ok(VERIFY_WRITE, dirent, count))
 		goto out;
diff -Naur linux-source-2.6.38.orig/fs/read_write.c linux-source-2.6.38.modif/fs/read_write.c
--- linux-source-2.6.38.orig/fs/read_write.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/fs/read_write.c	2011-12-16 16:47:31.000000000 +0100
@@ -175,6 +175,9 @@
 	struct file * file;
 	int fput_needed;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|lseek");
+
 	retval = -EBADF;
 	file = fget_light(fd, &fput_needed);
 	if (!file)
@@ -202,6 +205,9 @@
 	loff_t offset;
 	int fput_needed;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|sys_llseek");
+
 	retval = -EBADF;
 	file = fget_light(fd, &fput_needed);
 	if (!file)
@@ -405,6 +411,9 @@
 	ssize_t ret = -EBADF;
 	int fput_needed;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|read");
+
 	file = fget_light(fd, &fput_needed);
 	if (file) {
 		loff_t pos = file_pos_read(file);
@@ -423,6 +432,9 @@
 	ssize_t ret = -EBADF;
 	int fput_needed;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|write");
+
 	file = fget_light(fd, &fput_needed);
 	if (file) {
 		loff_t pos = file_pos_read(file);
@@ -732,6 +744,9 @@
 	ssize_t ret = -EBADF;
 	int fput_needed;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|readv");
+
 	file = fget_light(fd, &fput_needed);
 	if (file) {
 		loff_t pos = file_pos_read(file);
@@ -753,6 +768,9 @@
 	ssize_t ret = -EBADF;
 	int fput_needed;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|writev");
+
 	file = fget_light(fd, &fput_needed);
 	if (file) {
 		loff_t pos = file_pos_read(file);
@@ -781,6 +799,9 @@
 	ssize_t ret = -EBADF;
 	int fput_needed;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|preadv");
+
 	if (pos < 0)
 		return -EINVAL;
 
@@ -806,6 +827,9 @@
 	ssize_t ret = -EBADF;
 	int fput_needed;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|pwritev");
+
 	if (pos < 0)
 		return -EINVAL;
 
@@ -917,6 +941,9 @@
 	off_t off;
 	ssize_t ret;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|sendfile");
+
 	if (offset) {
 		if (unlikely(get_user(off, offset)))
 			return -EFAULT;
@@ -935,6 +962,9 @@
 	loff_t pos;
 	ssize_t ret;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|sendfile64");
+
 	if (offset) {
 		if (unlikely(copy_from_user(&pos, offset, sizeof(loff_t))))
 			return -EFAULT;
diff -Naur linux-source-2.6.38.orig/fs/select.c linux-source-2.6.38.modif/fs/select.c
--- linux-source-2.6.38.orig/fs/select.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/fs/select.c	2011-12-16 15:45:56.000000000 +0100
@@ -602,6 +602,9 @@
 	struct timeval tv;
 	int ret;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|select");
+
 	if (tvp) {
 		if (copy_from_user(&tv, tvp, sizeof(tv)))
 			return -EFAULT;
@@ -681,6 +684,9 @@
 	size_t sigsetsize = 0;
 	sigset_t __user *up = NULL;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|pselect6");
+
 	if (sig) {
 		if (!access_ok(VERIFY_READ, sig, sizeof(void *)+sizeof(size_t))
 		    || __get_user(up, (sigset_t __user * __user *)sig)
@@ -704,6 +710,9 @@
 {
 	struct sel_arg_struct a;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|old_select");
+
 	if (copy_from_user(&a, arg, sizeof(a)))
 		return -EFAULT;
 	return sys_select(a.n, a.inp, a.outp, a.exp, a.tvp);
@@ -920,6 +929,9 @@
 	struct timespec end_time, *to = NULL;
 	int ret;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|poll");
+
 	if (timeout_msecs >= 0) {
 		to = &end_time;
 		poll_select_set_timeout(to, timeout_msecs / MSEC_PER_SEC,
@@ -957,6 +969,9 @@
 	struct timespec ts, end_time, *to = NULL;
 	int ret;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|ppoll");
+
 	if (tsp) {
 		if (copy_from_user(&ts, tsp, sizeof(ts)))
 			return -EFAULT;
diff -Naur linux-source-2.6.38.orig/fs/signalfd.c linux-source-2.6.38.modif/fs/signalfd.c
--- linux-source-2.6.38.orig/fs/signalfd.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/fs/signalfd.c	2011-12-16 13:29:11.000000000 +0100
@@ -225,6 +225,9 @@
 	sigset_t sigmask;
 	struct signalfd_ctx *ctx;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|signalfd4");
+
 	/* Check the SFD_* constants for consistency.  */
 	BUILD_BUG_ON(SFD_CLOEXEC != O_CLOEXEC);
 	BUILD_BUG_ON(SFD_NONBLOCK != O_NONBLOCK);
@@ -276,5 +279,8 @@
 SYSCALL_DEFINE3(signalfd, int, ufd, sigset_t __user *, user_mask,
 		size_t, sizemask)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|signalfd");
+
 	return sys_signalfd4(ufd, user_mask, sizemask, 0);
 }
diff -Naur linux-source-2.6.38.orig/fs/splice.c linux-source-2.6.38.modif/fs/splice.c
--- linux-source-2.6.38.orig/fs/splice.c	2011-09-28 16:24:41.000000000 +0200
+++ linux-source-2.6.38.modif/fs/splice.c	2011-12-16 13:32:02.000000000 +0100
@@ -1659,6 +1659,9 @@
 	long error;
 	int fput;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|vmsplice");
+
 	if (unlikely(nr_segs > UIO_MAXIOV))
 		return -EINVAL;
 	else if (unlikely(!nr_segs))
@@ -1686,6 +1689,9 @@
 	struct file *in, *out;
 	int fput_in, fput_out;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|splice");
+
 	if (unlikely(!len))
 		return 0;
 
@@ -2026,6 +2032,9 @@
 	struct file *in;
 	int error, fput_in;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|tee");
+
 	if (unlikely(!len))
 		return 0;
 
diff -Naur linux-source-2.6.38.orig/fs/stat.c linux-source-2.6.38.modif/fs/stat.c
--- linux-source-2.6.38.orig/fs/stat.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/fs/stat.c	2011-12-16 13:36:32.000000000 +0100
@@ -156,6 +156,9 @@
 	struct kstat stat;
 	int error;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|stat");
+
 	error = vfs_stat(filename, &stat);
 	if (error)
 		return error;
@@ -169,6 +172,9 @@
 	struct kstat stat;
 	int error;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|lstat");
+
 	error = vfs_lstat(filename, &stat);
 	if (error)
 		return error;
@@ -181,6 +187,9 @@
 	struct kstat stat;
 	int error = vfs_fstat(fd, &stat);
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|fstat");
+
 	if (!error)
 		error = cp_old_stat(&stat, statbuf);
 
@@ -245,6 +254,9 @@
 	struct kstat stat;
 	int error = vfs_stat(filename, &stat);
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|sys_newstat");
+
 	if (error)
 		return error;
 	return cp_new_stat(&stat, statbuf);
@@ -256,6 +268,9 @@
 	struct kstat stat;
 	int error;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|sys_newlstat");
+
 	error = vfs_lstat(filename, &stat);
 	if (error)
 		return error;
@@ -282,6 +297,9 @@
 	struct kstat stat;
 	int error = vfs_fstat(fd, &stat);
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|sys_newfstat");
+
 	if (!error)
 		error = cp_new_stat(&stat, statbuf);
 
@@ -294,6 +312,9 @@
 	struct path path;
 	int error;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|readlinkat");
+
 	if (bufsiz <= 0)
 		return -EINVAL;
 
@@ -318,6 +339,9 @@
 SYSCALL_DEFINE3(readlink, const char __user *, path, char __user *, buf,
 		int, bufsiz)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|readlink");
+
 	return sys_readlinkat(AT_FDCWD, path, buf, bufsiz);
 }
 
@@ -368,6 +392,9 @@
 	struct kstat stat;
 	int error = vfs_stat(filename, &stat);
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|stat64");
+
 	if (!error)
 		error = cp_new_stat64(&stat, statbuf);
 
@@ -380,6 +407,9 @@
 	struct kstat stat;
 	int error = vfs_lstat(filename, &stat);
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|lstat64");
+
 	if (!error)
 		error = cp_new_stat64(&stat, statbuf);
 
@@ -391,6 +421,9 @@
 	struct kstat stat;
 	int error = vfs_fstat(fd, &stat);
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|fstat64");
+
 	if (!error)
 		error = cp_new_stat64(&stat, statbuf);
 
@@ -403,6 +436,9 @@
 	struct kstat stat;
 	int error;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|fstatat64");
+
 	error = vfs_fstatat(dfd, filename, &stat, flag);
 	if (error)
 		return error;
diff -Naur linux-source-2.6.38.orig/fs/statfs.c linux-source-2.6.38.modif/fs/statfs.c
--- linux-source-2.6.38.orig/fs/statfs.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/fs/statfs.c	2011-12-16 16:11:18.000000000 +0100
@@ -151,6 +151,9 @@
 	struct path path;
 	int error;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|statfs");
+
 	error = user_path(pathname, &path);
 	if (!error) {
 		struct statfs tmp;
@@ -167,6 +170,9 @@
 	struct path path;
 	long error;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|statfs64");
+
 	if (sz != sizeof(*buf))
 		return -EINVAL;
 	error = user_path(pathname, &path);
@@ -186,6 +192,9 @@
 	struct statfs tmp;
 	int error;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|fstatfs");
+
 	error = -EBADF;
 	file = fget(fd);
 	if (!file)
@@ -204,6 +213,9 @@
 	struct statfs64 tmp;
 	int error;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|fstatfs64");
+
 	if (sz != sizeof(*buf))
 		return -EINVAL;
 
diff -Naur linux-source-2.6.38.orig/fs/sync.c linux-source-2.6.38.modif/fs/sync.c
--- linux-source-2.6.38.orig/fs/sync.c	2011-09-28 16:24:41.000000000 +0200
+++ linux-source-2.6.38.modif/fs/sync.c	2011-12-16 16:05:21.000000000 +0100
@@ -97,6 +97,9 @@
  */
 SYSCALL_DEFINE0(sync)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|sync");
+
 	wakeup_flusher_threads(0);
 	sync_filesystems(0);
 	sync_filesystems(1);
@@ -195,11 +198,17 @@
 
 SYSCALL_DEFINE1(fsync, unsigned int, fd)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|fsync");
+
 	return do_fsync(fd, 0);
 }
 
 SYSCALL_DEFINE1(fdatasync, unsigned int, fd)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|fdatasync");
+
 	return do_fsync(fd, 1);
 }
 
diff -Naur linux-source-2.6.38.orig/fs/timerfd.c linux-source-2.6.38.modif/fs/timerfd.c
--- linux-source-2.6.38.orig/fs/timerfd.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/fs/timerfd.c	2011-12-16 13:41:20.000000000 +0100
@@ -167,6 +167,9 @@
 	int ufd;
 	struct timerfd_ctx *ctx;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|timerfd_create");
+
 	/* Check the TFD_* constants for consistency.  */
 	BUILD_BUG_ON(TFD_CLOEXEC != O_CLOEXEC);
 	BUILD_BUG_ON(TFD_NONBLOCK != O_NONBLOCK);
@@ -200,6 +203,9 @@
 	struct timerfd_ctx *ctx;
 	struct itimerspec ktmr, kotmr;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|timerfd_settime");
+
 	if (copy_from_user(&ktmr, utmr, sizeof(ktmr)))
 		return -EFAULT;
 
@@ -256,6 +262,9 @@
 	struct timerfd_ctx *ctx;
 	struct itimerspec kotmr;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|timerfd_gettime");
+
 	file = timerfd_fget(ufd);
 	if (IS_ERR(file))
 		return PTR_ERR(file);
diff -Naur linux-source-2.6.38.orig/fs/utimes.c linux-source-2.6.38.modif/fs/utimes.c
--- linux-source-2.6.38.orig/fs/utimes.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/fs/utimes.c	2011-12-16 16:09:49.000000000 +0100
@@ -28,6 +28,9 @@
 {
 	struct timespec tv[2];
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|utime");
+
 	if (times) {
 		if (get_user(tv[0].tv_sec, &times->actime) ||
 		    get_user(tv[1].tv_sec, &times->modtime))
@@ -176,6 +179,9 @@
 {
 	struct timespec tstimes[2];
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|utimensat");
+
 	if (utimes) {
 		if (copy_from_user(&tstimes, utimes, sizeof(tstimes)))
 			return -EFAULT;
@@ -195,6 +201,9 @@
 	struct timeval times[2];
 	struct timespec tstimes[2];
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|futimesat");
+
 	if (utimes) {
 		if (copy_from_user(&times, utimes, sizeof(times)))
 			return -EFAULT;
@@ -220,5 +229,8 @@
 SYSCALL_DEFINE2(utimes, char __user *, filename,
 		struct timeval __user *, utimes)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|utimes");
+
 	return sys_futimesat(AT_FDCWD, filename, utimes);
 }
diff -Naur linux-source-2.6.38.orig/fs/xattr.c linux-source-2.6.38.modif/fs/xattr.c
--- linux-source-2.6.38.orig/fs/xattr.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/fs/xattr.c	2011-12-16 13:47:10.000000000 +0100
@@ -283,6 +283,9 @@
 	struct path path;
 	int error;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|setxattr");
+
 	error = user_path(pathname, &path);
 	if (error)
 		return error;
@@ -302,6 +305,9 @@
 	struct path path;
 	int error;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|lsetxattr");
+
 	error = user_lpath(pathname, &path);
 	if (error)
 		return error;
@@ -321,6 +327,9 @@
 	struct dentry *dentry;
 	int error = -EBADF;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|fsetxattr");
+
 	f = fget(fd);
 	if (!f)
 		return error;
@@ -379,6 +388,9 @@
 	struct path path;
 	ssize_t error;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|getxattr");
+
 	error = user_path(pathname, &path);
 	if (error)
 		return error;
@@ -393,6 +405,9 @@
 	struct path path;
 	ssize_t error;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|lgetxattr");
+
 	error = user_lpath(pathname, &path);
 	if (error)
 		return error;
@@ -407,6 +422,9 @@
 	struct file *f;
 	ssize_t error = -EBADF;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|fgetxattr");
+
 	f = fget(fd);
 	if (!f)
 		return error;
@@ -452,6 +470,9 @@
 	struct path path;
 	ssize_t error;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|listxattr");
+
 	error = user_path(pathname, &path);
 	if (error)
 		return error;
@@ -466,6 +487,9 @@
 	struct path path;
 	ssize_t error;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|llistxattr");
+
 	error = user_lpath(pathname, &path);
 	if (error)
 		return error;
@@ -479,6 +503,9 @@
 	struct file *f;
 	ssize_t error = -EBADF;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|flistxattr");
+
 	f = fget(fd);
 	if (!f)
 		return error;
@@ -512,6 +539,9 @@
 	struct path path;
 	int error;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|removexattr");
+
 	error = user_path(pathname, &path);
 	if (error)
 		return error;
@@ -530,6 +560,9 @@
 	struct path path;
 	int error;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|lremovexattr");
+
 	error = user_lpath(pathname, &path);
 	if (error)
 		return error;
@@ -548,6 +581,9 @@
 	struct dentry *dentry;
 	int error = -EBADF;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|fremovexattr");
+
 	f = fget(fd);
 	if (!f)
 		return error;
diff -Naur linux-source-2.6.38.orig/ipc/mqueue.c linux-source-2.6.38.modif/ipc/mqueue.c
--- linux-source-2.6.38.orig/ipc/mqueue.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/ipc/mqueue.c	2011-12-16 13:50:52.000000000 +0100
@@ -687,6 +687,9 @@
 	int fd, error;
 	struct ipc_namespace *ipc_ns = current->nsproxy->ipc_ns;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|mq_open");
+
 	if (u_attr && copy_from_user(&attr, u_attr, sizeof(struct mq_attr)))
 		return -EFAULT;
 
@@ -758,6 +761,9 @@
 	struct inode *inode = NULL;
 	struct ipc_namespace *ipc_ns = current->nsproxy->ipc_ns;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|mq_unlink");
+
 	name = getname(u_name);
 	if (IS_ERR(name))
 		return PTR_ERR(name);
@@ -858,6 +864,9 @@
 	struct timespec ts;
 	int ret;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|mq_timedsend");
+
 	if (u_abs_timeout) {
 		int res = prepare_timeout(u_abs_timeout, &expires, &ts);
 		if (res)
@@ -951,6 +960,9 @@
 	ktime_t expires, *timeout = NULL;
 	struct timespec ts;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|mq_timedreceive");
+
 	if (u_abs_timeout) {
 		int res = prepare_timeout(u_abs_timeout, &expires, &ts);
 		if (res)
@@ -1038,6 +1050,9 @@
 	struct mqueue_inode_info *info;
 	struct sk_buff *nc;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|mq_notify");
+
 	if (u_notification) {
 		if (copy_from_user(&notification, u_notification,
 					sizeof(struct sigevent)))
@@ -1168,6 +1183,9 @@
 	struct inode *inode;
 	struct mqueue_inode_info *info;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|mq_getsetattr");
+
 	if (u_mqstat != NULL) {
 		if (copy_from_user(&mqstat, u_mqstat, sizeof(struct mq_attr)))
 			return -EFAULT;
diff -Naur linux-source-2.6.38.orig/ipc/syscall.c linux-source-2.6.38.modif/ipc/syscall.c
--- linux-source-2.6.38.orig/ipc/syscall.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/ipc/syscall.c	2011-12-16 15:48:22.000000000 +0100
@@ -18,6 +18,9 @@
 {
 	int version, ret;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|ipc");
+
 	version = call >> 16; /* hack for backward compatibility */
 	call &= 0xffff;
 
diff -Naur linux-source-2.6.38.orig/kernel/acct.c linux-source-2.6.38.modif/kernel/acct.c
--- linux-source-2.6.38.orig/kernel/acct.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/kernel/acct.c	2011-12-16 13:55:27.000000000 +0100
@@ -275,6 +275,9 @@
 {
 	int error = 0;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|acct");
+
 	if (!capable(CAP_SYS_PACCT))
 		return -EPERM;
 
diff -Naur linux-source-2.6.38.orig/kernel/capability.c linux-source-2.6.38.modif/kernel/capability.c
--- linux-source-2.6.38.orig/kernel/capability.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/kernel/capability.c	2011-12-16 13:55:56.000000000 +0100
@@ -165,6 +165,9 @@
 	unsigned tocopy;
 	kernel_cap_t pE, pI, pP;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|capget");
+
 	ret = cap_validate_magic(header, &tocopy);
 	if ((dataptr == NULL) || (ret != 0))
 		return ((dataptr == NULL) && (ret == -EINVAL)) ? 0 : ret;
@@ -241,6 +244,9 @@
 	int ret;
 	pid_t pid;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|capset");
+
 	ret = cap_validate_magic(header, &tocopy);
 	if (ret != 0)
 		return ret;
diff -Naur linux-source-2.6.38.orig/kernel/exec_domain.c linux-source-2.6.38.modif/kernel/exec_domain.c
--- linux-source-2.6.38.orig/kernel/exec_domain.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/kernel/exec_domain.c	2011-12-16 13:56:42.000000000 +0100
@@ -183,6 +183,9 @@
 {
 	unsigned int old = current->personality;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|personality");
+
 	if (personality != 0xffffffff)
 		set_personality(personality);
 
diff -Naur linux-source-2.6.38.orig/kernel/exit.c linux-source-2.6.38.modif/kernel/exit.c
--- linux-source-2.6.38.orig/kernel/exit.c	2011-09-28 16:24:41.000000000 +0200
+++ linux-source-2.6.38.modif/kernel/exit.c	2011-12-16 14:01:57.000000000 +0100
@@ -1072,6 +1072,9 @@
 
 SYSCALL_DEFINE1(exit, int, error_code)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|exit");
+
 	do_exit((error_code&0xff)<<8);
 }
 
@@ -1113,6 +1116,9 @@
  */
 SYSCALL_DEFINE1(exit_group, int, error_code)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|exit_group");
+
 	do_group_exit((error_code & 0xff) << 8);
 	/* NOTREACHED */
 	return 0;
@@ -1686,6 +1692,9 @@
 	enum pid_type type;
 	long ret;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|waitid");
+
 	if (options & ~(WNOHANG|WNOWAIT|WEXITED|WSTOPPED|WCONTINUED))
 		return -EINVAL;
 	if (!(options & (WEXITED|WSTOPPED|WCONTINUED)))
@@ -1757,6 +1766,9 @@
 	enum pid_type type;
 	long ret;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|wait4");
+
 	if (options & ~(WNOHANG|WUNTRACED|WCONTINUED|
 			__WNOTHREAD|__WCLONE|__WALL))
 		return -EINVAL;
@@ -1796,6 +1808,9 @@
  */
 SYSCALL_DEFINE3(waitpid, pid_t, pid, int __user *, stat_addr, int, options)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|waitpid");
+
 	return sys_wait4(pid, stat_addr, options, NULL);
 }
 
diff -Naur linux-source-2.6.38.orig/kernel/fork.c linux-source-2.6.38.modif/kernel/fork.c
--- linux-source-2.6.38.orig/kernel/fork.c	2011-09-28 16:24:41.000000000 +0200
+++ linux-source-2.6.38.modif/kernel/fork.c	2011-12-16 14:03:12.000000000 +0100
@@ -943,6 +943,9 @@
 
 SYSCALL_DEFINE1(set_tid_address, int __user *, tidptr)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|set_tid_address");
+
 	current->clear_child_tid = tidptr;
 
 	return task_pid_vnr(current);
@@ -1634,6 +1637,9 @@
 	struct nsproxy *new_nsproxy = NULL;
 	int do_sysvsem = 0;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|unshare");
+
 	check_unshare_flags(&unshare_flags);
 
 	/* Return -EINVAL for all unsupported flags */
diff -Naur linux-source-2.6.38.orig/kernel/futex.c linux-source-2.6.38.modif/kernel/futex.c
--- linux-source-2.6.38.orig/kernel/futex.c	2011-09-28 16:24:41.000000000 +0200
+++ linux-source-2.6.38.modif/kernel/futex.c	2011-12-16 14:04:17.000000000 +0100
@@ -2379,6 +2379,9 @@
 SYSCALL_DEFINE2(set_robust_list, struct robust_list_head __user *, head,
 		size_t, len)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|set_robust_list");
+
 	if (!futex_cmpxchg_enabled)
 		return -ENOSYS;
 	/*
@@ -2406,6 +2409,9 @@
 	unsigned long ret;
 	const struct cred *cred = current_cred(), *pcred;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|get_robust_list");
+
 	if (!futex_cmpxchg_enabled)
 		return -ENOSYS;
 
@@ -2639,6 +2645,9 @@
 	u32 val2 = 0;
 	int cmd = op & FUTEX_CMD_MASK;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|futex");
+
 	if (utime && (cmd == FUTEX_WAIT || cmd == FUTEX_LOCK_PI ||
 		      cmd == FUTEX_WAIT_BITSET ||
 		      cmd == FUTEX_WAIT_REQUEUE_PI)) {
diff -Naur linux-source-2.6.38.orig/kernel/groups.c linux-source-2.6.38.modif/kernel/groups.c
--- linux-source-2.6.38.orig/kernel/groups.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/kernel/groups.c	2011-12-16 14:05:15.000000000 +0100
@@ -204,6 +204,9 @@
 	const struct cred *cred = current_cred();
 	int i;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|getgroups");
+
 	if (gidsetsize < 0)
 		return -EINVAL;
 
@@ -233,6 +236,9 @@
 	struct group_info *group_info;
 	int retval;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|setgroups");
+
 	if (!capable(CAP_SETGID))
 		return -EPERM;
 	if ((unsigned)gidsetsize > NGROUPS_MAX)
diff -Naur linux-source-2.6.38.orig/kernel/hrtimer.c linux-source-2.6.38.modif/kernel/hrtimer.c
--- linux-source-2.6.38.orig/kernel/hrtimer.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/kernel/hrtimer.c	2011-12-16 15:30:00.000000000 +0100
@@ -1578,6 +1578,9 @@
 SYSCALL_DEFINE2(nanosleep, struct timespec __user *, rqtp,
 		struct timespec __user *, rmtp)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|nanosleep");
+
 	struct timespec tu;
 
 	if (copy_from_user(&tu, rqtp, sizeof(tu)))
diff -Naur linux-source-2.6.38.orig/kernel/ioport.c linux-source-2.6.38.modif/kernel/ioport.c
--- linux-source-2.6.38.orig/kernel/ioport.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-source-2.6.38.modif/kernel/ioport.c	2011-12-16 12:20:05.000000000 +0100
@@ -0,0 +1,129 @@
+/*
+ * This contains the io-permission bitmap code - written by obz, with changes
+ * by Linus. 32/64 bits code unification by Miguel Botón.
+ */
+
+#include <linux/sched.h>
+#include <linux/kernel.h>
+#include <linux/capability.h>
+#include <linux/errno.h>
+#include <linux/types.h>
+#include <linux/ioport.h>
+#include <linux/smp.h>
+#include <linux/stddef.h>
+#include <linux/slab.h>
+#include <linux/thread_info.h>
+#include <linux/syscalls.h>
+#include <asm/syscalls.h>
+
+/* Set EXTENT bits starting at BASE in BITMAP to value TURN_ON. */
+static void set_bitmap(unsigned long *bitmap, unsigned int base,
+		       unsigned int extent, int new_value)
+{
+	unsigned int i;
+
+	for (i = base; i < base + extent; i++) {
+		if (new_value)
+			__set_bit(i, bitmap);
+		else
+			__clear_bit(i, bitmap);
+	}
+}
+
+/*
+ * this changes the io permissions bitmap in the current task.
+ */
+asmlinkage long sys_ioperm(unsigned long from, unsigned long num, int turn_on)
+{
+	struct thread_struct *t = &current->thread;
+	struct tss_struct *tss;
+	unsigned int i, max_long, bytes, bytes_updated;
+
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|ioperm");
+
+	if ((from + num <= from) || (from + num > IO_BITMAP_BITS))
+		return -EINVAL;
+	if (turn_on && !capable(CAP_SYS_RAWIO))
+		return -EPERM;
+
+	/*
+	 * If it's the first ioperm() call in this thread's lifetime, set the
+	 * IO bitmap up. ioperm() is much less timing critical than clone(),
+	 * this is why we delay this operation until now:
+	 */
+	if (!t->io_bitmap_ptr) {
+		unsigned long *bitmap = kmalloc(IO_BITMAP_BYTES, GFP_KERNEL);
+
+		if (!bitmap)
+			return -ENOMEM;
+
+		memset(bitmap, 0xff, IO_BITMAP_BYTES);
+		t->io_bitmap_ptr = bitmap;
+		set_thread_flag(TIF_IO_BITMAP);
+	}
+
+	/*
+	 * do it in the per-thread copy and in the TSS ...
+	 *
+	 * Disable preemption via get_cpu() - we must not switch away
+	 * because the ->io_bitmap_max value must match the bitmap
+	 * contents:
+	 */
+	tss = &per_cpu(init_tss, get_cpu());
+
+	set_bitmap(t->io_bitmap_ptr, from, num, !turn_on);
+
+	/*
+	 * Search for a (possibly new) maximum. This is simple and stupid,
+	 * to keep it obviously correct:
+	 */
+	max_long = 0;
+	for (i = 0; i < IO_BITMAP_LONGS; i++)
+		if (t->io_bitmap_ptr[i] != ~0UL)
+			max_long = i;
+
+	bytes = (max_long + 1) * sizeof(unsigned long);
+	bytes_updated = max(bytes, t->io_bitmap_max);
+
+	t->io_bitmap_max = bytes;
+
+	/* Update the TSS: */
+	memcpy(tss->io_bitmap, t->io_bitmap_ptr, bytes_updated);
+
+	put_cpu();
+
+	return 0;
+}
+
+/*
+ * sys_iopl has to be used when you want to access the IO ports
+ * beyond the 0x3ff range: to get the full 65536 ports bitmapped
+ * you'd need 8kB of bitmaps/process, which is a bit excessive.
+ *
+ * Here we just change the flags value on the stack: we allow
+ * only the super-user to do it. This depends on the stack-layout
+ * on system-call entry - see also fork() and the signal handling
+ * code.
+ */
+long sys_iopl(unsigned int level, struct pt_regs *regs)
+{
+	unsigned int old = (regs->flags >> 12) & 3;
+	struct thread_struct *t = &current->thread;
+
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|iopl");
+
+	if (level > 3)
+		return -EINVAL;
+	/* Trying to gain more privileges? */
+	if (level > old) {
+		if (!capable(CAP_SYS_RAWIO))
+			return -EPERM;
+	}
+	regs->flags = (regs->flags & ~X86_EFLAGS_IOPL) | (level << 12);
+	t->iopl = level << 12;
+	set_iopl_mask(t->iopl);
+
+	return 0;
+}
diff -Naur linux-source-2.6.38.orig/kernel/itimer.c linux-source-2.6.38.modif/kernel/itimer.c
--- linux-source-2.6.38.orig/kernel/itimer.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/kernel/itimer.c	2011-12-16 14:06:25.000000000 +0100
@@ -105,6 +105,9 @@
 	int error = -EFAULT;
 	struct itimerval get_buffer;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|getitimer");
+
 	if (value) {
 		error = do_getitimer(which, &get_buffer);
 		if (!error &&
@@ -282,6 +285,9 @@
 	struct itimerval set_buffer, get_buffer;
 	int error;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|setitimer");
+
 	if (value) {
 		if(copy_from_user(&set_buffer, value, sizeof(set_buffer)))
 			return -EFAULT;
diff -Naur linux-source-2.6.38.orig/kernel/kexec.c linux-source-2.6.38.modif/kernel/kexec.c
--- linux-source-2.6.38.orig/kernel/kexec.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/kernel/kexec.c	2011-12-16 14:06:40.000000000 +0100
@@ -944,6 +944,9 @@
 	struct kimage **dest_image, *image;
 	int result;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|kexec_load");
+
 	/* We only trust the superuser with rebooting the system. */
 	if (!capable(CAP_SYS_BOOT))
 		return -EPERM;
diff -Naur linux-source-2.6.38.orig/kernel/ldt.c linux-source-2.6.38.modif/kernel/ldt.c
--- linux-source-2.6.38.orig/kernel/ldt.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-source-2.6.38.modif/kernel/ldt.c	2011-12-16 12:23:21.000000000 +0100
@@ -0,0 +1,271 @@
+/*
+ * Copyright (C) 1992 Krishna Balasubramanian and Linus Torvalds
+ * Copyright (C) 1999 Ingo Molnar <mingo@redhat.com>
+ * Copyright (C) 2002 Andi Kleen
+ *
+ * This handles calls from both 32bit and 64bit mode.
+ */
+
+#include <linux/errno.h>
+#include <linux/gfp.h>
+#include <linux/sched.h>
+#include <linux/string.h>
+#include <linux/mm.h>
+#include <linux/smp.h>
+#include <linux/vmalloc.h>
+#include <linux/uaccess.h>
+
+#include <asm/system.h>
+#include <asm/ldt.h>
+#include <asm/desc.h>
+#include <asm/mmu_context.h>
+#include <asm/syscalls.h>
+
+#ifdef CONFIG_SMP
+static void flush_ldt(void *current_mm)
+{
+	if (current->active_mm == current_mm)
+		load_LDT(&current->active_mm->context);
+}
+#endif
+
+static int alloc_ldt(mm_context_t *pc, int mincount, int reload)
+{
+	void *oldldt, *newldt;
+	int oldsize;
+
+	if (mincount <= pc->size)
+		return 0;
+	oldsize = pc->size;
+	mincount = (mincount + (PAGE_SIZE / LDT_ENTRY_SIZE - 1)) &
+			(~(PAGE_SIZE / LDT_ENTRY_SIZE - 1));
+	if (mincount * LDT_ENTRY_SIZE > PAGE_SIZE)
+		newldt = vmalloc(mincount * LDT_ENTRY_SIZE);
+	else
+		newldt = (void *)__get_free_page(GFP_KERNEL);
+
+	if (!newldt)
+		return -ENOMEM;
+
+	if (oldsize)
+		memcpy(newldt, pc->ldt, oldsize * LDT_ENTRY_SIZE);
+	oldldt = pc->ldt;
+	memset(newldt + oldsize * LDT_ENTRY_SIZE, 0,
+	       (mincount - oldsize) * LDT_ENTRY_SIZE);
+
+	paravirt_alloc_ldt(newldt, mincount);
+
+#ifdef CONFIG_X86_64
+	/* CHECKME: Do we really need this ? */
+	wmb();
+#endif
+	pc->ldt = newldt;
+	wmb();
+	pc->size = mincount;
+	wmb();
+
+	if (reload) {
+#ifdef CONFIG_SMP
+		preempt_disable();
+		load_LDT(pc);
+		if (!cpumask_equal(mm_cpumask(current->mm),
+				   cpumask_of(smp_processor_id())))
+			smp_call_function(flush_ldt, current->mm, 1);
+		preempt_enable();
+#else
+		load_LDT(pc);
+#endif
+	}
+	if (oldsize) {
+		paravirt_free_ldt(oldldt, oldsize);
+		if (oldsize * LDT_ENTRY_SIZE > PAGE_SIZE)
+			vfree(oldldt);
+		else
+			put_page(virt_to_page(oldldt));
+	}
+	return 0;
+}
+
+static inline int copy_ldt(mm_context_t *new, mm_context_t *old)
+{
+	int err = alloc_ldt(new, old->size, 0);
+	int i;
+
+	if (err < 0)
+		return err;
+
+	for (i = 0; i < old->size; i++)
+		write_ldt_entry(new->ldt, i, old->ldt + i * LDT_ENTRY_SIZE);
+	return 0;
+}
+
+/*
+ * we do not have to muck with descriptors here, that is
+ * done in switch_mm() as needed.
+ */
+int init_new_context(struct task_struct *tsk, struct mm_struct *mm)
+{
+	struct mm_struct *old_mm;
+	int retval = 0;
+
+	mutex_init(&mm->context.lock);
+	mm->context.size = 0;
+	old_mm = current->mm;
+	if (old_mm && old_mm->context.size > 0) {
+		mutex_lock(&old_mm->context.lock);
+		retval = copy_ldt(&mm->context, &old_mm->context);
+		mutex_unlock(&old_mm->context.lock);
+	}
+	return retval;
+}
+
+/*
+ * No need to lock the MM as we are the last user
+ *
+ * 64bit: Don't touch the LDT register - we're already in the next thread.
+ */
+void destroy_context(struct mm_struct *mm)
+{
+	if (mm->context.size) {
+#ifdef CONFIG_X86_32
+		/* CHECKME: Can this ever happen ? */
+		if (mm == current->active_mm)
+			clear_LDT();
+#endif
+		paravirt_free_ldt(mm->context.ldt, mm->context.size);
+		if (mm->context.size * LDT_ENTRY_SIZE > PAGE_SIZE)
+			vfree(mm->context.ldt);
+		else
+			put_page(virt_to_page(mm->context.ldt));
+		mm->context.size = 0;
+	}
+}
+
+static int read_ldt(void __user *ptr, unsigned long bytecount)
+{
+	int err;
+	unsigned long size;
+	struct mm_struct *mm = current->mm;
+
+	if (!mm->context.size)
+		return 0;
+	if (bytecount > LDT_ENTRY_SIZE * LDT_ENTRIES)
+		bytecount = LDT_ENTRY_SIZE * LDT_ENTRIES;
+
+	mutex_lock(&mm->context.lock);
+	size = mm->context.size * LDT_ENTRY_SIZE;
+	if (size > bytecount)
+		size = bytecount;
+
+	err = 0;
+	if (copy_to_user(ptr, mm->context.ldt, size))
+		err = -EFAULT;
+	mutex_unlock(&mm->context.lock);
+	if (err < 0)
+		goto error_return;
+	if (size != bytecount) {
+		/* zero-fill the rest */
+		if (clear_user(ptr + size, bytecount - size) != 0) {
+			err = -EFAULT;
+			goto error_return;
+		}
+	}
+	return bytecount;
+error_return:
+	return err;
+}
+
+static int read_default_ldt(void __user *ptr, unsigned long bytecount)
+{
+	/* CHECKME: Can we use _one_ random number ? */
+#ifdef CONFIG_X86_32
+	unsigned long size = 5 * sizeof(struct desc_struct);
+#else
+	unsigned long size = 128;
+#endif
+	if (bytecount > size)
+		bytecount = size;
+	if (clear_user(ptr, bytecount))
+		return -EFAULT;
+	return bytecount;
+}
+
+static int write_ldt(void __user *ptr, unsigned long bytecount, int oldmode)
+{
+	struct mm_struct *mm = current->mm;
+	struct desc_struct ldt;
+	int error;
+	struct user_desc ldt_info;
+
+	error = -EINVAL;
+	if (bytecount != sizeof(ldt_info))
+		goto out;
+	error = -EFAULT;
+	if (copy_from_user(&ldt_info, ptr, sizeof(ldt_info)))
+		goto out;
+
+	error = -EINVAL;
+	if (ldt_info.entry_number >= LDT_ENTRIES)
+		goto out;
+	if (ldt_info.contents == 3) {
+		if (oldmode)
+			goto out;
+		if (ldt_info.seg_not_present == 0)
+			goto out;
+	}
+
+	mutex_lock(&mm->context.lock);
+	if (ldt_info.entry_number >= mm->context.size) {
+		error = alloc_ldt(&current->mm->context,
+				  ldt_info.entry_number + 1, 1);
+		if (error < 0)
+			goto out_unlock;
+	}
+
+	/* Allow LDTs to be cleared by the user. */
+	if (ldt_info.base_addr == 0 && ldt_info.limit == 0) {
+		if (oldmode || LDT_empty(&ldt_info)) {
+			memset(&ldt, 0, sizeof(ldt));
+			goto install;
+		}
+	}
+
+	fill_ldt(&ldt, &ldt_info);
+	if (oldmode)
+		ldt.avl = 0;
+
+	/* Install the new entry ...  */
+install:
+	write_ldt_entry(mm->context.ldt, ldt_info.entry_number, &ldt);
+	error = 0;
+
+out_unlock:
+	mutex_unlock(&mm->context.lock);
+out:
+	return error;
+}
+
+asmlinkage int sys_modify_ldt(int func, void __user *ptr,
+			      unsigned long bytecount)
+{
+	int ret = -ENOSYS;
+
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|modify_ldt");
+
+	switch (func) {
+	case 0:
+		ret = read_ldt(ptr, bytecount);
+		break;
+	case 1:
+		ret = write_ldt(ptr, bytecount, 1);
+		break;
+	case 2:
+		ret = read_default_ldt(ptr, bytecount);
+		break;
+	case 0x11:
+		ret = write_ldt(ptr, bytecount, 0);
+		break;
+	}
+	return ret;
+}
diff -Naur linux-source-2.6.38.orig/kernel/module.c linux-source-2.6.38.modif/kernel/module.c
--- linux-source-2.6.38.orig/kernel/module.c	2011-09-28 16:24:41.000000000 +0200
+++ linux-source-2.6.38.modif/kernel/module.c	2011-12-16 14:11:35.000000000 +0100
@@ -755,6 +755,9 @@
 	char name[MODULE_NAME_LEN];
 	int ret, forced = 0;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|delete_module");
+
 	if (!capable(CAP_SYS_MODULE) || modules_disabled)
 		return -EPERM;
 
@@ -2864,6 +2867,9 @@
 	struct module *mod;
 	int ret = 0;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|init_module");
+
 	/* Must have permission */
 	if (!capable(CAP_SYS_MODULE) || modules_disabled)
 		return -EPERM;
diff -Naur linux-source-2.6.38.orig/kernel/perf_event.c linux-source-2.6.38.modif/kernel/perf_event.c
--- linux-source-2.6.38.orig/kernel/perf_event.c	2011-09-28 16:24:41.000000000 +0200
+++ linux-source-2.6.38.modif/kernel/perf_event.c	2011-12-16 14:12:12.000000000 +0100
@@ -5827,6 +5827,9 @@
 	int fput_needed = 0;
 	int err;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|perf_event_open");
+
 	/* for future expandability... */
 	if (flags & ~(PERF_FLAG_FD_NO_GROUP | PERF_FLAG_FD_OUTPUT))
 		return -EINVAL;
diff -Naur linux-source-2.6.38.orig/kernel/posix-timers.c linux-source-2.6.38.modif/kernel/posix-timers.c
--- linux-source-2.6.38.orig/kernel/posix-timers.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/kernel/posix-timers.c	2011-12-16 14:15:08.000000000 +0100
@@ -534,6 +534,9 @@
 	sigevent_t event;
 	int it_id_set = IT_ID_NOT_SET;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|timer_create");
+
 	if (invalid_clockid(which_clock))
 		return -EINVAL;
 
@@ -713,6 +716,9 @@
 	struct itimerspec cur_setting;
 	unsigned long flags;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|timer_gettime");
+
 	timr = lock_timer(timer_id, &flags);
 	if (!timr)
 		return -EINVAL;
@@ -742,6 +748,9 @@
 	int overrun;
 	unsigned long flags;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|timer_getoverrun");
+
 	timr = lock_timer(timer_id, &flags);
 	if (!timr)
 		return -EINVAL;
@@ -814,6 +823,9 @@
 	unsigned long flag;
 	struct itimerspec *rtn = old_setting ? &old_spec : NULL;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|timer_settime");
+
 	if (!new_setting)
 		return -EINVAL;
 
@@ -864,6 +876,9 @@
 	struct k_itimer *timer;
 	unsigned long flags;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|timer_delete");
+
 retry_delete:
 	timer = lock_timer(timer_id, &flags);
 	if (!timer)
@@ -950,6 +965,9 @@
 {
 	struct timespec new_tp;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|clock_settime");
+
 	if (invalid_clockid(which_clock))
 		return -EINVAL;
 	if (copy_from_user(&new_tp, tp, sizeof (*tp)))
@@ -964,6 +982,9 @@
 	struct timespec kernel_tp;
 	int error;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|clock_gettime");
+
 	if (invalid_clockid(which_clock))
 		return -EINVAL;
 	error = CLOCK_DISPATCH(which_clock, clock_get,
@@ -981,6 +1002,9 @@
 	struct timespec rtn_tp;
 	int error;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|clock_getres");
+
 	if (invalid_clockid(which_clock))
 		return -EINVAL;
 
@@ -1011,6 +1035,9 @@
 {
 	struct timespec t;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|clock_nanosleep");
+
 	if (invalid_clockid(which_clock))
 		return -EINVAL;
 
diff -Naur linux-source-2.6.38.orig/kernel/process.c linux-source-2.6.38.modif/kernel/process.c
--- linux-source-2.6.38.orig/kernel/process.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-source-2.6.38.modif/kernel/process.c	2011-12-16 12:29:19.000000000 +0100
@@ -0,0 +1,705 @@
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/mm.h>
+#include <linux/smp.h>
+#include <linux/prctl.h>
+#include <linux/slab.h>
+#include <linux/sched.h>
+#include <linux/module.h>
+#include <linux/pm.h>
+#include <linux/clockchips.h>
+#include <linux/random.h>
+#include <linux/user-return-notifier.h>
+#include <linux/dmi.h>
+#include <linux/utsname.h>
+#include <trace/events/power.h>
+#include <linux/hw_breakpoint.h>
+#include <asm/cpu.h>
+#include <asm/system.h>
+#include <asm/apic.h>
+#include <asm/syscalls.h>
+#include <asm/idle.h>
+#include <asm/uaccess.h>
+#include <asm/i387.h>
+#include <asm/debugreg.h>
+
+struct kmem_cache *task_xstate_cachep;
+EXPORT_SYMBOL_GPL(task_xstate_cachep);
+
+int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src)
+{
+	int ret;
+
+	*dst = *src;
+	if (fpu_allocated(&src->thread.fpu)) {
+		memset(&dst->thread.fpu, 0, sizeof(dst->thread.fpu));
+		ret = fpu_alloc(&dst->thread.fpu);
+		if (ret)
+			return ret;
+		fpu_copy(&dst->thread.fpu, &src->thread.fpu);
+	}
+	return 0;
+}
+
+void free_thread_xstate(struct task_struct *tsk)
+{
+	fpu_free(&tsk->thread.fpu);
+}
+
+void free_thread_info(struct thread_info *ti)
+{
+	free_thread_xstate(ti->task);
+	free_pages((unsigned long)ti, get_order(THREAD_SIZE));
+}
+
+void arch_task_cache_init(void)
+{
+        task_xstate_cachep =
+        	kmem_cache_create("task_xstate", xstate_size,
+				  __alignof__(union thread_xstate),
+				  SLAB_PANIC | SLAB_NOTRACK, NULL);
+}
+
+/*
+ * Free current thread data structures etc..
+ */
+void exit_thread(void)
+{
+	struct task_struct *me = current;
+	struct thread_struct *t = &me->thread;
+	unsigned long *bp = t->io_bitmap_ptr;
+
+	if (bp) {
+		struct tss_struct *tss = &per_cpu(init_tss, get_cpu());
+
+		t->io_bitmap_ptr = NULL;
+		clear_thread_flag(TIF_IO_BITMAP);
+		/*
+		 * Careful, clear this in the TSS too:
+		 */
+		memset(tss->io_bitmap, 0xff, t->io_bitmap_max);
+		t->io_bitmap_max = 0;
+		put_cpu();
+		kfree(bp);
+	}
+}
+
+void show_regs(struct pt_regs *regs)
+{
+	show_registers(regs);
+	show_trace(NULL, regs, (unsigned long *)kernel_stack_pointer(regs));
+}
+
+void show_regs_common(void)
+{
+	const char *vendor, *product, *board;
+
+	vendor = dmi_get_system_info(DMI_SYS_VENDOR);
+	if (!vendor)
+		vendor = "";
+	product = dmi_get_system_info(DMI_PRODUCT_NAME);
+	if (!product)
+		product = "";
+
+	/* Board Name is optional */
+	board = dmi_get_system_info(DMI_BOARD_NAME);
+
+	printk(KERN_CONT "\n");
+	printk(KERN_DEFAULT "Pid: %d, comm: %.20s %s %s %.*s",
+		current->pid, current->comm, print_tainted(),
+		init_utsname()->release,
+		(int)strcspn(init_utsname()->version, " "),
+		init_utsname()->version);
+	printk(KERN_CONT " ");
+	printk(KERN_CONT "%s %s", vendor, product);
+	if (board) {
+		printk(KERN_CONT "/");
+		printk(KERN_CONT "%s", board);
+	}
+	printk(KERN_CONT "\n");
+}
+
+void flush_thread(void)
+{
+	struct task_struct *tsk = current;
+
+	flush_ptrace_hw_breakpoint(tsk);
+	memset(tsk->thread.tls_array, 0, sizeof(tsk->thread.tls_array));
+	/*
+	 * Forget coprocessor state..
+	 */
+	tsk->fpu_counter = 0;
+	clear_fpu(tsk);
+	clear_used_math();
+}
+
+static void hard_disable_TSC(void)
+{
+	write_cr4(read_cr4() | X86_CR4_TSD);
+}
+
+void disable_TSC(void)
+{
+	preempt_disable();
+	if (!test_and_set_thread_flag(TIF_NOTSC))
+		/*
+		 * Must flip the CPU state synchronously with
+		 * TIF_NOTSC in the current running context.
+		 */
+		hard_disable_TSC();
+	preempt_enable();
+}
+
+static void hard_enable_TSC(void)
+{
+	write_cr4(read_cr4() & ~X86_CR4_TSD);
+}
+
+static void enable_TSC(void)
+{
+	preempt_disable();
+	if (test_and_clear_thread_flag(TIF_NOTSC))
+		/*
+		 * Must flip the CPU state synchronously with
+		 * TIF_NOTSC in the current running context.
+		 */
+		hard_enable_TSC();
+	preempt_enable();
+}
+
+int get_tsc_mode(unsigned long adr)
+{
+	unsigned int val;
+
+	if (test_thread_flag(TIF_NOTSC))
+		val = PR_TSC_SIGSEGV;
+	else
+		val = PR_TSC_ENABLE;
+
+	return put_user(val, (unsigned int __user *)adr);
+}
+
+int set_tsc_mode(unsigned int val)
+{
+	if (val == PR_TSC_SIGSEGV)
+		disable_TSC();
+	else if (val == PR_TSC_ENABLE)
+		enable_TSC();
+	else
+		return -EINVAL;
+
+	return 0;
+}
+
+void __switch_to_xtra(struct task_struct *prev_p, struct task_struct *next_p,
+		      struct tss_struct *tss)
+{
+	struct thread_struct *prev, *next;
+
+	prev = &prev_p->thread;
+	next = &next_p->thread;
+
+	if (test_tsk_thread_flag(prev_p, TIF_BLOCKSTEP) ^
+	    test_tsk_thread_flag(next_p, TIF_BLOCKSTEP)) {
+		unsigned long debugctl = get_debugctlmsr();
+
+		debugctl &= ~DEBUGCTLMSR_BTF;
+		if (test_tsk_thread_flag(next_p, TIF_BLOCKSTEP))
+			debugctl |= DEBUGCTLMSR_BTF;
+
+		update_debugctlmsr(debugctl);
+	}
+
+	if (test_tsk_thread_flag(prev_p, TIF_NOTSC) ^
+	    test_tsk_thread_flag(next_p, TIF_NOTSC)) {
+		/* prev and next are different */
+		if (test_tsk_thread_flag(next_p, TIF_NOTSC))
+			hard_disable_TSC();
+		else
+			hard_enable_TSC();
+	}
+
+	if (test_tsk_thread_flag(next_p, TIF_IO_BITMAP)) {
+		/*
+		 * Copy the relevant range of the IO bitmap.
+		 * Normally this is 128 bytes or less:
+		 */
+		memcpy(tss->io_bitmap, next->io_bitmap_ptr,
+		       max(prev->io_bitmap_max, next->io_bitmap_max));
+	} else if (test_tsk_thread_flag(prev_p, TIF_IO_BITMAP)) {
+		/*
+		 * Clear any possible leftover bits:
+		 */
+		memset(tss->io_bitmap, 0xff, prev->io_bitmap_max);
+	}
+	propagate_user_return_notify(prev_p, next_p);
+}
+
+int sys_fork(struct pt_regs *regs)
+{
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|fork");
+
+	return do_fork(SIGCHLD, regs->sp, regs, 0, NULL, NULL);
+}
+
+/*
+ * This is trivial, and on the face of it looks like it
+ * could equally well be done in user mode.
+ *
+ * Not so, for quite unobvious reasons - register pressure.
+ * In user mode vfork() cannot have a stack frame, and if
+ * done by calling the "clone()" system call directly, you
+ * do not have enough call-clobbered registers to hold all
+ * the information you need.
+ */
+int sys_vfork(struct pt_regs *regs)
+{
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|vfork");
+
+	return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs->sp, regs, 0,
+		       NULL, NULL);
+}
+
+long
+sys_clone(unsigned long clone_flags, unsigned long newsp,
+	  void __user *parent_tid, void __user *child_tid, struct pt_regs *regs)
+{
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|clone");
+
+	if (!newsp)
+		newsp = regs->sp;
+	return do_fork(clone_flags, newsp, regs, 0, parent_tid, child_tid);
+}
+
+/*
+ * This gets run with %si containing the
+ * function to call, and %di containing
+ * the "args".
+ */
+extern void kernel_thread_helper(void);
+
+/*
+ * Create a kernel thread
+ */
+int kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
+{
+	struct pt_regs regs;
+
+	memset(&regs, 0, sizeof(regs));
+
+	regs.si = (unsigned long) fn;
+	regs.di = (unsigned long) arg;
+
+#ifdef CONFIG_X86_32
+	regs.ds = __USER_DS;
+	regs.es = __USER_DS;
+	regs.fs = __KERNEL_PERCPU;
+	regs.gs = __KERNEL_STACK_CANARY;
+#else
+	regs.ss = __KERNEL_DS;
+#endif
+
+	regs.orig_ax = -1;
+	regs.ip = (unsigned long) kernel_thread_helper;
+	regs.cs = __KERNEL_CS | get_kernel_rpl();
+	regs.flags = X86_EFLAGS_IF | 0x2;
+
+	/* Ok, create the new process.. */
+	return do_fork(flags | CLONE_VM | CLONE_UNTRACED, 0, &regs, 0, NULL, NULL);
+}
+EXPORT_SYMBOL(kernel_thread);
+
+/*
+ * sys_execve() executes a new program.
+ */
+long sys_execve(const char __user *name,
+		const char __user *const __user *argv,
+		const char __user *const __user *envp, struct pt_regs *regs)
+{
+	long error;
+	char *filename;
+
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|execve");
+
+	filename = getname(name);
+	error = PTR_ERR(filename);
+	if (IS_ERR(filename))
+		return error;
+	error = do_execve(filename, argv, envp, regs);
+
+#ifdef CONFIG_X86_32
+	if (error == 0) {
+		/* Make sure we don't return using sysenter.. */
+                set_thread_flag(TIF_IRET);
+        }
+#endif
+
+	putname(filename);
+	return error;
+}
+
+/*
+ * Idle related variables and functions
+ */
+unsigned long boot_option_idle_override = IDLE_NO_OVERRIDE;
+EXPORT_SYMBOL(boot_option_idle_override);
+
+/*
+ * Powermanagement idle function, if any..
+ */
+void (*pm_idle)(void);
+EXPORT_SYMBOL(pm_idle);
+
+#ifdef CONFIG_X86_32
+/*
+ * This halt magic was a workaround for ancient floppy DMA
+ * wreckage. It should be safe to remove.
+ */
+static int hlt_counter;
+void disable_hlt(void)
+{
+	hlt_counter++;
+}
+EXPORT_SYMBOL(disable_hlt);
+
+void enable_hlt(void)
+{
+	hlt_counter--;
+}
+EXPORT_SYMBOL(enable_hlt);
+
+static inline int hlt_use_halt(void)
+{
+	return (!hlt_counter && boot_cpu_data.hlt_works_ok);
+}
+#else
+static inline int hlt_use_halt(void)
+{
+	return 1;
+}
+#endif
+
+/*
+ * We use this if we don't have any better
+ * idle routine..
+ */
+void default_idle(void)
+{
+	if (hlt_use_halt()) {
+		trace_power_start(POWER_CSTATE, 1, smp_processor_id());
+		trace_cpu_idle(1, smp_processor_id());
+		current_thread_info()->status &= ~TS_POLLING;
+		/*
+		 * TS_POLLING-cleared state must be visible before we
+		 * test NEED_RESCHED:
+		 */
+		smp_mb();
+
+		if (!need_resched())
+			safe_halt();	/* enables interrupts racelessly */
+		else
+			local_irq_enable();
+		current_thread_info()->status |= TS_POLLING;
+		trace_power_end(smp_processor_id());
+		trace_cpu_idle(PWR_EVENT_EXIT, smp_processor_id());
+	} else {
+		local_irq_enable();
+		/* loop is done by the caller */
+		cpu_relax();
+	}
+}
+#ifdef CONFIG_APM_MODULE
+EXPORT_SYMBOL(default_idle);
+#endif
+
+void stop_this_cpu(void *dummy)
+{
+	local_irq_disable();
+	/*
+	 * Remove this CPU:
+	 */
+	set_cpu_online(smp_processor_id(), false);
+	disable_local_APIC();
+
+	for (;;) {
+		if (hlt_works(smp_processor_id()))
+			halt();
+	}
+}
+
+static void do_nothing(void *unused)
+{
+}
+
+/*
+ * cpu_idle_wait - Used to ensure that all the CPUs discard old value of
+ * pm_idle and update to new pm_idle value. Required while changing pm_idle
+ * handler on SMP systems.
+ *
+ * Caller must have changed pm_idle to the new value before the call. Old
+ * pm_idle value will not be used by any CPU after the return of this function.
+ */
+void cpu_idle_wait(void)
+{
+	smp_mb();
+	/* kick all the CPUs so that they exit out of pm_idle */
+	smp_call_function(do_nothing, NULL, 1);
+}
+EXPORT_SYMBOL_GPL(cpu_idle_wait);
+
+/*
+ * This uses new MONITOR/MWAIT instructions on P4 processors with PNI,
+ * which can obviate IPI to trigger checking of need_resched.
+ * We execute MONITOR against need_resched and enter optimized wait state
+ * through MWAIT. Whenever someone changes need_resched, we would be woken
+ * up from MWAIT (without an IPI).
+ *
+ * New with Core Duo processors, MWAIT can take some hints based on CPU
+ * capability.
+ */
+void mwait_idle_with_hints(unsigned long ax, unsigned long cx)
+{
+	if (!need_resched()) {
+		if (cpu_has(__this_cpu_ptr(&cpu_info), X86_FEATURE_CLFLUSH_MONITOR))
+			clflush((void *)&current_thread_info()->flags);
+
+		__monitor((void *)&current_thread_info()->flags, 0, 0);
+		smp_mb();
+		if (!need_resched())
+			__mwait(ax, cx);
+	}
+}
+
+/* Default MONITOR/MWAIT with no hints, used for default C1 state */
+static void mwait_idle(void)
+{
+	if (!need_resched()) {
+		trace_power_start(POWER_CSTATE, 1, smp_processor_id());
+		trace_cpu_idle(1, smp_processor_id());
+		if (cpu_has(__this_cpu_ptr(&cpu_info), X86_FEATURE_CLFLUSH_MONITOR))
+			clflush((void *)&current_thread_info()->flags);
+
+		__monitor((void *)&current_thread_info()->flags, 0, 0);
+		smp_mb();
+		if (!need_resched())
+			__sti_mwait(0, 0);
+		else
+			local_irq_enable();
+		trace_power_end(smp_processor_id());
+		trace_cpu_idle(PWR_EVENT_EXIT, smp_processor_id());
+	} else
+		local_irq_enable();
+}
+
+/*
+ * On SMP it's slightly faster (but much more power-consuming!)
+ * to poll the ->work.need_resched flag instead of waiting for the
+ * cross-CPU IPI to arrive. Use this option with caution.
+ */
+static void poll_idle(void)
+{
+	trace_power_start(POWER_CSTATE, 0, smp_processor_id());
+	trace_cpu_idle(0, smp_processor_id());
+	local_irq_enable();
+	while (!need_resched())
+		cpu_relax();
+	trace_power_end(smp_processor_id());
+	trace_cpu_idle(PWR_EVENT_EXIT, smp_processor_id());
+}
+
+/*
+ * mwait selection logic:
+ *
+ * It depends on the CPU. For AMD CPUs that support MWAIT this is
+ * wrong. Family 0x10 and 0x11 CPUs will enter C1 on HLT. Powersavings
+ * then depend on a clock divisor and current Pstate of the core. If
+ * all cores of a processor are in halt state (C1) the processor can
+ * enter the C1E (C1 enhanced) state. If mwait is used this will never
+ * happen.
+ *
+ * idle=mwait overrides this decision and forces the usage of mwait.
+ */
+
+#define MWAIT_INFO			0x05
+#define MWAIT_ECX_EXTENDED_INFO		0x01
+#define MWAIT_EDX_C1			0xf0
+
+int mwait_usable(const struct cpuinfo_x86 *c)
+{
+	u32 eax, ebx, ecx, edx;
+
+	if (boot_option_idle_override == IDLE_FORCE_MWAIT)
+		return 1;
+
+	if (c->cpuid_level < MWAIT_INFO)
+		return 0;
+
+	cpuid(MWAIT_INFO, &eax, &ebx, &ecx, &edx);
+	/* Check, whether EDX has extended info about MWAIT */
+	if (!(ecx & MWAIT_ECX_EXTENDED_INFO))
+		return 1;
+
+	/*
+	 * edx enumeratios MONITOR/MWAIT extensions. Check, whether
+	 * C1  supports MWAIT
+	 */
+	return (edx & MWAIT_EDX_C1);
+}
+
+bool c1e_detected;
+EXPORT_SYMBOL(c1e_detected);
+
+static cpumask_var_t c1e_mask;
+
+void c1e_remove_cpu(int cpu)
+{
+	if (c1e_mask != NULL)
+		cpumask_clear_cpu(cpu, c1e_mask);
+}
+
+/*
+ * C1E aware idle routine. We check for C1E active in the interrupt
+ * pending message MSR. If we detect C1E, then we handle it the same
+ * way as C3 power states (local apic timer and TSC stop)
+ */
+static void c1e_idle(void)
+{
+	if (need_resched())
+		return;
+
+	if (!c1e_detected) {
+		u32 lo, hi;
+
+		rdmsr(MSR_K8_INT_PENDING_MSG, lo, hi);
+
+		if (lo & K8_INTP_C1E_ACTIVE_MASK) {
+			c1e_detected = true;
+			if (!boot_cpu_has(X86_FEATURE_NONSTOP_TSC))
+				mark_tsc_unstable("TSC halt in AMD C1E");
+			printk(KERN_INFO "System has AMD C1E enabled\n");
+		}
+	}
+
+	if (c1e_detected) {
+		int cpu = smp_processor_id();
+
+		if (!cpumask_test_cpu(cpu, c1e_mask)) {
+			cpumask_set_cpu(cpu, c1e_mask);
+			/*
+			 * Force broadcast so ACPI can not interfere.
+			 */
+			clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_FORCE,
+					   &cpu);
+			printk(KERN_INFO "Switch to broadcast mode on CPU%d\n",
+			       cpu);
+		}
+		clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_ENTER, &cpu);
+
+		default_idle();
+
+		/*
+		 * The switch back from broadcast mode needs to be
+		 * called with interrupts disabled.
+		 */
+		 local_irq_disable();
+		 clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_EXIT, &cpu);
+		 local_irq_enable();
+	} else
+		default_idle();
+}
+
+void __cpuinit select_idle_routine(const struct cpuinfo_x86 *c)
+{
+#ifdef CONFIG_SMP
+	if (pm_idle == poll_idle && smp_num_siblings > 1) {
+		printk_once(KERN_WARNING "WARNING: polling idle and HT enabled,"
+			" performance may degrade.\n");
+	}
+#endif
+	if (pm_idle)
+		return;
+
+	if (cpu_has(c, X86_FEATURE_MWAIT) && mwait_usable(c)) {
+		/*
+		 * One CPU supports mwait => All CPUs supports mwait
+		 */
+		printk(KERN_INFO "using mwait in idle threads.\n");
+		pm_idle = mwait_idle;
+	} else if (cpu_has_amd_erratum(amd_erratum_400)) {
+		/* E400: APIC timer interrupt does not wake up CPU from C1e */
+		printk(KERN_INFO "using C1E aware idle routine\n");
+		pm_idle = c1e_idle;
+	} else
+		pm_idle = default_idle;
+}
+
+void __init init_c1e_mask(void)
+{
+	/* If we're using c1e_idle, we need to allocate c1e_mask. */
+	if (pm_idle == c1e_idle)
+		zalloc_cpumask_var(&c1e_mask, GFP_KERNEL);
+}
+
+static int __init idle_setup(char *str)
+{
+	if (!str)
+		return -EINVAL;
+
+	if (!strcmp(str, "poll")) {
+		printk("using polling idle threads.\n");
+		pm_idle = poll_idle;
+		boot_option_idle_override = IDLE_POLL;
+	} else if (!strcmp(str, "mwait")) {
+		boot_option_idle_override = IDLE_FORCE_MWAIT;
+	} else if (!strcmp(str, "halt")) {
+		/*
+		 * When the boot option of idle=halt is added, halt is
+		 * forced to be used for CPU idle. In such case CPU C2/C3
+		 * won't be used again.
+		 * To continue to load the CPU idle driver, don't touch
+		 * the boot_option_idle_override.
+		 */
+		pm_idle = default_idle;
+		boot_option_idle_override = IDLE_HALT;
+	} else if (!strcmp(str, "nomwait")) {
+		/*
+		 * If the boot option of "idle=nomwait" is added,
+		 * it means that mwait will be disabled for CPU C2/C3
+		 * states. In such case it won't touch the variable
+		 * of boot_option_idle_override.
+		 */
+		boot_option_idle_override = IDLE_NOMWAIT;
+	} else
+		return -1;
+
+	return 0;
+}
+early_param("idle", idle_setup);
+
+unsigned long arch_align_stack(unsigned long sp)
+{
+	if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
+		sp -= get_random_int() % 8192;
+	return sp & ~0xf;
+}
+
+unsigned long arch_randomize_brk(struct mm_struct *mm)
+{
+	unsigned long range_end = mm->brk + 0x02000000;
+	unsigned long bump = 0;
+#ifdef CONFIG_X86_32
+	/* in the case of NX emulation, shove the brk segment way out of the
+	   way of the exec randomization area, since it can collide with
+	   future allocations if not. */
+	if ( (mm->get_unmapped_exec_area == arch_get_unmapped_exec_area) &&
+	     (mm->brk < 0x08000000) ) {
+		bump = (TASK_SIZE/6);
+	}
+#endif
+	return bump + (randomize_range(mm->brk, range_end, 0) ? : mm->brk);
+}
+
diff -Naur linux-source-2.6.38.orig/kernel/ptrace.c linux-source-2.6.38.modif/kernel/ptrace.c
--- linux-source-2.6.38.orig/kernel/ptrace.c	2011-09-28 16:24:41.000000000 +0200
+++ linux-source-2.6.38.modif/kernel/ptrace.c	2011-12-16 15:58:34.000000000 +0100
@@ -701,6 +701,9 @@
 	struct task_struct *child;
 	long ret;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|ptrace");
+
 	if (request == PTRACE_TRACEME) {
 		ret = ptrace_traceme();
 		if (!ret)
diff -Naur linux-source-2.6.38.orig/kernel/sched.c linux-source-2.6.38.modif/kernel/sched.c
--- linux-source-2.6.38.orig/kernel/sched.c	2011-09-28 16:24:41.000000000 +0200
+++ linux-source-2.6.38.modif/kernel/sched.c	2011-12-16 14:28:52.000000000 +0100
@@ -4655,6 +4655,9 @@
 {
 	long nice, retval;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|nice");
+
 	/*
 	 * Setpriority might change our priority at the same moment.
 	 * We don't have to worry. Conceptually one call occurs first
@@ -4979,6 +4982,9 @@
 SYSCALL_DEFINE3(sched_setscheduler, pid_t, pid, int, policy,
 		struct sched_param __user *, param)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|sched_setscheduler");
+
 	/* negative values for policy are not valid */
 	if (policy < 0)
 		return -EINVAL;
@@ -4993,6 +4999,9 @@
  */
 SYSCALL_DEFINE2(sched_setparam, pid_t, pid, struct sched_param __user *, param)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|sched_setparam");
+
 	return do_sched_setscheduler(pid, -1, param);
 }
 
@@ -5005,6 +5014,9 @@
 	struct task_struct *p;
 	int retval;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|sched_getscheduler");
+
 	if (pid < 0)
 		return -EINVAL;
 
@@ -5032,6 +5044,9 @@
 	struct task_struct *p;
 	int retval;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|sched_getparam");
+
 	if (!param || pid < 0)
 		return -EINVAL;
 
@@ -5146,6 +5161,9 @@
 	cpumask_var_t new_mask;
 	int retval;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|sched_setaffinity");
+
 	if (!alloc_cpumask_var(&new_mask, GFP_KERNEL))
 		return -ENOMEM;
 
@@ -5198,6 +5216,9 @@
 	int ret;
 	cpumask_var_t mask;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|sched_getaffinity");
+
 	if ((len * BITS_PER_BYTE) < nr_cpu_ids)
 		return -EINVAL;
 	if (len & (sizeof(unsigned long)-1))
@@ -5230,6 +5251,9 @@
 {
 	struct rq *rq = this_rq_lock();
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|sched_yield");
+
 	schedstat_inc(rq, yld_count);
 	current->sched_class->yield_task(rq);
 
@@ -5368,6 +5392,9 @@
 {
 	int ret = -EINVAL;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|sched_get_priority_max");
+
 	switch (policy) {
 	case SCHED_FIFO:
 	case SCHED_RR:
@@ -5393,6 +5420,9 @@
 {
 	int ret = -EINVAL;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|sched_get_priority_min");
+
 	switch (policy) {
 	case SCHED_FIFO:
 	case SCHED_RR:
@@ -5424,6 +5454,9 @@
 	int retval;
 	struct timespec t;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|sched_rr_get_interval");
+
 	if (pid < 0)
 		return -EINVAL;
 
diff -Naur linux-source-2.6.38.orig/kernel/signal.c linux-source-2.6.38.modif/kernel/signal.c
--- linux-source-2.6.38.orig/kernel/signal.c	2011-09-28 16:24:41.000000000 +0200
+++ linux-source-2.6.38.modif/kernel/signal.c	2011-12-16 16:43:52.000000000 +0100
@@ -2117,6 +2117,9 @@
 	int error = -EINVAL;
 	sigset_t old_set, new_set;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|rt_sigprocmask");
+
 	/* XXX: Don't preclude handling different sized sigset_t's.  */
 	if (sigsetsize != sizeof(sigset_t))
 		goto out;
@@ -2173,6 +2176,9 @@
 
 SYSCALL_DEFINE2(rt_sigpending, sigset_t __user *, set, size_t, sigsetsize)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|rt_sigpending");
+
 	return do_sigpending(set, sigsetsize);
 }
 
@@ -2260,6 +2266,9 @@
 	siginfo_t info;
 	long timeout = 0;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|rt_sigtimedwait");
+
 	/* XXX: Don't preclude handling different sized sigset_t's.  */
 	if (sigsetsize != sizeof(sigset_t))
 		return -EINVAL;
@@ -2329,6 +2338,9 @@
 {
 	struct siginfo info;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|kill");
+
 	info.si_signo = sig;
 	info.si_errno = 0;
 	info.si_code = SI_USER;
@@ -2393,6 +2405,9 @@
  */
 SYSCALL_DEFINE3(tgkill, pid_t, tgid, pid_t, pid, int, sig)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|tgkill");
+
 	/* This is only valid for single tasks */
 	if (pid <= 0 || tgid <= 0)
 		return -EINVAL;
@@ -2405,6 +2420,9 @@
  */
 SYSCALL_DEFINE2(tkill, pid_t, pid, int, sig)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|tkill");
+
 	/* This is only valid for single tasks */
 	if (pid <= 0)
 		return -EINVAL;
@@ -2415,6 +2433,9 @@
 SYSCALL_DEFINE3(rt_sigqueueinfo, pid_t, pid, int, sig,
 		siginfo_t __user *, uinfo)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|rt_sigqueueinfo");
+
 	siginfo_t info;
 
 	if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
@@ -2456,6 +2477,9 @@
 SYSCALL_DEFINE4(rt_tgsigqueueinfo, pid_t, tgid, pid_t, pid, int, sig,
 		siginfo_t __user *, uinfo)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|rt_tgsigqueueinfo");
+
 	siginfo_t info;
 
 	if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
@@ -2580,6 +2604,9 @@
 
 SYSCALL_DEFINE1(sigpending, old_sigset_t __user *, set)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|sigpending");
+
 	return do_sigpending(set, sizeof(*set));
 }
 
@@ -2595,6 +2622,9 @@
 	int error;
 	old_sigset_t old_set, new_set;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|sigprocmask");
+
 	if (set) {
 		error = -EFAULT;
 		if (copy_from_user(&new_set, set, sizeof(*set)))
@@ -2648,6 +2678,9 @@
 	struct k_sigaction new_sa, old_sa;
 	int ret = -EINVAL;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|rt_sigaction");
+
 	/* XXX: Don't preclude handling different sized sigset_t's.  */
 	if (sigsetsize != sizeof(sigset_t))
 		goto out;
@@ -2675,6 +2708,9 @@
  */
 SYSCALL_DEFINE0(sgetmask)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|sgetmask");
+
 	/* SMP safe */
 	return current->blocked.sig[0];
 }
@@ -2683,6 +2719,9 @@
 {
 	int old;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|ssetmask");
+
 	spin_lock_irq(&current->sighand->siglock);
 	old = current->blocked.sig[0];
 
@@ -2704,6 +2743,9 @@
 	struct k_sigaction new_sa, old_sa;
 	int ret;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|sys_signal");
+
 	new_sa.sa.sa_handler = handler;
 	new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
 	sigemptyset(&new_sa.sa.sa_mask);
diff -Naur linux-source-2.6.38.orig/kernel/sys.c linux-source-2.6.38.modif/kernel/sys.c
--- linux-source-2.6.38.orig/kernel/sys.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/kernel/sys.c	2011-12-16 15:43:54.000000000 +0100
@@ -156,6 +156,9 @@
 	int error = -EINVAL;
 	struct pid *pgrp;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|setpriority");
+
 	if (which > PRIO_USER || which < PRIO_PROCESS)
 		goto out;
 
@@ -223,6 +226,9 @@
 	long niceval, retval = -ESRCH;
 	struct pid *pgrp;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|getpriority");
+
 	if (which > PRIO_USER || which < PRIO_PROCESS)
 		return -EINVAL;
 
@@ -377,6 +383,9 @@
 	char buffer[256];
 	int ret = 0;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|reboot");
+
 	/* We only trust the superuser with rebooting the system. */
 	if (!capable(CAP_SYS_BOOT))
 		return -EPERM;
@@ -493,6 +502,9 @@
 	struct cred *new;
 	int retval;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|setregid");
+
 	new = prepare_creds();
 	if (!new)
 		return -ENOMEM;
@@ -540,6 +552,9 @@
 	struct cred *new;
 	int retval;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|setgid");
+
 	new = prepare_creds();
 	if (!new)
 		return -ENOMEM;
@@ -603,6 +618,9 @@
 	struct cred *new;
 	int retval;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|setreuid");
+
 	new = prepare_creds();
 	if (!new)
 		return -ENOMEM;
@@ -664,6 +682,9 @@
 	struct cred *new;
 	int retval;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|setuid");
+
 	new = prepare_creds();
 	if (!new)
 		return -ENOMEM;
@@ -705,6 +726,9 @@
 	struct cred *new;
 	int retval;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|setresuid");
+
 	new = prepare_creds();
 	if (!new)
 		return -ENOMEM;
@@ -754,6 +778,9 @@
 	const struct cred *cred = current_cred();
 	int retval;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|getresuid");
+
 	if (!(retval   = put_user(cred->uid,  ruid)) &&
 	    !(retval   = put_user(cred->euid, euid)))
 		retval = put_user(cred->suid, suid);
@@ -770,6 +797,9 @@
 	struct cred *new;
 	int retval;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|setresgid");
+
 	new = prepare_creds();
 	if (!new)
 		return -ENOMEM;
@@ -808,6 +838,9 @@
 	const struct cred *cred = current_cred();
 	int retval;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|getresgid");
+
 	if (!(retval   = put_user(cred->gid,  rgid)) &&
 	    !(retval   = put_user(cred->egid, egid)))
 		retval = put_user(cred->sgid, sgid);
@@ -828,6 +861,9 @@
 	struct cred *new;
 	uid_t old_fsuid;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|setfsuid");
+
 	new = prepare_creds();
 	if (!new)
 		return current_fsuid();
@@ -861,6 +897,9 @@
 	struct cred *new;
 	gid_t old_fsgid;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|setfsgid");
+
 	new = prepare_creds();
 	if (!new)
 		return current_fsgid();
@@ -901,6 +940,9 @@
 
 SYSCALL_DEFINE1(times, struct tms __user *, tbuf)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|times");
+
 	if (tbuf) {
 		struct tms tmp;
 
@@ -931,6 +973,9 @@
 	struct pid *pgrp;
 	int err;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|setpgid");
+
 	if (!pid)
 		pid = task_pid_vnr(group_leader);
 	if (!pgid)
@@ -1001,6 +1046,9 @@
 	struct pid *grp;
 	int retval;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|getpgid");
+
 	rcu_read_lock();
 	if (!pid)
 		grp = task_pgrp(current);
@@ -1027,6 +1075,9 @@
 
 SYSCALL_DEFINE0(getpgrp)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|getpgrp");
+
 	return sys_getpgid(0);
 }
 
@@ -1038,6 +1089,9 @@
 	struct pid *sid;
 	int retval;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|sys_getsid");
+
 	rcu_read_lock();
 	if (!pid)
 		sid = task_session(current);
@@ -1067,6 +1121,9 @@
 	pid_t session = pid_vnr(sid);
 	int err = -EPERM;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|setsid");
+
 	write_lock_irq(&tasklist_lock);
 	/* Fail if I am already a session leader */
 	if (group_leader->signal->leader)
@@ -1126,6 +1183,9 @@
 {
 	int error = 0;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|uname");
+
 	if (!name)
 		return -EFAULT;
 
@@ -1143,6 +1203,9 @@
 {
 	int error;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|olduname");
+
 	if (!name)
 		return -EFAULT;
 	if (!access_ok(VERIFY_WRITE, name, sizeof(struct oldold_utsname)))
@@ -1177,6 +1240,9 @@
 	int errno;
 	char tmp[__NEW_UTS_LEN];
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|sethostname");
+
 	if (!capable(CAP_SYS_ADMIN))
 		return -EPERM;
 	if (len < 0 || len > __NEW_UTS_LEN)
@@ -1226,6 +1292,10 @@
 	int errno;
 	char tmp[__NEW_UTS_LEN];
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|setdomainname");
+
+
 	if (!capable(CAP_SYS_ADMIN))
 		return -EPERM;
 	if (len < 0 || len > __NEW_UTS_LEN)
@@ -1249,6 +1319,9 @@
 	struct rlimit value;
 	int ret;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|getrlimit");
+
 	ret = do_prlimit(current, resource, NULL, &value);
 	if (!ret)
 		ret = copy_to_user(rlim, &value, sizeof(*rlim)) ? -EFAULT : 0;
@@ -1445,6 +1518,9 @@
 {
 	struct rlimit new_rlim;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|setrlimit");
+
 	if (copy_from_user(&new_rlim, rlim, sizeof(*rlim)))
 		return -EFAULT;
 	return do_prlimit(current, resource, &new_rlim, NULL);
@@ -1576,6 +1652,9 @@
 
 SYSCALL_DEFINE2(getrusage, int, who, struct rusage __user *, ru)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|getrusage");
+
 	if (who != RUSAGE_SELF && who != RUSAGE_CHILDREN &&
 	    who != RUSAGE_THREAD)
 		return -EINVAL;
@@ -1584,6 +1663,9 @@
 
 SYSCALL_DEFINE1(umask, int, mask)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|umask");
+
 	mask = xchg(&current->fs->umask, mask & S_IRWXUGO);
 	return mask;
 }
@@ -1595,6 +1677,9 @@
 	unsigned char comm[sizeof(me->comm)];
 	long error;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|prctl");
+
 	error = security_task_prctl(option, arg2, arg3, arg4, arg5);
 	if (error != -ENOSYS)
 		return error;
@@ -1748,6 +1833,9 @@
 {
 	int err = 0;
 	int cpu = raw_smp_processor_id();
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|getcpu");
+
 	if (cpup)
 		err |= put_user(cpu, cpup);
 	if (nodep)
diff -Naur linux-source-2.6.38.orig/kernel/sysctl_binary.c linux-source-2.6.38.modif/kernel/sysctl_binary.c
--- linux-source-2.6.38.orig/kernel/sysctl_binary.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/kernel/sysctl_binary.c	2011-12-16 15:41:44.000000000 +0100
@@ -1464,6 +1464,9 @@
 	size_t oldlen = 0;
 	ssize_t result;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|sysctl");
+
 	if (copy_from_user(&tmp, args, sizeof(tmp)))
 		return -EFAULT;
 
diff -Naur linux-source-2.6.38.orig/kernel/sys_i386_32.c linux-source-2.6.38.modif/kernel/sys_i386_32.c
--- linux-source-2.6.38.orig/kernel/sys_i386_32.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-source-2.6.38.modif/kernel/sys_i386_32.c	2011-03-15 02:20:32.000000000 +0100
@@ -0,0 +1,40 @@
+/*
+ * This file contains various random system calls that
+ * have a non-standard calling sequence on the Linux/i386
+ * platform.
+ */
+
+#include <linux/errno.h>
+#include <linux/sched.h>
+#include <linux/mm.h>
+#include <linux/fs.h>
+#include <linux/smp.h>
+#include <linux/sem.h>
+#include <linux/msg.h>
+#include <linux/shm.h>
+#include <linux/stat.h>
+#include <linux/syscalls.h>
+#include <linux/mman.h>
+#include <linux/file.h>
+#include <linux/utsname.h>
+#include <linux/ipc.h>
+
+#include <linux/uaccess.h>
+#include <linux/unistd.h>
+
+#include <asm/syscalls.h>
+
+/*
+ * Do a system call from kernel instead of calling sys_execve so we
+ * end up with proper pt_regs.
+ */
+int kernel_execve(const char *filename,
+		  const char *const argv[],
+		  const char *const envp[])
+{
+	long __res;
+	asm volatile ("int $0x80"
+	: "=a" (__res)
+	: "0" (__NR_execve), "b" (filename), "c" (argv), "d" (envp) : "memory");
+	return __res;
+}
diff -Naur linux-source-2.6.38.orig/kernel/time.c linux-source-2.6.38.modif/kernel/time.c
--- linux-source-2.6.38.orig/kernel/time.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/kernel/time.c	2011-12-16 15:27:24.000000000 +0100
@@ -61,6 +61,9 @@
  */
 SYSCALL_DEFINE1(time, time_t __user *, tloc)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|time");
+
 	time_t i = get_seconds();
 
 	if (tloc) {
@@ -83,6 +86,9 @@
 	struct timespec tv;
 	int err;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|stime");
+
 	if (get_user(tv.tv_sec, tptr))
 		return -EFAULT;
 
@@ -101,6 +107,9 @@
 SYSCALL_DEFINE2(gettimeofday, struct timeval __user *, tv,
 		struct timezone __user *, tz)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|gettimeofday");
+
 	if (likely(tv != NULL)) {
 		struct timeval ktv;
 		do_gettimeofday(&ktv);
@@ -189,6 +198,9 @@
 	struct timespec	new_ts;
 	struct timezone new_tz;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|settimeofday");
+
 	if (tv) {
 		if (copy_from_user(&user_tv, tv, sizeof(*tv)))
 			return -EFAULT;
@@ -208,6 +220,9 @@
 	struct timex txc;		/* Local copy of parameter */
 	int ret;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|adjtimex");
+
 	/* Copy the user data space into the kernel copy
 	 * structure. But bear in mind that the structures
 	 * may change
diff -Naur linux-source-2.6.38.orig/kernel/timer.c linux-source-2.6.38.modif/kernel/timer.c
--- linux-source-2.6.38.orig/kernel/timer.c	2011-09-28 16:24:41.000000000 +0200
+++ linux-source-2.6.38.modif/kernel/timer.c	2011-12-16 16:31:43.000000000 +0100
@@ -1325,6 +1325,9 @@
  */
 SYSCALL_DEFINE1(alarm, unsigned int, seconds)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|alarm");
+
 	return alarm_setitimer(seconds);
 }
 
@@ -1348,6 +1351,9 @@
  */
 SYSCALL_DEFINE0(getpid)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|getpid");
+
 	return task_tgid_vnr(current);
 }
 
@@ -1361,6 +1367,9 @@
 {
 	int pid;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|getppid");
+
 	rcu_read_lock();
 	pid = task_tgid_vnr(current->real_parent);
 	rcu_read_unlock();
@@ -1370,24 +1379,36 @@
 
 SYSCALL_DEFINE0(getuid)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|getuid");
+
 	/* Only we change this so SMP safe */
 	return current_uid();
 }
 
 SYSCALL_DEFINE0(geteuid)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|geteuid");
+
 	/* Only we change this so SMP safe */
 	return current_euid();
 }
 
 SYSCALL_DEFINE0(getgid)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|getgid");
+
 	/* Only we change this so SMP safe */
 	return current_gid();
 }
 
 SYSCALL_DEFINE0(getegid)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|getegid");
+
 	/* Only we change this so SMP safe */
 	return  current_egid();
 }
@@ -1504,6 +1525,9 @@
 /* Thread ID - the internal kernel "pid" */
 SYSCALL_DEFINE0(gettid)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|gettid");
+
 	return task_pid_vnr(current);
 }
 
@@ -1578,6 +1602,9 @@
 {
 	struct sysinfo val;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|sysinfo");
+
 	do_sysinfo(&val);
 
 	if (copy_to_user(info, &val, sizeof(struct sysinfo)))
diff -Naur linux-source-2.6.38.orig/kernel/vm86_32.c linux-source-2.6.38.modif/kernel/vm86_32.c
--- linux-source-2.6.38.orig/kernel/vm86_32.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-source-2.6.38.modif/kernel/vm86_32.c	2011-12-16 12:40:55.000000000 +0100
@@ -0,0 +1,851 @@
+/*
+ *  Copyright (C) 1994  Linus Torvalds
+ *
+ *  29 dec 2001 - Fixed oopses caused by unchecked access to the vm86
+ *                stack - Manfred Spraul <manfred@colorfullife.com>
+ *
+ *  22 mar 2002 - Manfred detected the stackfaults, but didn't handle
+ *                them correctly. Now the emulation will be in a
+ *                consistent state after stackfaults - Kasper Dupont
+ *                <kasperd@daimi.au.dk>
+ *
+ *  22 mar 2002 - Added missing clear_IF in set_vflags_* Kasper Dupont
+ *                <kasperd@daimi.au.dk>
+ *
+ *  ?? ??? 2002 - Fixed premature returns from handle_vm86_fault
+ *                caused by Kasper Dupont's changes - Stas Sergeev
+ *
+ *   4 apr 2002 - Fixed CHECK_IF_IN_TRAP broken by Stas' changes.
+ *                Kasper Dupont <kasperd@daimi.au.dk>
+ *
+ *   9 apr 2002 - Changed syntax of macros in handle_vm86_fault.
+ *                Kasper Dupont <kasperd@daimi.au.dk>
+ *
+ *   9 apr 2002 - Changed stack access macros to jump to a label
+ *                instead of returning to userspace. This simplifies
+ *                do_int, and is needed by handle_vm6_fault. Kasper
+ *                Dupont <kasperd@daimi.au.dk>
+ *
+ */
+
+#include <linux/capability.h>
+#include <linux/errno.h>
+#include <linux/interrupt.h>
+#include <linux/sched.h>
+#include <linux/kernel.h>
+#include <linux/signal.h>
+#include <linux/string.h>
+#include <linux/mm.h>
+#include <linux/smp.h>
+#include <linux/highmem.h>
+#include <linux/ptrace.h>
+#include <linux/audit.h>
+#include <linux/stddef.h>
+
+#include <asm/uaccess.h>
+#include <asm/io.h>
+#include <asm/tlbflush.h>
+#include <asm/irq.h>
+#include <asm/syscalls.h>
+
+/*
+ * Known problems:
+ *
+ * Interrupt handling is not guaranteed:
+ * - a real x86 will disable all interrupts for one instruction
+ *   after a "mov ss,xx" to make stack handling atomic even without
+ *   the 'lss' instruction. We can't guarantee this in v86 mode,
+ *   as the next instruction might result in a page fault or similar.
+ * - a real x86 will have interrupts disabled for one instruction
+ *   past the 'sti' that enables them. We don't bother with all the
+ *   details yet.
+ *
+ * Let's hope these problems do not actually matter for anything.
+ */
+
+
+#define KVM86	((struct kernel_vm86_struct *)regs)
+#define VMPI	KVM86->vm86plus
+
+
+/*
+ * 8- and 16-bit register defines..
+ */
+#define AL(regs)	(((unsigned char *)&((regs)->pt.ax))[0])
+#define AH(regs)	(((unsigned char *)&((regs)->pt.ax))[1])
+#define IP(regs)	(*(unsigned short *)&((regs)->pt.ip))
+#define SP(regs)	(*(unsigned short *)&((regs)->pt.sp))
+
+/*
+ * virtual flags (16 and 32-bit versions)
+ */
+#define VFLAGS	(*(unsigned short *)&(current->thread.v86flags))
+#define VEFLAGS	(current->thread.v86flags)
+
+#define set_flags(X, new, mask) \
+((X) = ((X) & ~(mask)) | ((new) & (mask)))
+
+#define SAFE_MASK	(0xDD5)
+#define RETURN_MASK	(0xDFF)
+
+/* convert kernel_vm86_regs to vm86_regs */
+static int copy_vm86_regs_to_user(struct vm86_regs __user *user,
+				  const struct kernel_vm86_regs *regs)
+{
+	int ret = 0;
+
+	/*
+	 * kernel_vm86_regs is missing gs, so copy everything up to
+	 * (but not including) orig_eax, and then rest including orig_eax.
+	 */
+	ret += copy_to_user(user, regs, offsetof(struct kernel_vm86_regs, pt.orig_ax));
+	ret += copy_to_user(&user->orig_eax, &regs->pt.orig_ax,
+			    sizeof(struct kernel_vm86_regs) -
+			    offsetof(struct kernel_vm86_regs, pt.orig_ax));
+
+	return ret;
+}
+
+/* convert vm86_regs to kernel_vm86_regs */
+static int copy_vm86_regs_from_user(struct kernel_vm86_regs *regs,
+				    const struct vm86_regs __user *user,
+				    unsigned extra)
+{
+	int ret = 0;
+
+	/* copy ax-fs inclusive */
+	ret += copy_from_user(regs, user, offsetof(struct kernel_vm86_regs, pt.orig_ax));
+	/* copy orig_ax-__gsh+extra */
+	ret += copy_from_user(&regs->pt.orig_ax, &user->orig_eax,
+			      sizeof(struct kernel_vm86_regs) -
+			      offsetof(struct kernel_vm86_regs, pt.orig_ax) +
+			      extra);
+	return ret;
+}
+
+struct pt_regs *save_v86_state(struct kernel_vm86_regs *regs)
+{
+	struct tss_struct *tss;
+	struct pt_regs *ret;
+	unsigned long tmp;
+
+	/*
+	 * This gets called from entry.S with interrupts disabled, but
+	 * from process context. Enable interrupts here, before trying
+	 * to access user space.
+	 */
+	local_irq_enable();
+
+	if (!current->thread.vm86_info) {
+		printk("no vm86_info: BAD\n");
+		do_exit(SIGSEGV);
+	}
+	set_flags(regs->pt.flags, VEFLAGS, X86_EFLAGS_VIF | current->thread.v86mask);
+	tmp = copy_vm86_regs_to_user(&current->thread.vm86_info->regs, regs);
+	tmp += put_user(current->thread.screen_bitmap, &current->thread.vm86_info->screen_bitmap);
+	if (tmp) {
+		printk("vm86: could not access userspace vm86_info\n");
+		do_exit(SIGSEGV);
+	}
+
+	tss = &per_cpu(init_tss, get_cpu());
+	current->thread.sp0 = current->thread.saved_sp0;
+	current->thread.sysenter_cs = __KERNEL_CS;
+	load_sp0(tss, &current->thread);
+	current->thread.saved_sp0 = 0;
+	put_cpu();
+
+	ret = KVM86->regs32;
+
+	ret->fs = current->thread.saved_fs;
+	set_user_gs(ret, current->thread.saved_gs);
+
+	return ret;
+}
+
+static void mark_screen_rdonly(struct mm_struct *mm)
+{
+	pgd_t *pgd;
+	pud_t *pud;
+	pmd_t *pmd;
+	pte_t *pte;
+	spinlock_t *ptl;
+	int i;
+
+	pgd = pgd_offset(mm, 0xA0000);
+	if (pgd_none_or_clear_bad(pgd))
+		goto out;
+	pud = pud_offset(pgd, 0xA0000);
+	if (pud_none_or_clear_bad(pud))
+		goto out;
+	pmd = pmd_offset(pud, 0xA0000);
+	split_huge_page_pmd(mm, pmd);
+	if (pmd_none_or_clear_bad(pmd))
+		goto out;
+	pte = pte_offset_map_lock(mm, pmd, 0xA0000, &ptl);
+	for (i = 0; i < 32; i++) {
+		if (pte_present(*pte))
+			set_pte(pte, pte_wrprotect(*pte));
+		pte++;
+	}
+	pte_unmap_unlock(pte, ptl);
+out:
+	flush_tlb();
+}
+
+
+
+static int do_vm86_irq_handling(int subfunction, int irqnumber);
+static void do_sys_vm86(struct kernel_vm86_struct *info, struct task_struct *tsk);
+
+int sys_vm86old(struct vm86_struct __user *v86, struct pt_regs *regs)
+{
+	struct kernel_vm86_struct info; /* declare this _on top_,
+					 * this avoids wasting of stack space.
+					 * This remains on the stack until we
+					 * return to 32 bit user space.
+					 */
+	struct task_struct *tsk;
+	int tmp, ret = -EPERM;
+
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|vm86old");
+
+	tsk = current;
+	if (tsk->thread.saved_sp0)
+		goto out;
+	tmp = copy_vm86_regs_from_user(&info.regs, &v86->regs,
+				       offsetof(struct kernel_vm86_struct, vm86plus) -
+				       sizeof(info.regs));
+	ret = -EFAULT;
+	if (tmp)
+		goto out;
+	memset(&info.vm86plus, 0, (int)&info.regs32 - (int)&info.vm86plus);
+	info.regs32 = regs;
+	tsk->thread.vm86_info = v86;
+	do_sys_vm86(&info, tsk);
+	ret = 0;	/* we never return here */
+out:
+	return ret;
+}
+
+
+int sys_vm86(unsigned long cmd, unsigned long arg, struct pt_regs *regs)
+{
+	struct kernel_vm86_struct info; /* declare this _on top_,
+					 * this avoids wasting of stack space.
+					 * This remains on the stack until we
+					 * return to 32 bit user space.
+					 */
+	struct task_struct *tsk;
+	int tmp, ret;
+	struct vm86plus_struct __user *v86;
+
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|vm86");
+
+	tsk = current;
+	switch (cmd) {
+	case VM86_REQUEST_IRQ:
+	case VM86_FREE_IRQ:
+	case VM86_GET_IRQ_BITS:
+	case VM86_GET_AND_RESET_IRQ:
+		ret = do_vm86_irq_handling(cmd, (int)arg);
+		goto out;
+	case VM86_PLUS_INSTALL_CHECK:
+		/*
+		 * NOTE: on old vm86 stuff this will return the error
+		 *  from access_ok(), because the subfunction is
+		 *  interpreted as (invalid) address to vm86_struct.
+		 *  So the installation check works.
+		 */
+		ret = 0;
+		goto out;
+	}
+
+	/* we come here only for functions VM86_ENTER, VM86_ENTER_NO_BYPASS */
+	ret = -EPERM;
+	if (tsk->thread.saved_sp0)
+		goto out;
+	v86 = (struct vm86plus_struct __user *)arg;
+	tmp = copy_vm86_regs_from_user(&info.regs, &v86->regs,
+				       offsetof(struct kernel_vm86_struct, regs32) -
+				       sizeof(info.regs));
+	ret = -EFAULT;
+	if (tmp)
+		goto out;
+	info.regs32 = regs;
+	info.vm86plus.is_vm86pus = 1;
+	tsk->thread.vm86_info = (struct vm86_struct __user *)v86;
+	do_sys_vm86(&info, tsk);
+	ret = 0;	/* we never return here */
+out:
+	return ret;
+}
+
+
+static void do_sys_vm86(struct kernel_vm86_struct *info, struct task_struct *tsk)
+{
+	struct tss_struct *tss;
+/*
+ * make sure the vm86() system call doesn't try to do anything silly
+ */
+	info->regs.pt.ds = 0;
+	info->regs.pt.es = 0;
+	info->regs.pt.fs = 0;
+#ifndef CONFIG_X86_32_LAZY_GS
+	info->regs.pt.gs = 0;
+#endif
+
+/*
+ * The flags register is also special: we cannot trust that the user
+ * has set it up safely, so this makes sure interrupt etc flags are
+ * inherited from protected mode.
+ */
+	VEFLAGS = info->regs.pt.flags;
+	info->regs.pt.flags &= SAFE_MASK;
+	info->regs.pt.flags |= info->regs32->flags & ~SAFE_MASK;
+	info->regs.pt.flags |= X86_VM_MASK;
+
+	switch (info->cpu_type) {
+	case CPU_286:
+		tsk->thread.v86mask = 0;
+		break;
+	case CPU_386:
+		tsk->thread.v86mask = X86_EFLAGS_NT | X86_EFLAGS_IOPL;
+		break;
+	case CPU_486:
+		tsk->thread.v86mask = X86_EFLAGS_AC | X86_EFLAGS_NT | X86_EFLAGS_IOPL;
+		break;
+	default:
+		tsk->thread.v86mask = X86_EFLAGS_ID | X86_EFLAGS_AC | X86_EFLAGS_NT | X86_EFLAGS_IOPL;
+		break;
+	}
+
+/*
+ * Save old state, set default return value (%ax) to 0 (VM86_SIGNAL)
+ */
+	info->regs32->ax = VM86_SIGNAL;
+	tsk->thread.saved_sp0 = tsk->thread.sp0;
+	tsk->thread.saved_fs = info->regs32->fs;
+	tsk->thread.saved_gs = get_user_gs(info->regs32);
+
+	tss = &per_cpu(init_tss, get_cpu());
+	tsk->thread.sp0 = (unsigned long) &info->VM86_TSS_ESP0;
+	if (cpu_has_sep)
+		tsk->thread.sysenter_cs = 0;
+	load_sp0(tss, &tsk->thread);
+	put_cpu();
+
+	tsk->thread.screen_bitmap = info->screen_bitmap;
+	if (info->flags & VM86_SCREEN_BITMAP)
+		mark_screen_rdonly(tsk->mm);
+
+	/*call audit_syscall_exit since we do not exit via the normal paths */
+	if (unlikely(current->audit_context))
+		audit_syscall_exit(AUDITSC_RESULT(0), 0);
+
+	__asm__ __volatile__(
+		"movl %0,%%esp\n\t"
+		"movl %1,%%ebp\n\t"
+#ifdef CONFIG_X86_32_LAZY_GS
+		"mov  %2, %%gs\n\t"
+#endif
+		"jmp resume_userspace"
+		: /* no outputs */
+		:"r" (&info->regs), "r" (task_thread_info(tsk)), "r" (0));
+	/* we never return here */
+}
+
+static inline void return_to_32bit(struct kernel_vm86_regs *regs16, int retval)
+{
+	struct pt_regs *regs32;
+
+	regs32 = save_v86_state(regs16);
+	regs32->ax = retval;
+	__asm__ __volatile__("movl %0,%%esp\n\t"
+		"movl %1,%%ebp\n\t"
+		"jmp resume_userspace"
+		: : "r" (regs32), "r" (current_thread_info()));
+}
+
+static inline void set_IF(struct kernel_vm86_regs *regs)
+{
+	VEFLAGS |= X86_EFLAGS_VIF;
+	if (VEFLAGS & X86_EFLAGS_VIP)
+		return_to_32bit(regs, VM86_STI);
+}
+
+static inline void clear_IF(struct kernel_vm86_regs *regs)
+{
+	VEFLAGS &= ~X86_EFLAGS_VIF;
+}
+
+static inline void clear_TF(struct kernel_vm86_regs *regs)
+{
+	regs->pt.flags &= ~X86_EFLAGS_TF;
+}
+
+static inline void clear_AC(struct kernel_vm86_regs *regs)
+{
+	regs->pt.flags &= ~X86_EFLAGS_AC;
+}
+
+/*
+ * It is correct to call set_IF(regs) from the set_vflags_*
+ * functions. However someone forgot to call clear_IF(regs)
+ * in the opposite case.
+ * After the command sequence CLI PUSHF STI POPF you should
+ * end up with interrupts disabled, but you ended up with
+ * interrupts enabled.
+ *  ( I was testing my own changes, but the only bug I
+ *    could find was in a function I had not changed. )
+ * [KD]
+ */
+
+static inline void set_vflags_long(unsigned long flags, struct kernel_vm86_regs *regs)
+{
+	set_flags(VEFLAGS, flags, current->thread.v86mask);
+	set_flags(regs->pt.flags, flags, SAFE_MASK);
+	if (flags & X86_EFLAGS_IF)
+		set_IF(regs);
+	else
+		clear_IF(regs);
+}
+
+static inline void set_vflags_short(unsigned short flags, struct kernel_vm86_regs *regs)
+{
+	set_flags(VFLAGS, flags, current->thread.v86mask);
+	set_flags(regs->pt.flags, flags, SAFE_MASK);
+	if (flags & X86_EFLAGS_IF)
+		set_IF(regs);
+	else
+		clear_IF(regs);
+}
+
+static inline unsigned long get_vflags(struct kernel_vm86_regs *regs)
+{
+	unsigned long flags = regs->pt.flags & RETURN_MASK;
+
+	if (VEFLAGS & X86_EFLAGS_VIF)
+		flags |= X86_EFLAGS_IF;
+	flags |= X86_EFLAGS_IOPL;
+	return flags | (VEFLAGS & current->thread.v86mask);
+}
+
+static inline int is_revectored(int nr, struct revectored_struct *bitmap)
+{
+	__asm__ __volatile__("btl %2,%1\n\tsbbl %0,%0"
+		:"=r" (nr)
+		:"m" (*bitmap), "r" (nr));
+	return nr;
+}
+
+#define val_byte(val, n) (((__u8 *)&val)[n])
+
+#define pushb(base, ptr, val, err_label) \
+	do { \
+		__u8 __val = val; \
+		ptr--; \
+		if (put_user(__val, base + ptr) < 0) \
+			goto err_label; \
+	} while (0)
+
+#define pushw(base, ptr, val, err_label) \
+	do { \
+		__u16 __val = val; \
+		ptr--; \
+		if (put_user(val_byte(__val, 1), base + ptr) < 0) \
+			goto err_label; \
+		ptr--; \
+		if (put_user(val_byte(__val, 0), base + ptr) < 0) \
+			goto err_label; \
+	} while (0)
+
+#define pushl(base, ptr, val, err_label) \
+	do { \
+		__u32 __val = val; \
+		ptr--; \
+		if (put_user(val_byte(__val, 3), base + ptr) < 0) \
+			goto err_label; \
+		ptr--; \
+		if (put_user(val_byte(__val, 2), base + ptr) < 0) \
+			goto err_label; \
+		ptr--; \
+		if (put_user(val_byte(__val, 1), base + ptr) < 0) \
+			goto err_label; \
+		ptr--; \
+		if (put_user(val_byte(__val, 0), base + ptr) < 0) \
+			goto err_label; \
+	} while (0)
+
+#define popb(base, ptr, err_label) \
+	({ \
+		__u8 __res; \
+		if (get_user(__res, base + ptr) < 0) \
+			goto err_label; \
+		ptr++; \
+		__res; \
+	})
+
+#define popw(base, ptr, err_label) \
+	({ \
+		__u16 __res; \
+		if (get_user(val_byte(__res, 0), base + ptr) < 0) \
+			goto err_label; \
+		ptr++; \
+		if (get_user(val_byte(__res, 1), base + ptr) < 0) \
+			goto err_label; \
+		ptr++; \
+		__res; \
+	})
+
+#define popl(base, ptr, err_label) \
+	({ \
+		__u32 __res; \
+		if (get_user(val_byte(__res, 0), base + ptr) < 0) \
+			goto err_label; \
+		ptr++; \
+		if (get_user(val_byte(__res, 1), base + ptr) < 0) \
+			goto err_label; \
+		ptr++; \
+		if (get_user(val_byte(__res, 2), base + ptr) < 0) \
+			goto err_label; \
+		ptr++; \
+		if (get_user(val_byte(__res, 3), base + ptr) < 0) \
+			goto err_label; \
+		ptr++; \
+		__res; \
+	})
+
+/* There are so many possible reasons for this function to return
+ * VM86_INTx, so adding another doesn't bother me. We can expect
+ * userspace programs to be able to handle it. (Getting a problem
+ * in userspace is always better than an Oops anyway.) [KD]
+ */
+static void do_int(struct kernel_vm86_regs *regs, int i,
+    unsigned char __user *ssp, unsigned short sp)
+{
+	unsigned long __user *intr_ptr;
+	unsigned long segoffs;
+
+	if (regs->pt.cs == BIOSSEG)
+		goto cannot_handle;
+	if (is_revectored(i, &KVM86->int_revectored))
+		goto cannot_handle;
+	if (i == 0x21 && is_revectored(AH(regs), &KVM86->int21_revectored))
+		goto cannot_handle;
+	intr_ptr = (unsigned long __user *) (i << 2);
+	if (get_user(segoffs, intr_ptr))
+		goto cannot_handle;
+	if ((segoffs >> 16) == BIOSSEG)
+		goto cannot_handle;
+	pushw(ssp, sp, get_vflags(regs), cannot_handle);
+	pushw(ssp, sp, regs->pt.cs, cannot_handle);
+	pushw(ssp, sp, IP(regs), cannot_handle);
+	regs->pt.cs = segoffs >> 16;
+	SP(regs) -= 6;
+	IP(regs) = segoffs & 0xffff;
+	clear_TF(regs);
+	clear_IF(regs);
+	clear_AC(regs);
+	return;
+
+cannot_handle:
+	return_to_32bit(regs, VM86_INTx + (i << 8));
+}
+
+int handle_vm86_trap(struct kernel_vm86_regs *regs, long error_code, int trapno)
+{
+	if (VMPI.is_vm86pus) {
+		if ((trapno == 3) || (trapno == 1)) {
+			KVM86->regs32->ax = VM86_TRAP + (trapno << 8);
+			/* setting this flag forces the code in entry_32.S to
+			   call save_v86_state() and change the stack pointer
+			   to KVM86->regs32 */
+			set_thread_flag(TIF_IRET);
+			return 0;
+		}
+		do_int(regs, trapno, (unsigned char __user *) (regs->pt.ss << 4), SP(regs));
+		return 0;
+	}
+	if (trapno != 1)
+		return 1; /* we let this handle by the calling routine */
+	current->thread.trap_no = trapno;
+	current->thread.error_code = error_code;
+	force_sig(SIGTRAP, current);
+	return 0;
+}
+
+void handle_vm86_fault(struct kernel_vm86_regs *regs, long error_code)
+{
+	unsigned char opcode;
+	unsigned char __user *csp;
+	unsigned char __user *ssp;
+	unsigned short ip, sp, orig_flags;
+	int data32, pref_done;
+
+#define CHECK_IF_IN_TRAP \
+	if (VMPI.vm86dbg_active && VMPI.vm86dbg_TFpendig) \
+		newflags |= X86_EFLAGS_TF
+#define VM86_FAULT_RETURN do { \
+	if (VMPI.force_return_for_pic  && (VEFLAGS & (X86_EFLAGS_IF | X86_EFLAGS_VIF))) \
+		return_to_32bit(regs, VM86_PICRETURN); \
+	if (orig_flags & X86_EFLAGS_TF) \
+		handle_vm86_trap(regs, 0, 1); \
+	return; } while (0)
+
+	orig_flags = *(unsigned short *)&regs->pt.flags;
+
+	csp = (unsigned char __user *) (regs->pt.cs << 4);
+	ssp = (unsigned char __user *) (regs->pt.ss << 4);
+	sp = SP(regs);
+	ip = IP(regs);
+
+	data32 = 0;
+	pref_done = 0;
+	do {
+		switch (opcode = popb(csp, ip, simulate_sigsegv)) {
+		case 0x66:      /* 32-bit data */     data32 = 1; break;
+		case 0x67:      /* 32-bit address */  break;
+		case 0x2e:      /* CS */              break;
+		case 0x3e:      /* DS */              break;
+		case 0x26:      /* ES */              break;
+		case 0x36:      /* SS */              break;
+		case 0x65:      /* GS */              break;
+		case 0x64:      /* FS */              break;
+		case 0xf2:      /* repnz */       break;
+		case 0xf3:      /* rep */             break;
+		default: pref_done = 1;
+		}
+	} while (!pref_done);
+
+	switch (opcode) {
+
+	/* pushf */
+	case 0x9c:
+		if (data32) {
+			pushl(ssp, sp, get_vflags(regs), simulate_sigsegv);
+			SP(regs) -= 4;
+		} else {
+			pushw(ssp, sp, get_vflags(regs), simulate_sigsegv);
+			SP(regs) -= 2;
+		}
+		IP(regs) = ip;
+		VM86_FAULT_RETURN;
+
+	/* popf */
+	case 0x9d:
+		{
+		unsigned long newflags;
+		if (data32) {
+			newflags = popl(ssp, sp, simulate_sigsegv);
+			SP(regs) += 4;
+		} else {
+			newflags = popw(ssp, sp, simulate_sigsegv);
+			SP(regs) += 2;
+		}
+		IP(regs) = ip;
+		CHECK_IF_IN_TRAP;
+		if (data32)
+			set_vflags_long(newflags, regs);
+		else
+			set_vflags_short(newflags, regs);
+
+		VM86_FAULT_RETURN;
+		}
+
+	/* int xx */
+	case 0xcd: {
+		int intno = popb(csp, ip, simulate_sigsegv);
+		IP(regs) = ip;
+		if (VMPI.vm86dbg_active) {
+			if ((1 << (intno & 7)) & VMPI.vm86dbg_intxxtab[intno >> 3])
+				return_to_32bit(regs, VM86_INTx + (intno << 8));
+		}
+		do_int(regs, intno, ssp, sp);
+		return;
+	}
+
+	/* iret */
+	case 0xcf:
+		{
+		unsigned long newip;
+		unsigned long newcs;
+		unsigned long newflags;
+		if (data32) {
+			newip = popl(ssp, sp, simulate_sigsegv);
+			newcs = popl(ssp, sp, simulate_sigsegv);
+			newflags = popl(ssp, sp, simulate_sigsegv);
+			SP(regs) += 12;
+		} else {
+			newip = popw(ssp, sp, simulate_sigsegv);
+			newcs = popw(ssp, sp, simulate_sigsegv);
+			newflags = popw(ssp, sp, simulate_sigsegv);
+			SP(regs) += 6;
+		}
+		IP(regs) = newip;
+		regs->pt.cs = newcs;
+		CHECK_IF_IN_TRAP;
+		if (data32) {
+			set_vflags_long(newflags, regs);
+		} else {
+			set_vflags_short(newflags, regs);
+		}
+		VM86_FAULT_RETURN;
+		}
+
+	/* cli */
+	case 0xfa:
+		IP(regs) = ip;
+		clear_IF(regs);
+		VM86_FAULT_RETURN;
+
+	/* sti */
+	/*
+	 * Damn. This is incorrect: the 'sti' instruction should actually
+	 * enable interrupts after the /next/ instruction. Not good.
+	 *
+	 * Probably needs some horsing around with the TF flag. Aiee..
+	 */
+	case 0xfb:
+		IP(regs) = ip;
+		set_IF(regs);
+		VM86_FAULT_RETURN;
+
+	default:
+		return_to_32bit(regs, VM86_UNKNOWN);
+	}
+
+	return;
+
+simulate_sigsegv:
+	/* FIXME: After a long discussion with Stas we finally
+	 *        agreed, that this is wrong. Here we should
+	 *        really send a SIGSEGV to the user program.
+	 *        But how do we create the correct context? We
+	 *        are inside a general protection fault handler
+	 *        and has just returned from a page fault handler.
+	 *        The correct context for the signal handler
+	 *        should be a mixture of the two, but how do we
+	 *        get the information? [KD]
+	 */
+	return_to_32bit(regs, VM86_UNKNOWN);
+}
+
+/* ---------------- vm86 special IRQ passing stuff ----------------- */
+
+#define VM86_IRQNAME		"vm86irq"
+
+static struct vm86_irqs {
+	struct task_struct *tsk;
+	int sig;
+} vm86_irqs[16];
+
+static DEFINE_SPINLOCK(irqbits_lock);
+static int irqbits;
+
+#define ALLOWED_SIGS (1 /* 0 = don't send a signal */ \
+	| (1 << SIGUSR1) | (1 << SIGUSR2) | (1 << SIGIO)  | (1 << SIGURG) \
+	| (1 << SIGUNUSED))
+
+static irqreturn_t irq_handler(int intno, void *dev_id)
+{
+	int irq_bit;
+	unsigned long flags;
+
+	spin_lock_irqsave(&irqbits_lock, flags);
+	irq_bit = 1 << intno;
+	if ((irqbits & irq_bit) || !vm86_irqs[intno].tsk)
+		goto out;
+	irqbits |= irq_bit;
+	if (vm86_irqs[intno].sig)
+		send_sig(vm86_irqs[intno].sig, vm86_irqs[intno].tsk, 1);
+	/*
+	 * IRQ will be re-enabled when user asks for the irq (whether
+	 * polling or as a result of the signal)
+	 */
+	disable_irq_nosync(intno);
+	spin_unlock_irqrestore(&irqbits_lock, flags);
+	return IRQ_HANDLED;
+
+out:
+	spin_unlock_irqrestore(&irqbits_lock, flags);
+	return IRQ_NONE;
+}
+
+static inline void free_vm86_irq(int irqnumber)
+{
+	unsigned long flags;
+
+	free_irq(irqnumber, NULL);
+	vm86_irqs[irqnumber].tsk = NULL;
+
+	spin_lock_irqsave(&irqbits_lock, flags);
+	irqbits &= ~(1 << irqnumber);
+	spin_unlock_irqrestore(&irqbits_lock, flags);
+}
+
+void release_vm86_irqs(struct task_struct *task)
+{
+	int i;
+	for (i = FIRST_VM86_IRQ ; i <= LAST_VM86_IRQ; i++)
+	    if (vm86_irqs[i].tsk == task)
+		free_vm86_irq(i);
+}
+
+static inline int get_and_reset_irq(int irqnumber)
+{
+	int bit;
+	unsigned long flags;
+	int ret = 0;
+
+	if (invalid_vm86_irq(irqnumber)) return 0;
+	if (vm86_irqs[irqnumber].tsk != current) return 0;
+	spin_lock_irqsave(&irqbits_lock, flags);
+	bit = irqbits & (1 << irqnumber);
+	irqbits &= ~bit;
+	if (bit) {
+		enable_irq(irqnumber);
+		ret = 1;
+	}
+
+	spin_unlock_irqrestore(&irqbits_lock, flags);
+	return ret;
+}
+
+
+static int do_vm86_irq_handling(int subfunction, int irqnumber)
+{
+	int ret;
+	switch (subfunction) {
+		case VM86_GET_AND_RESET_IRQ: {
+			return get_and_reset_irq(irqnumber);
+		}
+		case VM86_GET_IRQ_BITS: {
+			return irqbits;
+		}
+		case VM86_REQUEST_IRQ: {
+			int sig = irqnumber >> 8;
+			int irq = irqnumber & 255;
+			if (!capable(CAP_SYS_ADMIN)) return -EPERM;
+			if (!((1 << sig) & ALLOWED_SIGS)) return -EPERM;
+			if (invalid_vm86_irq(irq)) return -EPERM;
+			if (vm86_irqs[irq].tsk) return -EPERM;
+			ret = request_irq(irq, &irq_handler, 0, VM86_IRQNAME, NULL);
+			if (ret) return ret;
+			vm86_irqs[irq].sig = sig;
+			vm86_irqs[irq].tsk = current;
+			return irq;
+		}
+		case  VM86_FREE_IRQ: {
+			if (invalid_vm86_irq(irqnumber)) return -EPERM;
+			if (!vm86_irqs[irqnumber].tsk) return 0;
+			if (vm86_irqs[irqnumber].tsk != current) return -EPERM;
+			free_vm86_irq(irqnumber);
+			return 0;
+		}
+	}
+	return -EINVAL;
+}
+
diff -Naur linux-source-2.6.38.orig/mm/fremap.c linux-source-2.6.38.modif/mm/fremap.c
--- linux-source-2.6.38.orig/mm/fremap.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/mm/fremap.c	2011-12-16 16:48:32.000000000 +0100
@@ -129,6 +129,9 @@
 	int err = -EINVAL;
 	int has_write_lock = 0;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|remap_file_pages");
+
 	if (prot)
 		return err;
 	/*
diff -Naur linux-source-2.6.38.orig/mm/madvise.c linux-source-2.6.38.modif/mm/madvise.c
--- linux-source-2.6.38.orig/mm/madvise.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/mm/madvise.c	2011-12-16 16:49:21.000000000 +0100
@@ -351,6 +351,9 @@
 	int write;
 	size_t len;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|madvise");
+
 #ifdef CONFIG_MEMORY_FAILURE
 	if (behavior == MADV_HWPOISON || behavior == MADV_SOFT_OFFLINE)
 		return madvise_hwpoison(behavior, start, start+len_in);
diff -Naur linux-source-2.6.38.orig/mm/mempolicy.c linux-source-2.6.38.modif/mm/mempolicy.c
--- linux-source-2.6.38.orig/mm/mempolicy.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/mm/mempolicy.c	2011-12-16 16:51:01.000000000 +0100
@@ -1249,6 +1249,9 @@
 	int err;
 	unsigned short mode_flags;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|mbind");
+
 	mode_flags = mode & MPOL_MODE_FLAGS;
 	mode &= ~MPOL_MODE_FLAGS;
 	if (mode >= MPOL_MAX)
@@ -1270,6 +1273,9 @@
 	nodemask_t nodes;
 	unsigned short flags;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|set_mempolicy");
+
 	flags = mode & MPOL_MODE_FLAGS;
 	mode &= ~MPOL_MODE_FLAGS;
 	if ((unsigned int)mode >= MPOL_MAX)
@@ -1295,6 +1301,9 @@
 	nodemask_t *new;
 	NODEMASK_SCRATCH(scratch);
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|migrate_pages");
+
 	if (!scratch)
 		return -ENOMEM;
 
@@ -1377,6 +1386,9 @@
 	int uninitialized_var(pval);
 	nodemask_t nodes;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|get_mempolicy");
+
 	if (nmask != NULL && maxnode < MAX_NUMNODES)
 		return -EINVAL;
 
diff -Naur linux-source-2.6.38.orig/mm/migrate.c linux-source-2.6.38.modif/mm/migrate.c
--- linux-source-2.6.38.orig/mm/migrate.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/mm/migrate.c	2011-12-16 16:51:23.000000000 +0100
@@ -1279,6 +1279,9 @@
 	struct mm_struct *mm;
 	int err;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|move_pages");
+
 	/* Check flags */
 	if (flags & ~(MPOL_MF_MOVE|MPOL_MF_MOVE_ALL))
 		return -EINVAL;
diff -Naur linux-source-2.6.38.orig/mm/mincore.c linux-source-2.6.38.modif/mm/mincore.c
--- linux-source-2.6.38.orig/mm/mincore.c	2011-09-28 16:24:41.000000000 +0200
+++ linux-source-2.6.38.modif/mm/mincore.c	2011-12-16 16:52:11.000000000 +0100
@@ -269,6 +269,9 @@
 	unsigned long pages;
 	unsigned char *tmp;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|mincore");
+
 	/* Check the start address: needs to be page-aligned.. */
  	if (start & ~PAGE_CACHE_MASK)
 		return -EINVAL;
diff -Naur linux-source-2.6.38.orig/mm/mlock.c linux-source-2.6.38.modif/mm/mlock.c
--- linux-source-2.6.38.orig/mm/mlock.c	2011-09-28 16:24:41.000000000 +0200
+++ linux-source-2.6.38.modif/mm/mlock.c	2011-12-16 16:54:45.000000000 +0100
@@ -476,6 +476,9 @@
 	unsigned long lock_limit;
 	int error = -ENOMEM;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|mlock");
+
 	if (!can_do_mlock())
 		return -EPERM;
 
@@ -504,6 +507,9 @@
 {
 	int ret;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|munlock");
+
 	down_write(&current->mm->mmap_sem);
 	len = PAGE_ALIGN(len + (start & ~PAGE_MASK));
 	start &= PAGE_MASK;
@@ -542,6 +548,9 @@
 	unsigned long lock_limit;
 	int ret = -EINVAL;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|mlockall");
+
 	if (!flags || (flags & ~(MCL_CURRENT | MCL_FUTURE)))
 		goto out;
 
@@ -572,6 +581,8 @@
 SYSCALL_DEFINE0(munlockall)
 {
 	int ret;
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|munlockall");
 
 	down_write(&current->mm->mmap_sem);
 	ret = do_mlockall(0);
diff -Naur linux-source-2.6.38.orig/mm/mmap.c linux-source-2.6.38.modif/mm/mmap.c
--- linux-source-2.6.38.orig/mm/mmap.c	2011-09-28 16:24:41.000000000 +0200
+++ linux-source-2.6.38.modif/mm/mmap.c	2011-12-16 17:01:04.000000000 +0100
@@ -264,6 +264,9 @@
 	struct mm_struct *mm = current->mm;
 	unsigned long min_brk;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|brk");
+
 	down_write(&mm->mmap_sem);
 
 #ifdef CONFIG_COMPAT_BRK
@@ -1142,6 +1145,9 @@
 	struct file *file = NULL;
 	unsigned long retval = -EBADF;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|mmap_pgoff");
+
 	if (!(flags & MAP_ANONYMOUS)) {
 		audit_mmap_fd(fd, flags);
 		if (unlikely(flags & MAP_HUGETLB))
@@ -1190,6 +1196,9 @@
 {
 	struct mmap_arg_struct a;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|old_mmap");
+
 	if (copy_from_user(&a, arg, sizeof(a)))
 		return -EFAULT;
 	if (a.offset & ~PAGE_MASK)
@@ -2251,6 +2260,9 @@
 	int ret;
 	struct mm_struct *mm = current->mm;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|munmap");
+
 	profile_munmap(addr);
 
 	down_write(&mm->mmap_sem);
diff -Naur linux-source-2.6.38.orig/mm/mprotect.c linux-source-2.6.38.modif/mm/mprotect.c
--- linux-source-2.6.38.orig/mm/mprotect.c	2011-09-28 16:24:41.000000000 +0200
+++ linux-source-2.6.38.modif/mm/mprotect.c	2011-12-16 17:01:40.000000000 +0100
@@ -248,6 +248,9 @@
 	if (grows == (PROT_GROWSDOWN|PROT_GROWSUP)) /* can't be both */
 		return -EINVAL;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|mprotect");
+
 	if (start & ~PAGE_MASK)
 		return -EINVAL;
 	if (!len)
diff -Naur linux-source-2.6.38.orig/mm/mremap.c linux-source-2.6.38.modif/mm/mremap.c
--- linux-source-2.6.38.orig/mm/mremap.c	2011-09-28 16:24:41.000000000 +0200
+++ linux-source-2.6.38.modif/mm/mremap.c	2011-12-16 17:03:17.000000000 +0100
@@ -521,6 +521,9 @@
 {
 	unsigned long ret;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|mremap");
+
 	down_write(&current->mm->mmap_sem);
 	ret = do_mremap(addr, old_len, new_len, flags, new_addr);
 	up_write(&current->mm->mmap_sem);
diff -Naur linux-source-2.6.38.orig/mm/msync.c linux-source-2.6.38.modif/mm/msync.c
--- linux-source-2.6.38.orig/mm/msync.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/mm/msync.c	2011-12-16 16:46:10.000000000 +0100
@@ -36,6 +36,9 @@
 	int unmapped_error = 0;
 	int error = -EINVAL;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|msync");
+
 	if (flags & ~(MS_ASYNC | MS_INVALIDATE | MS_SYNC))
 		goto out;
 	if (start & ~PAGE_MASK)
diff -Naur linux-source-2.6.38.orig/mm/swapfile.c linux-source-2.6.38.modif/mm/swapfile.c
--- linux-source-2.6.38.orig/mm/swapfile.c	2011-09-28 16:24:41.000000000 +0200
+++ linux-source-2.6.38.modif/mm/swapfile.c	2011-12-16 17:04:20.000000000 +0100
@@ -1567,6 +1567,9 @@
 	int i, type, prev;
 	int err;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|swapoff");
+
 	if (!capable(CAP_SYS_ADMIN))
 		return -EPERM;
 
@@ -1876,6 +1879,9 @@
 	struct inode *inode = NULL;
 	int did_down = 0;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|swapon");
+
 	if (!capable(CAP_SYS_ADMIN))
 		return -EPERM;
 
diff -Naur linux-source-2.6.38.orig/net/socket.c linux-source-2.6.38.modif/net/socket.c
--- linux-source-2.6.38.orig/net/socket.c	2011-09-28 16:24:41.000000000 +0200
+++ linux-source-2.6.38.modif/net/socket.c	2011-12-16 17:05:09.000000000 +0100
@@ -2193,6 +2193,9 @@
 	int datagrams;
 	struct timespec timeout_sys;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|recvmmsg");
+
 	if (!timeout)
 		return __sys_recvmmsg(fd, mmsg, vlen, flags, NULL);
 
diff -Naur linux-source-2.6.38.orig/security/keys/keyctl.c linux-source-2.6.38.modif/security/keys/keyctl.c
--- linux-source-2.6.38.orig/security/keys/keyctl.c	2011-03-15 02:20:32.000000000 +0100
+++ linux-source-2.6.38.modif/security/keys/keyctl.c	2011-12-16 17:06:41.000000000 +0100
@@ -62,6 +62,9 @@
 	long ret;
 	bool vm;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|add_key");
+
 	ret = -EINVAL;
 	if (plen > 1024 * 1024 - 1)
 		goto error;
@@ -155,6 +158,9 @@
 	char type[32], *description, *callout_info;
 	long ret;
 
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|request_key");
+
 	/* pull the type into kernel space */
 	ret = key_get_type_from_user(type, _type, sizeof(type));
 	if (ret < 0)
@@ -1411,6 +1417,9 @@
 SYSCALL_DEFINE5(keyctl, int, option, unsigned long, arg2, unsigned long, arg3,
 		unsigned long, arg4, unsigned long, arg5)
 {
+	//GGuirado SysCall Statistics
+	printk(KERN_DEBUG "|keyctl");
+
 	switch (option) {
 	case KEYCTL_GET_KEYRING_ID:
 		return keyctl_get_keyring_ID((key_serial_t) arg2,
