uti: Call into McKernel futex()

(1) Masquerade clv (2) Fix timeout (3) Let mcexec thread with the same tid as McKernel thread migrating to Linux handles the migration request (4) Call create_tracer() before creating proxy related objects Change-Id: I6b2689b70db49827f10aa7d5a4c581aa81319b55
2018-09-02 17:36:28 +09:00
parent 460917c4a0
commit 52afbbbc98
16 changed files with 629 additions and 150 deletions
--- a/kernel/futex.c
+++ b/kernel/futex.c
@@ -71,14 +71,21 @@
 #include <kmsg.h>
 #include <timer.h>
 #include <debug.h>
+#include <syscall.h>

 //#define DEBUG_PRINT_FUTEX

 #ifdef DEBUG_PRINT_FUTEX
 #undef DDEBUG_DEFAULT
 #define DDEBUG_DEFAULT DDEBUG_PRINT
+#define uti_dkprintf(...) do { ((clv_override && linux_printk) ? (*linux_printk) : kprintf)(__VA_ARGS__); } while (0)
+#else
+#define uti_dkprintf(...) do { } while (0)
 #endif
+#define uti_kprintf(...) do { ((clv_override && linux_printk) ? (*linux_printk) : kprintf)(__VA_ARGS__); } while (0)

+
+unsigned long ihk_mc_get_ns_per_tsc(void);
 int futex_cmpxchg_enabled;

 /**
@@ -108,6 +115,9 @@ struct futex_q {
 	union futex_key key;
 	union futex_key *requeue_pi_key;
 	uint32_t bitset;
+
+	/* Used to wake-up a thread running on a Linux CPU */
+	void *uti_futex_resp; 
 };

 /*
@@ -180,11 +190,12 @@ static void drop_futex_key_refs(union futex_key *key)
 * lock_page() might sleep, the caller should not hold a spinlock.
 */
 static int
-get_futex_key(uint32_t *uaddr, int fshared, union futex_key *key)
+get_futex_key(uint32_t *uaddr, int fshared, union futex_key *key, struct cpu_local_var *clv_override)
 {
 	unsigned long address = (unsigned long)uaddr;
 	unsigned long phys;
-	struct process_vm *mm = cpu_local_var(current)->vm;
+	struct thread *thread = cpu_local_var_with_override(current, clv_override);
+	struct process_vm *mm = thread->vm;

 	/*
 	 * The futex address must be "naturally" aligned.
@@ -250,7 +261,7 @@ static int cmpxchg_futex_value_locked(uint32_t __user *uaddr, uint32_t uval, uin
 * The hash bucket lock must be held when this is called.
 * Afterwards, the futex_q must not be accessed.
 */
-static void wake_futex(struct futex_q *q)
+static void wake_futex(struct futex_q *q, struct cpu_local_var *clv_override)
 {
 	struct thread *p = q->task;

@@ -272,8 +283,31 @@ static void wake_futex(struct futex_q *q)
 	barrier();
 	q->lock_ptr = NULL;

-	dkprintf("wake_futex(): waking up tid %d\n", p->tid);
-	sched_wakeup_thread(p, PS_NORMAL);
+
+	if (q->uti_futex_resp) { 
+		int rc;
+		uti_dkprintf("wake_futex(): waking up migrated-to-Linux thread (tid %d),uti_futex_resp=%p\n", p->tid, q->uti_futex_resp);
+		/* TODO: Add the case when a Linux thread waking up another Linux thread */
+		if (clv_override) {
+			uti_dkprintf("%s: ERROR: A Linux thread is waking up migrated-to-Linux thread\n", __FUNCTION__);
+		}
+		if (p->spin_sleep == 0) {
+			uti_dkprintf("%s: INFO: woken up by someone else\n", __FUNCTION__);
+		}
+
+		struct ikc_scd_packet pckt;
+		struct ihk_ikc_channel_desc *resp_channel = cpu_local_var_with_override(ikc2linux, clv_override);
+		pckt.msg = SCD_MSG_FUTEX_WAKE;
+		pckt.futex.resp = q->uti_futex_resp;
+		pckt.futex.spin_sleep = &p->spin_sleep;
+		rc = ihk_ikc_send(resp_channel, &pckt, 0);
+		if (rc) {
+			uti_dkprintf("%s: ERROR: ihk_ikc_send returned %d, resp_channel=%p\n", __FUNCTION__, rc, resp_channel);
+		}
+	} else {
+		uti_dkprintf("wake_futex(): waking up McKernel thread (tid %d)\n", p->tid);
+		sched_wakeup_thread(p, PS_NORMAL);
+	}
 }

 /*
@@ -303,7 +337,7 @@ double_unlock_hb(struct futex_hash_bucket *hb1, struct futex_hash_bucket *hb2)
 /*
 * Wake up waiters matching bitset queued on this futex (uaddr).
 */
-static int futex_wake(uint32_t *uaddr, int fshared, int nr_wake, uint32_t bitset)
+static int futex_wake(uint32_t *uaddr, int fshared, int nr_wake, uint32_t bitset, struct cpu_local_var *clv_override)
 {
 	struct futex_hash_bucket *hb;
 	struct futex_q *this, *next;
@@ -314,7 +348,7 @@ static int futex_wake(uint32_t *uaddr, int fshared, int nr_wake, uint32_t bitset
 	if (!bitset)
 		return -EINVAL;

-	ret = get_futex_key(uaddr, fshared, &key);
+	ret = get_futex_key(uaddr, fshared, &key, clv_override);
 	if ((ret != 0))
 		goto out;

@@ -330,7 +364,7 @@ static int futex_wake(uint32_t *uaddr, int fshared, int nr_wake, uint32_t bitset
 			if (!(this->bitset & bitset))
 				continue;

-			wake_futex(this);
+			wake_futex(this, clv_override);
 			if (++ret >= nr_wake)
 				break;
 		}
@@ -348,7 +382,8 @@ out:
 */
 static int
 futex_wake_op(uint32_t *uaddr1, int fshared, uint32_t *uaddr2,
-	      int nr_wake, int nr_wake2, int op)
+			  int nr_wake, int nr_wake2, int op,
+			  struct cpu_local_var *clv_override)
 {
 	union futex_key key1 = FUTEX_KEY_INIT, key2 = FUTEX_KEY_INIT;
 	struct futex_hash_bucket *hb1, *hb2;
@@ -357,10 +392,10 @@ futex_wake_op(uint32_t *uaddr1, int fshared, uint32_t *uaddr2,
 	int ret, op_ret;

 retry:
-	ret = get_futex_key(uaddr1, fshared, &key1);
+	ret = get_futex_key(uaddr1, fshared, &key1, clv_override);
 	if ((ret != 0))
 		goto out;
-	ret = get_futex_key(uaddr2, fshared, &key2);
+	ret = get_futex_key(uaddr2, fshared, &key2, clv_override);
 	if ((ret != 0))
 		goto out_put_key1;

@@ -394,7 +429,7 @@ retry_private:

 	plist_for_each_entry_safe(this, next, head, list) {
 		if (match_futex (&this->key, &key1)) {
-			wake_futex(this);
+			wake_futex(this, clv_override);
 			if (++ret >= nr_wake)
 				break;
 		}
@@ -406,7 +441,7 @@ retry_private:
 		op_ret = 0;
 		plist_for_each_entry_safe(this, next, head, list) {
 			if (match_futex (&this->key, &key2)) {
-				wake_futex(this);
+				wake_futex(this, clv_override);
 				if (++op_ret >= nr_wake2)
 					break;
 			}
@@ -469,7 +504,7 @@ void requeue_futex(struct futex_q *q, struct futex_hash_bucket *hb1,
 */
 static int futex_requeue(uint32_t *uaddr1, int fshared, uint32_t *uaddr2,
 			 int nr_wake, int nr_requeue, uint32_t *cmpval,
-			 int requeue_pi)
+						 int requeue_pi, struct cpu_local_var *clv_override)
 {
 	union futex_key key1 = FUTEX_KEY_INIT, key2 = FUTEX_KEY_INIT;
 	int drop_count = 0, task_count = 0, ret;
@@ -477,10 +512,10 @@ static int futex_requeue(uint32_t *uaddr1, int fshared, uint32_t *uaddr2,
 	struct plist_head *head1;
 	struct futex_q *this, *next;

-	ret = get_futex_key(uaddr1, fshared, &key1);
+	ret = get_futex_key(uaddr1, fshared, &key1, clv_override);
 	if ((ret != 0))
 		goto out;
-	ret = get_futex_key(uaddr2, fshared, &key2);
+	ret = get_futex_key(uaddr2, fshared, &key2, clv_override);
 	if ((ret != 0))
 		goto out_put_key1;

@@ -515,7 +550,7 @@ static int futex_requeue(uint32_t *uaddr1, int fshared, uint32_t *uaddr2,
 		 */
 		/* RIKEN: no requeue_pi at this moment */
 		if (++task_count <= nr_wake) {
-			wake_futex(this);
+			wake_futex(this, clv_override);
 			continue;
 		}

@@ -574,7 +609,7 @@ queue_unlock(struct futex_q *q, struct futex_hash_bucket *hb)
 * state is implicit in the state of woken task (see futex_wait_requeue_pi() for
 * an example).
 */
-static inline void queue_me(struct futex_q *q, struct futex_hash_bucket *hb)
+static inline void queue_me(struct futex_q *q, struct futex_hash_bucket *hb, struct cpu_local_var *clv_override)
 {
 	int prio;

@@ -595,7 +630,7 @@ static inline void queue_me(struct futex_q *q, struct futex_hash_bucket *hb)
 	q->list.plist.spinlock = &hb->lock;
 #endif
 	plist_add(&q->list, &hb->chain);
-	q->task = cpu_local_var(current);
+	q->task = cpu_local_var_with_override(current, clv_override);
 	ihk_mc_spinlock_unlock_noirq(&hb->lock);
 }

@@ -658,19 +693,19 @@ retry:
 /* RIKEN: this function has been rewritten so that it returns the remaining
 * time in case we are waken.
 */
-static uint64_t futex_wait_queue_me(struct futex_hash_bucket *hb, struct futex_q *q,
-				uint64_t timeout)
+static int64_t futex_wait_queue_me(struct futex_hash_bucket *hb, struct futex_q *q,
+				   uint64_t timeout, struct cpu_local_var *clv_override)
 {
-	uint64_t time_remain = 0;
+	int64_t time_remain = 0;
 	unsigned long irqstate;
-	struct thread *thread = cpu_local_var(current);
+	struct thread *thread = cpu_local_var_with_override(current, clv_override);
 	/*
 	 * The task state is guaranteed to be set before another task can
 	 * wake it. 
 	 * queue_me() calls spin_unlock() upon completion, serializing
 	 * access to the hash list and forcing a memory barrier.
 	 */
-	xchg4(&(cpu_local_var(current)->status), PS_INTERRUPTIBLE);
+	xchg4(&(thread->status), PS_INTERRUPTIBLE);

 	/* Indicate spin sleep. Note that schedule_timeout() with
 	 * idle_halt should use spin sleep because sleep with timeout
@@ -682,25 +717,40 @@ static uint64_t futex_wait_queue_me(struct futex_hash_bucket *hb, struct futex_q
 		ihk_mc_spinlock_unlock(&thread->spin_sleep_lock, irqstate);
 	}

-	queue_me(q, hb);
+	queue_me(q, hb, clv_override);
 	
 	if (!plist_node_empty(&q->list)) {
+		if (clv_override) {
+			uti_dkprintf("%s: tid: %d is trying to sleep\n", __FUNCTION__, thread->tid);
+			/* Note that the unit of timeout is nsec */
+			time_remain = (*linux_wait_event)(q->uti_futex_resp, timeout);
+			
+			/* Note that time_remain == 0 indicates contidion evaluated to false after the timeout elapsed */
+			if (time_remain < 0) {
+				if (time_remain == -ERESTARTSYS) { /* Interrupted by signal */
+					uti_dkprintf("%s: DEBUG: wait_event returned -ERESTARTSYS\n", __FUNCTION__);
+				} else {
+					uti_kprintf("%s: ERROR: wait_event returned %d\n", __FUNCTION__, time_remain);
+				}
+			}
+			uti_dkprintf("%s: tid: %d woken up\n", __FUNCTION__, thread->tid);
+		} else {
 		
 		if (timeout) {
-			dkprintf("futex_wait_queue_me(): tid: %d schedule_timeout()\n", cpu_local_var(current)->tid);
+			dkprintf("futex_wait_queue_me(): tid: %d schedule_timeout()\n", thread->tid);
 			time_remain = schedule_timeout(timeout);
 		}
 		else {
-			dkprintf("futex_wait_queue_me(): tid: %d schedule()\n", cpu_local_var(current)->tid);
+			dkprintf("futex_wait_queue_me(): tid: %d schedule()\n", thread->tid);
 			spin_sleep_or_schedule();
 			time_remain = 0;
 		}
-		
-		dkprintf("futex_wait_queue_me(): tid: %d woken up\n", cpu_local_var(current)->tid);
+		dkprintf("futex_wait_queue_me(): tid: %d woken up\n", thread->tid);
+		}
 	}
 	
 	/* This does not need to be serialized */
-	cpu_local_var(current)->status = PS_RUNNING;
+	thread->status = PS_RUNNING;
 	thread->spin_sleep = 0;
 	
 	return time_remain;
@@ -724,7 +774,8 @@ static uint64_t futex_wait_queue_me(struct futex_hash_bucket *hb, struct futex_q
 * <1 - -EFAULT or -EWOULDBLOCK (uaddr does not contain val) and hb is unlcoked
 */
 static int futex_wait_setup(uint32_t __user *uaddr, uint32_t val, int fshared,
-			   struct futex_q *q, struct futex_hash_bucket **hb)
+			    struct futex_q *q, struct futex_hash_bucket **hb,
+			    struct cpu_local_var *clv_override)
 {
 	uint32_t uval;
 	int ret;
@@ -747,7 +798,7 @@ static int futex_wait_setup(uint32_t __user *uaddr, uint32_t val, int fshared,
 	 * rare, but normal.
 	 */
 	q->key = FUTEX_KEY_INIT;
-	ret = get_futex_key(uaddr, fshared, &q->key);
+	ret = get_futex_key(uaddr, fshared, &q->key, clv_override);
 	if (ret != 0)
 		return ret;

@@ -771,46 +822,54 @@ static int futex_wait_setup(uint32_t __user *uaddr, uint32_t val, int fshared,
 }

 static int futex_wait(uint32_t __user *uaddr, int fshared,
-		      uint32_t val, uint64_t timeout, uint32_t bitset, int clockrt)
+		      uint32_t val, uint64_t timeout, uint32_t bitset, int clockrt,
+		      struct cpu_local_var *clv_override)
 {
 	struct futex_hash_bucket *hb;
 	struct futex_q q;
-	uint64_t time_remain;
+	int64_t time_remain;
 	int ret;

 	if (!bitset)
 		return -EINVAL;

 #ifdef PROFILE_ENABLE
-	if (cpu_local_var(current)->profile &&
-			cpu_local_var(current)->profile_start_ts) {
-		cpu_local_var(current)->profile_elapsed_ts +=
-			(rdtsc() - cpu_local_var(current)->profile_start_ts);
-		cpu_local_var(current)->profile_start_ts = 0;
+	if (cpu_local_var_with_override(current, clv_override)->profile &&
+		cpu_local_var_with_override(current, clv_override)->profile_start_ts) {
+		cpu_local_var_with_override(current, clv_override)->profile_elapsed_ts +=
+			(rdtsc() - cpu_local_var_with_override(current, clv_override)->profile_start_ts);
+		cpu_local_var_with_override(current, clv_override)->profile_start_ts = 0;
 	}
 #endif

 	q.bitset = bitset;
 	q.requeue_pi_key = NULL;
+	q.uti_futex_resp = cpu_local_var_with_override(uti_futex_resp, clv_override);

 retry:
 	/* Prepare to wait on uaddr. */
-	ret = futex_wait_setup(uaddr, val, fshared, &q, &hb);
-	if (ret)
+	ret = futex_wait_setup(uaddr, val, fshared, &q, &hb, clv_override);
+	if (ret) {
+		uti_dkprintf("%s: tid=%d futex_wait_setup returns zero, no need to sleep\n", __FUNCTION__, cpu_local_var_with_override(current, clv_override)->tid);
 		goto out;
+	}

 	/* queue_me and wait for wakeup, timeout, or a signal. */
-	time_remain = futex_wait_queue_me(hb, &q, timeout);
+	time_remain = futex_wait_queue_me(hb, &q, timeout, clv_override);

 	/* If we were woken (and unqueued), we succeeded, whatever. */
 	ret = 0;
-	if (!unqueue_me(&q))
+	if (!unqueue_me(&q)) {
+		uti_dkprintf("%s: tid=%d unqueued\n", __FUNCTION__, cpu_local_var_with_override(current, clv_override)->tid);
 		goto out_put_key;
+	}
 	ret = -ETIMEDOUT;

 	/* RIKEN: timer expired case (indicated by !time_remain) */
-	if (timeout && !time_remain)
+	if (timeout && !time_remain) {
+		uti_dkprintf("%s: tid=%d timer expired\n", __FUNCTION__, cpu_local_var_with_override(current, clv_override)->tid);
 		goto out_put_key;
+	}

 	if (hassigpending(cpu_local_var(current))) {
 		ret = -EINTR;
@@ -825,19 +884,22 @@ out_put_key:
 	put_futex_key(fshared, &q.key);
 out:
 #ifdef PROFILE_ENABLE
-	if (cpu_local_var(current)->profile) {
-		cpu_local_var(current)->profile_start_ts = rdtsc();
+	if (cpu_local_var_with_override(current, clv_override)->profile) {
+		cpu_local_var_with_override(current, clv_override)->profile_start_ts = rdtsc();
 	}
 #endif
 	return ret;
 }

 int futex(uint32_t *uaddr, int op, uint32_t val, uint64_t timeout,
-		uint32_t *uaddr2, uint32_t val2, uint32_t val3, int fshared)
+	  uint32_t *uaddr2, uint32_t val2, uint32_t val3, int fshared,
+	  struct cpu_local_var *clv_override)
 {
 	int clockrt, ret = -ENOSYS;
 	int cmd = op & FUTEX_CMD_MASK;

+	uti_dkprintf("%s: uaddr=%p, op=%x, val=%x, timeout=%ld, uaddr2=%p, val2=%x, val3=%x, fshared=%d, clv=%p\n", __FUNCTION__, uaddr, op, val, timeout, uaddr2, val2, val3, fshared, clv_override);
+
 	clockrt = op & FUTEX_CLOCK_REALTIME;
 	if (clockrt && cmd != FUTEX_WAIT_BITSET && cmd != FUTEX_WAIT_REQUEUE_PI)
 		return -ENOSYS;
@@ -846,21 +908,21 @@ int futex(uint32_t *uaddr, int op, uint32_t val, uint64_t timeout,
 	case FUTEX_WAIT:
 		val3 = FUTEX_BITSET_MATCH_ANY;
 	case FUTEX_WAIT_BITSET:
-		ret = futex_wait(uaddr, fshared, val, timeout, val3, clockrt);
+		ret = futex_wait(uaddr, fshared, val, timeout, val3, clockrt, clv_override);
 		break;
 	case FUTEX_WAKE:
 		val3 = FUTEX_BITSET_MATCH_ANY;
 	case FUTEX_WAKE_BITSET:
-		ret = futex_wake(uaddr, fshared, val, val3);
+		ret = futex_wake(uaddr, fshared, val, val3, clv_override);
 		break;
 	case FUTEX_REQUEUE:
-		ret = futex_requeue(uaddr, fshared, uaddr2, val, val2, NULL, 0);
+		ret = futex_requeue(uaddr, fshared, uaddr2, val, val2, NULL, 0, clv_override);
 		break;
 	case FUTEX_CMP_REQUEUE:
-		ret = futex_requeue(uaddr, fshared, uaddr2, val, val2, &val3, 0);
+		ret = futex_requeue(uaddr, fshared, uaddr2, val, val2, &val3, 0, clv_override);
 		break;
 	case FUTEX_WAKE_OP:
-		ret = futex_wake_op(uaddr, fshared, uaddr2, val, val2, val3);
+		ret = futex_wake_op(uaddr, fshared, uaddr2, val, val2, val3, clv_override);
 		break;
 	/* RIKEN: these calls are not supported for now.	
 	case FUTEX_LOCK_PI:
--- a/kernel/include/cls.h
+++ b/kernel/include/cls.h
@@ -100,6 +100,9 @@ struct cpu_local_var {
 	struct list_head smp_func_req_list;

 	struct process_vm *on_fork_vm;
+
+	/* UTI */
+	void *uti_futex_resp;
 } __attribute__((aligned(64)));


@@ -111,4 +114,6 @@ static struct cpu_local_var *get_this_cpu_local_var(void)

 #define cpu_local_var(name) get_this_cpu_local_var()->name

+#define cpu_local_var_with_override(name, clv_override) (clv_override ? clv_override->name : get_this_cpu_local_var()->name)
+
 #endif
--- a/kernel/include/futex.h
+++ b/kernel/include/futex.h
@@ -150,6 +150,7 @@ union futex_key {

 extern int futex_init(void);

+struct cpu_local_var;
 extern int
 futex(
 	uint32_t __user *		uaddr,
@@ -159,7 +160,8 @@ futex(
 	uint32_t __user *		uaddr2,
 	uint32_t				val2,
 	uint32_t				val3,
-	int                     fshared
+	int                     fshared,
+	struct cpu_local_var *clv_override
 );


--- a/kernel/include/syscall.h
+++ b/kernel/include/syscall.h
@@ -83,6 +83,8 @@
 #define SCD_MSG_CPU_RW_REG              0x52
 #define SCD_MSG_CPU_RW_REG_RESP         0x53

+#define SCD_MSG_FUTEX_WAKE              0x60
+
 /* Cloning flags.  */
 # define CSIGNAL       0x000000ff /* Signal mask to be sent at exit.  */
 # define CLONE_VM      0x00000100 /* Set if VM shared between processes.  */
@@ -276,6 +278,12 @@ struct ikc_scd_packet {
 		struct {
 			int eventfd_type;
 		};
+
+		/* SCD_MSG_FUTEX_WAKE */
+		struct {
+			void *resp;
+			int *spin_sleep; /* 1: waiting in linux_wait_event() 0: woken up by someone else */
+		} futex;
 	};
 	char padding[8];
 };
@@ -475,6 +483,14 @@ int arch_cpu_read_write_register(struct ihk_os_cpu_register *desc,
 		enum mcctrl_os_cpu_operation op);
 struct vm_range_numa_policy *vm_range_policy_search(struct process_vm *vm, uintptr_t addr);
 time_t time(void);
+long do_futex(int n, unsigned long arg0, unsigned long arg1,
+			  unsigned long arg2, unsigned long arg3,
+			  unsigned long arg4, unsigned long arg5,
+			  unsigned long _uti_clv,
+			  void *uti_futex_resp,
+			  void *_linux_wait_event,
+			  void *_linux_printk,
+			  void *_linux_clock_gettime);

 #ifndef POSTK_DEBUG_ARCH_DEP_52
 #define VDSO_MAXPAGES 2
@@ -592,4 +608,9 @@ struct move_pages_smp_req {
 #define PROCESS_VM_READ		0
 #define PROCESS_VM_WRITE	1

+/* uti: function pointers pointing to Linux codes */
+extern long (*linux_wait_event)(void *_resp, unsigned long nsec_timeout);
+extern int (*linux_printk)(const char *fmt, ...);
+extern int (*linux_clock_gettime)(clockid_t clk_id, struct timespec *tp);
+
 #endif
--- a/kernel/include/time.h
+++ b/kernel/include/time.h
@@ -25,6 +25,8 @@
 #define CLOCK_PROCESS_CPUTIME_ID	2
 #define CLOCK_THREAD_CPUTIME_ID		3

+typedef int clockid_t;
+
 typedef long int __time_t;

 /* POSIX.1b structure for a time value.  This is like a `struct timeval' but
--- a/kernel/init.c
+++ b/kernel/init.c
@@ -251,6 +251,11 @@ static void nmi_init()
 	ihk_set_nmi_mode_addr(phys);
 }

+static void uti_init()
+{
+	ihk_set_mckernel_do_futex((unsigned long)do_futex);
+}
+
 static void rest_init(void)
 {
 	handler_init();
@@ -266,6 +271,7 @@ static void rest_init(void)
 #endif /* !POSTK_DEBUG_TEMP_FIX_73 */
 	cpu_local_var_init();
 	nmi_init();
+	uti_init();
 	time_init();
 	kmalloc_init();

--- a/kernel/syscall.c
+++ b/kernel/syscall.c
@@ -74,6 +74,13 @@
 #define DDEBUG_DEFAULT DDEBUG_PRINT
 #endif

+#define DEBUG_UTI
+#ifdef DEBUG_UTI
+#define uti_dkprintf(...) do { ((uti_clv && linux_printk) ? (*linux_printk) : kprintf)(__VA_ARGS__); } while (0)
+#else
+#define uti_dkprintf(...) do { } while (0)
+#endif
+
 //static ihk_atomic_t pid_cnt = IHK_ATOMIC_INIT(1024);

 /* generate system call handler's prototypes */
@@ -139,6 +146,10 @@ static void do_mod_exit(int status);
 */
 #define NR_TIDS (allow_oversubscribe ? (num_processors * 2) : num_processors)

+long (*linux_wait_event)(void *_resp, unsigned long nsec_timeout);
+int (*linux_printk)(const char *fmt, ...);
+int (*linux_clock_gettime)(clockid_t clk_id, struct timespec *tp);
+
 static void send_syscall(struct syscall_request *req, int cpu, int pid, struct syscall_response *res)
 {
 	struct ikc_scd_packet packet IHK_DMA_ALIGN;
@@ -264,10 +275,21 @@ long do_syscall(struct syscall_request *req, int cpu, int pid)
 		++thread->in_syscall_offload;
 	}

-	/* The current thread is the requester and any thread from 
-	 * the pool may serve the request */
+	/* The current thread is the requester */
 	req->rtid = cpu_local_var(current)->tid;
-	req->ttid = 0;
+
+	if (req->number == __NR_sched_setaffinity && req->args[0] == 0) {
+		/* mcexec thread serving migrate-to-Linux request must have
+		   the same tid as the requesting McKernel thread because the
+		   serving thread jumps to hfi driver and then jumps to
+		   rus_vm_fault() without registering it into per thread data
+		   by mcctrl_add_per_thread_data()). */
+		req->ttid = cpu_local_var(current)->tid/*0*/;
+		dkprintf("%s: uti, ttid=%d\n", __FUNCTION__, req->ttid);
+	} else {
+		/* Any thread from the pool may serve the request */
+		req->ttid = 0;
+	}
 	res.req_thread_status = IHK_SCD_REQ_THREAD_SPINNING;
 #ifdef POSTK_DEBUG_TEMP_FIX_26 /* do_syscall arg pid is not targetpid */
 	send_syscall(req, cpu, target_pid, &res);
@@ -5323,8 +5345,16 @@ SYSCALL_DECLARE(shmdt)
 	return 0;
 } /* sys_shmdt() */

-SYSCALL_DECLARE(futex)
+long do_futex(int n, unsigned long arg0, unsigned long arg1,
+			  unsigned long arg2, unsigned long arg3,
+			  unsigned long arg4, unsigned long arg5,
+			  unsigned long _uti_clv,
+			  void *uti_futex_resp,
+			  void *_linux_wait_event,
+			  void *_linux_printk,
+			  void *_linux_clock_gettime)
 {
+	struct cpu_local_var *uti_clv = (struct cpu_local_var *)_uti_clv;
 	uint64_t timeout = 0; // No timeout
 	uint32_t val2 = 0;
 	// Only one clock is used, ignore FUTEX_CLOCK_REALTIME
@@ -5332,24 +5362,44 @@ SYSCALL_DECLARE(futex)
 	int fshared = 1;
 	int ret = 0;

-	uint32_t *uaddr = (uint32_t *)ihk_mc_syscall_arg0(ctx);
-	int op = (int)ihk_mc_syscall_arg1(ctx);
-	uint32_t val = (uint32_t)ihk_mc_syscall_arg2(ctx);
-	struct timespec *utime = (struct timespec*)ihk_mc_syscall_arg3(ctx);
-	uint32_t *uaddr2 = (uint32_t *)ihk_mc_syscall_arg4(ctx);
-	uint32_t val3 = (uint32_t)ihk_mc_syscall_arg5(ctx);
+	uint32_t *uaddr = (uint32_t *)arg0;
+	int op = (int)arg1;
+	uint32_t val = (uint32_t)arg2;
+	struct timespec *utime = (struct timespec*)arg3;
+	uint32_t *uaddr2 = (uint32_t *)arg4;
+	uint32_t val3 = (uint32_t)arg5;
 	int flags = op;
-   	struct ihk_os_cpu_monitor *monitor = cpu_local_var(monitor);

-	monitor->status = IHK_OS_MONITOR_KERNEL_HEAVY;
- 
+
+	/* TODO: replace these with passing via struct smp_boot_param */
+	if (_linux_printk && !linux_printk) {
+		linux_printk = (int (*)(const char *fmt, ...))_linux_printk;
+	}
+	if (_linux_wait_event && !linux_wait_event) {
+		linux_wait_event = (long (*)(void *_resp, unsigned long nsec_timeout))_linux_wait_event;
+	}
+	if (_linux_clock_gettime && !linux_clock_gettime) {
+		linux_clock_gettime = (int (*)(clockid_t clk_id, struct timespec *tp))_linux_clock_gettime;
+	}
+
+	/* Fill in clv */
+	if (uti_clv) {
+		uti_clv->uti_futex_resp = uti_futex_resp;
+	}
+
+	/* monitor is per-cpu object */
+	if (!uti_clv) {
+		struct ihk_os_cpu_monitor *monitor = cpu_local_var(monitor);
+		monitor->status = IHK_OS_MONITOR_KERNEL_HEAVY;
+	} 
+
 	/* Cross-address space futex? */
 	if (op & FUTEX_PRIVATE_FLAG) {
 		fshared = 0;
 	}
 	op = (op & FUTEX_CMD_MASK);
 	
-	dkprintf("futex op=[%x, %s],uaddr=%lx, val=%x, utime=%lx, uaddr2=%lx, val3=%x, []=%x, shared: %d\n", 
+	uti_dkprintf("futex op=[%x, %s],uaddr=%lx, val=%x, utime=%lx, uaddr2=%lx, val3=%x, []=%x, shared: %d\n", 
 			flags,
 			(op == FUTEX_WAIT) ? "FUTEX_WAIT" :
 			(op == FUTEX_WAIT_BITSET) ? "FUTEX_WAIT_BITSET" :
@@ -5360,8 +5410,13 @@ SYSCALL_DECLARE(futex)
 			(op == FUTEX_REQUEUE) ? "FUTEX_REQUEUE (NOT IMPL!)" : "unknown",
 			(unsigned long)uaddr, val, utime, uaddr2, val3, *uaddr, fshared);

+	if ((op == FUTEX_WAIT || op == FUTEX_WAIT_BITSET) && utime) {
+		uti_dkprintf("%s: utime=%ld.%09ld\n", __FUNCTION__, utime->tv_sec, utime->tv_nsec);
+	}
 	if (utime && (op == FUTEX_WAIT_BITSET || op == FUTEX_WAIT)) {
 		unsigned long nsec_timeout;
+		if (!uti_clv) {
+			/* Use cycles for non-UTI case */

 		/* As per the Linux implementation FUTEX_WAIT specifies the duration of
 		 * the timeout, while FUTEX_WAIT_BITSET specifies the absolute timestamp */
@@ -5407,19 +5462,35 @@ SYSCALL_DECLARE(futex)
 		else {
 			nsec_timeout = (utime->tv_sec * NS_PER_SEC + utime->tv_nsec);
 		}
-
 		timeout = nsec_timeout * 1000 / ihk_mc_get_ns_per_tsc();
-		dkprintf("futex timeout: %lu\n", timeout);
+
+		}
+		else{
+			if (op == FUTEX_WAIT_BITSET) { /* User passed absolute time */
+				struct timespec ats;
+				ret = (*linux_clock_gettime)((flags & FUTEX_CLOCK_REALTIME) ? CLOCK_REALTIME: CLOCK_MONOTONIC, &ats);
+				if (ret) {
+					return ret;
+				}
+				uti_dkprintf("%s: ats=%ld.%09ld\n", __FUNCTION__, ats.tv_sec, ats.tv_nsec);
+				/* Use nsec for UTI case */
+				timeout = (utime->tv_sec * NS_PER_SEC + utime->tv_nsec) -
+					(ats.tv_sec * NS_PER_SEC + ats.tv_nsec);
+			} else { /* User passed relative time */
+				/* Use nsec for UTI case */
+				timeout = (utime->tv_sec * NS_PER_SEC + utime->tv_nsec);
+			}
+		}
 	}

 	/* Requeue parameter in 'utime' if op == FUTEX_CMP_REQUEUE.
 	 * number of waiters to wake in 'utime' if op == FUTEX_WAKE_OP. */
 	if (op == FUTEX_CMP_REQUEUE || op == FUTEX_WAKE_OP)
-		val2 = (uint32_t) (unsigned long) ihk_mc_syscall_arg3(ctx);
+		val2 = (uint32_t) (unsigned long) arg3;

-	ret = futex(uaddr, op, val, timeout, uaddr2, val2, val3, fshared);
+	ret = futex(uaddr, op, val, timeout, uaddr2, val2, val3, fshared, uti_clv);

-	dkprintf("futex op=[%x, %s],uaddr=%lx, val=%x, utime=%lx, uaddr2=%lx, val3=%x, []=%x, shared: %d, ret: %d\n", 
+	uti_dkprintf("futex op=[%x, %s],uaddr=%lx, val=%x, utime=%lx, uaddr2=%lx, val3=%x, []=%x, shared: %d, ret: %d\n", 
 			op,
 			(op == FUTEX_WAIT) ? "FUTEX_WAIT" :
 			(op == FUTEX_WAIT_BITSET) ? "FUTEX_WAIT_BITSET" :
@@ -5433,6 +5504,14 @@ SYSCALL_DECLARE(futex)
 	return ret;
 }

+SYSCALL_DECLARE(futex)
+{
+	return do_futex(n, ihk_mc_syscall_arg0(ctx), ihk_mc_syscall_arg1(ctx),
+					ihk_mc_syscall_arg2(ctx), ihk_mc_syscall_arg3(ctx),
+					ihk_mc_syscall_arg4(ctx), ihk_mc_syscall_arg5(ctx),
+					0UL, NULL, NULL, NULL, NULL);
+}
+
 static void
 do_exit(int code)
 {
@@ -5474,7 +5553,7 @@ do_exit(int code)
 		setint_user((int*)thread->clear_child_tid, 0);
 		barrier();
 		futex((uint32_t *)thread->clear_child_tid,
-		      FUTEX_WAKE, 1, 0, NULL, 0, 0, 1);
+		      FUTEX_WAKE, 1, 0, NULL, 0, 0, 1, NULL);
 	}

 	mcs_rwlock_writer_lock(&proc->threads_lock, &lock);
@@ -8998,6 +9077,7 @@ util_thread(struct uti_attr *arg)
 {
 	volatile unsigned long *context;
 	unsigned long pcontext;
+	struct cpu_local_var *uti_clv;
 	struct syscall_request request IHK_DMA_ALIGN;
 	long rc;
 	struct thread *thread = cpu_local_var(current);
@@ -9016,6 +9096,14 @@ util_thread(struct uti_attr *arg)
 	pcontext = virt_to_phys((void *)context);
 	save_uctx((void *)context, NULL);

+	/* Create a copy of clv and replace clv with it when the Linux thread calls in a McKernel function */
+	uti_clv = kmalloc(sizeof(struct cpu_local_var), IHK_MC_AP_NOWAIT);
+	if (!uti_clv) {
+		ihk_mc_free_pages((void *)context, 1);
+		return -ENOMEM;
+	}
+	memcpy(uti_clv, get_this_cpu_local_var(), sizeof(struct cpu_local_var));
+
 	request.number = __NR_sched_setaffinity;
 	request.args[0] = 0;
 	request.args[1] = pcontext;
@@ -9025,19 +9113,23 @@ util_thread(struct uti_attr *arg)
 		kattr.parent_cpuid = thread->parent_cpuid;
 		request.args[2] = virt_to_phys(&kattr);
 	}
+	request.args[3] = (unsigned long)uti_clv;
 	thread->thread_offloaded = 1;
 	rc = do_syscall(&request, ihk_mc_get_processor_id(), 0);
 	thread->thread_offloaded = 0;
 	free_address = context[0];
 	free_size = context[1];
 	ihk_mc_free_pages((void *)context, 1);
+	kfree(uti_clv);

 	if (rc >= 0) {
 		if (rc & 0x10000007f) { // exit_group || signal
+			dkprintf("%s: exit_group || signal\n", __FUNCTION__);
 			thread->proc->nohost = 1;
 			terminate((rc >> 8) & 255, rc & 255);
 		}
 		else {
+			dkprintf("%s: !exit_group && !signal\n", __FUNCTION__);
 			request.number = __NR_sched_setaffinity;
 			request.args[0] = 1;
 			request.args[1] = free_address;