prerelease: 0.94: fix __mcctrl_os_read_write_cpu_register

Change-Id: Ibcfbe7796347cc9c2148cdea2519fe6c7ca9e97e
move_pages: Fix and support some specs for LTP.
2021-02-18 15:23:01 +09:00 · 2021-02-18 06:16:17 +00:00 · 2021-02-18 06:16:17 +00:00 · 2021-02-18 06:16:17 +00:00 · 2021-02-18 06:16:17 +00:00 · 2021-02-18 06:16:17 +00:00
54 changed files with 3811 additions and 386 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 2.6)
+cmake_minimum_required(VERSION 3.11)

 if (NOT CMAKE_BUILD_TYPE)
 	set (CMAKE_BUILD_TYPE "Debug" CACHE STRING "Build type: Debug Release..." FORCE)
@ -10,7 +10,7 @@ project(mckernel C ASM)
 set(MCKERNEL_VERSION "1.7.1")

 # See "Fedora Packaging Guidelines -- Versioning"
-set(MCKERNEL_RELEASE "0.6")
+set(MCKERNEL_RELEASE "0.94")

 set(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/modules)
 # for rpmbuild
@ -65,7 +65,7 @@ if(ENABLE_TOFU)
 endif()

 # when compiling on a compute-node
-execute_process(COMMAND bash -c "grep $(hostname) /etc/opt/FJSVfefs/config/fefs_node1.csv 2>/dev/null | cut -d, -f2"
+execute_process(COMMAND bash -c "grep $(hostname) /etc/opt/FJSVfefs/config/fefs_node1.csv 2>/dev/null | cut -d, -f2 | grep -o CN"
  OUTPUT_VARIABLE FUGAKU_NODE_TYPE OUTPUT_STRIP_TRAILING_WHITESPACE)
 if(FUGAKU_NODE_TYPE STREQUAL "CN")
 	option(ENABLE_FUGAKU_HACKS "Fugaku hacks" ON)
@ -78,6 +78,22 @@ if(ENABLE_FUGAKU_HACKS)
 	set(KBUILD_C_FLAGS "${KBUILD_C_FLAGS} -DENABLE_FUGAKU_HACKS")
 endif()

+# krm that mandates reserved memory amount >= available at boot time?
+execute_process(COMMAND bash -c "rpm -qi FJSVpxkrm-plugin-mckernel | awk '$1 == \"Version\" && $2 == \":\" { print $3 }'"
+  OUTPUT_VARIABLE KRM_VERSION OUTPUT_STRIP_TRAILING_WHITESPACE)
+message("KRM_VERSION: ${KRM_VERSION}")
+
+if(NOT "${KRM_VERSION}" STREQUAL "" AND "${KRM_VERSION}" VERSION_LESS_EQUAL 4.0.1)
+	option(ENABLE_KRM_WORKAROUND "krm workaround" ON)
+else()
+	option(ENABLE_KRM_WORKAROUND "krm workaround" OFF)
+endif()
+
+if(ENABLE_KRM_WORKAROUND)
+	add_definitions(-DENABLE_KRM_WORKAROUND)
+	set(KBUILD_C_FLAGS "${KBUILD_C_FLAGS} -DENABLE_KRM_WORKAROUND")
+endif()
+
 # SIGSTOP instead of SIGSEGV, additional IHK Linux kmsg
 option(ENABLE_FUGAKU_DEBUG "Fugaku debug instrumentation" OFF)

@ -297,6 +313,7 @@ message("ENABLE_PERF: ${ENABLE_PERF}")
 message("ENABLE_TOFU: ${ENABLE_TOFU}")
 message("ENABLE_FUGAKU_HACKS: ${ENABLE_FUGAKU_HACKS}")
 message("ENABLE_FUGAKU_DEBUG: ${ENABLE_FUGAKU_DEBUG}")
+message("ENABLE_KRM_WORKAROUND: ${ENABLE_KRM_WORKAROUND}")
 message("PROFILE_ENABLE: ${PROFILE_ENABLE}")
 message("ENABLE_RUSAGE: ${ENABLE_RUSAGE}")
 message("ENABLE_QLMPI: ${ENABLE_QLMPI}")
--- a/arch/arm64/kernel/cpu.c
+++ b/arch/arm64/kernel/cpu.c
@ -1972,15 +1972,15 @@ int arch_cpu_read_write_register(
 	return ret;
 }

-int smp_call_func(cpu_set_t *__cpu_set, smp_func_t __func, void *__arg)
-{
-	/* TODO: skeleton for smp_call_func */
-	return -1;
-}
-
 void arch_flush_icache_all(void)
 {
 	asm("ic	ialluis");
 	dsb(ish);
 }
+
+int ihk_mc_get_smp_handler_irq(void)
+{
+	return LOCAL_SMP_FUNC_CALL_VECTOR;
+}
+
 /*** end of file ***/
--- a/arch/arm64/kernel/include/irq.h
+++ b/arch/arm64/kernel/include/irq.h
@ -17,6 +17,7 @@
 #define INTRID_STACK_TRACE	5
 #define INTRID_MULTI_INTR	6
 #define INTRID_MULTI_NMI	7
+#define LOCAL_SMP_FUNC_CALL_VECTOR   1 /* same as IKC */

 /* use PPI interrupt number */
 #define INTRID_PERF_OVF		23
--- a/arch/arm64/kernel/syscall.c
+++ b/arch/arm64/kernel/syscall.c
@ -16,6 +16,7 @@
 #include <uio.h>
 #include <syscall.h>
 #include <rusage_private.h>
+#include <memory.h>
 #include <ihk/debug.h>

 void terminate_mcexec(int, int);
@ -2250,8 +2251,10 @@ int move_pages_smp_handler(int cpu_index, int nr_cpus, void *arg)
 		case 0:
 			memcpy(mpsr->virt_addr, mpsr->user_virt_addr,
 			       sizeof(void *) * count);
-			memcpy(mpsr->nodes, mpsr->user_nodes,
-			       sizeof(int) * count);
+			if (mpsr->user_nodes) {
+				memcpy(mpsr->nodes, mpsr->user_nodes,
+						sizeof(int) * count);
+			}
 			memset(mpsr->ptep, 0, sizeof(pte_t) * count);
 			memset(mpsr->status, 0, sizeof(int) * count);
 			memset(mpsr->nr_pages, 0, sizeof(int) * count);
@ -2269,8 +2272,10 @@ int move_pages_smp_handler(int cpu_index, int nr_cpus, void *arg)
 		case 0:
 			memcpy(mpsr->virt_addr, mpsr->user_virt_addr,
 			       sizeof(void *) * count);
-			memcpy(mpsr->nodes, mpsr->user_nodes,
-			       sizeof(int) * count);
+			if (mpsr->user_nodes) {
+				memcpy(mpsr->nodes, mpsr->user_nodes,
+						sizeof(int) * count);
+			}
 			mpsr->nodes_ready = 1;
 			break;
 		case 1:
@ -2292,8 +2297,10 @@ int move_pages_smp_handler(int cpu_index, int nr_cpus, void *arg)
 			       sizeof(void *) * count);
 			break;
 		case 1:
-			memcpy(mpsr->nodes, mpsr->user_nodes,
-			       sizeof(int) * count);
+			if (mpsr->user_nodes) {
+				memcpy(mpsr->nodes, mpsr->user_nodes,
+						sizeof(int) * count);
+			}
 			mpsr->nodes_ready = 1;
 			break;
 		case 2:
@ -2322,8 +2329,10 @@ int move_pages_smp_handler(int cpu_index, int nr_cpus, void *arg)
 			       sizeof(void *) * (count / 2));
 			break;
 		case 2:
-			memcpy(mpsr->nodes, mpsr->user_nodes,
-			       sizeof(int) * count);
+			if (mpsr->user_nodes) {
+				memcpy(mpsr->nodes, mpsr->user_nodes,
+						sizeof(int) * count);
+			}
 			mpsr->nodes_ready = 1;
 			break;
 		case 3:
@ -2349,13 +2358,15 @@ int move_pages_smp_handler(int cpu_index, int nr_cpus, void *arg)
 	}

 	/* NUMA verification in parallel */
-	for (i = i_s; i < i_e; i++) {
-		if (mpsr->nodes[i] < 0 ||
-				mpsr->nodes[i] >= ihk_mc_get_nr_numa_nodes() ||
-				!test_bit(mpsr->nodes[i],
-					mpsr->proc->vm->numa_mask)) {
-			mpsr->phase_ret = -EINVAL;
-			break;
+	if (mpsr->user_nodes) {
+		for (i = i_s; i < i_e; i++) {
+			if (mpsr->nodes[i] < 0 ||
+					mpsr->nodes[i] >= ihk_mc_get_nr_numa_nodes() ||
+					!test_bit(mpsr->nodes[i],
+						mpsr->proc->vm->numa_mask)) {
+				mpsr->phase_ret = -EINVAL;
+				break;
+			}
 		}
 	}

@ -2387,7 +2398,7 @@ int move_pages_smp_handler(int cpu_index, int nr_cpus, void *arg)

 		/* PTE valid? */
 		if (!mpsr->ptep[i] || !pte_is_present(mpsr->ptep[i])) {
-			mpsr->status[i] = -ENOENT;
+			mpsr->status[i] = -EFAULT;
 			mpsr->ptep[i] = NULL;
 			continue;
 		}
@ -2451,6 +2462,26 @@ pte_out:
 	dkprintf("%s: phase %d done\n", __FUNCTION__, phase);
 	++phase;

+	/*
+	 * When nodes array is NULL, move_pages doesn't move any pages,
+	 * instead will return the node where each page
+	 * currently resides by status array.
+	 */
+	if (!mpsr->user_nodes) {
+		/* get nid in parallel */
+		for (i = i_s; i < i_e; i++) {
+			if (mpsr->status[i] < 0) {
+				continue;
+			}
+			mpsr->status[i] = phys_to_nid(
+					pte_get_phys(mpsr->ptep[i]));
+		}
+		mpsr->phase_ret = 0;
+		goto out;  // return node information
+	}
+
+	/* Processing of move pages */
+
 	if (cpu_index == 0) {
 		/* Allocate new pages on target NUMA nodes */
 		for (i = 0; i < count; i++) {
@ -2463,8 +2494,11 @@ pte_out:

 			/* TODO: store pgalign info in an array as well? */
 			if (mpsr->nr_pages[i] > 1) {
-				if (mpsr->nr_pages[i] * PAGE_SIZE == PTL2_SIZE)
-					pgalign = PTL2_SHIFT - PTL1_SHIFT;
+				int nr_pages;
+
+				for (pgalign = 0, nr_pages = mpsr->nr_pages[i];
+				     nr_pages != 1; pgalign++, nr_pages >>= 1) {
+				}
 			}

 			dst = ihk_mc_alloc_aligned_pages_node(mpsr->nr_pages[i],
--- a/arch/x86_64/kernel/cpu.c
+++ b/arch/x86_64/kernel/cpu.c
@ -80,7 +80,11 @@ static void (*lapic_icr_write)(unsigned int h, unsigned int l);
 static void (*lapic_wait_icr_idle)(void);
 void (*x86_issue_ipi)(unsigned int apicid, unsigned int low);
 int running_on_kvm(void);
-static void smp_func_call_handler(void);
+void smp_func_call_handler(void);
+int ihk_mc_get_smp_handler_irq(void)
+{
+	return LOCAL_SMP_FUNC_CALL_VECTOR;
+}

 void init_processors_local(int max_id);
 void assign_processor_id(void);
@ -2170,144 +2174,6 @@ int arch_cpu_read_write_register(
 	return 0;
 }

-/*
- * Generic remote CPU function invocation facility.
- */
-static void smp_func_call_handler(void)
-{
-	int irq_flags;
-	struct smp_func_call_request *req;
-	int reqs_left;
-
-reiterate:
-	req = NULL;
-	reqs_left = 0;
-
-	irq_flags = ihk_mc_spinlock_lock(
-			&cpu_local_var(smp_func_req_lock));
-
-	/* Take requests one-by-one */
-	if (!list_empty(&cpu_local_var(smp_func_req_list))) {
-		req = list_first_entry(&cpu_local_var(smp_func_req_list),
-			struct smp_func_call_request, list);
-		list_del(&req->list);
-
-		reqs_left = !list_empty(&cpu_local_var(smp_func_req_list));
-	}
-
-	ihk_mc_spinlock_unlock(&cpu_local_var(smp_func_req_lock),
-			irq_flags);
-
-	if (req) {
-		req->ret = req->sfcd->func(req->cpu_index,
-				req->sfcd->nr_cpus, req->sfcd->arg);
-		ihk_atomic_dec(&req->sfcd->cpus_left);
-	}
-
-	if (reqs_left)
-		goto reiterate;
-}
-
-int smp_call_func(cpu_set_t *__cpu_set, smp_func_t __func, void *__arg)
-{
-	int cpu, nr_cpus = 0;
-	int cpu_index = 0;
-	int this_cpu_index = 0;
-	struct smp_func_call_data sfcd;
-	struct smp_func_call_request *reqs;
-	int ret = 0;
-	int call_on_this_cpu = 0;
-	cpu_set_t cpu_set;
-
-	/* Sanity checks */
-	if (!__cpu_set || !__func) {
-		return -EINVAL;
-	}
-
-	/* Make sure it won't change in between */
-	cpu_set = *__cpu_set;
-
-	for_each_set_bit(cpu, (unsigned long *)&cpu_set,
-			sizeof(cpu_set) * BITS_PER_BYTE) {
-
-		if (cpu == ihk_mc_get_processor_id()) {
-			call_on_this_cpu = 1;
-		}
-		++nr_cpus;
-	}
-
-	if (!nr_cpus) {
-		return -EINVAL;
-	}
-
-	reqs = kmalloc(sizeof(*reqs) * nr_cpus, IHK_MC_AP_NOWAIT);
-	if (!reqs) {
-		ret = -ENOMEM;
-		goto free_out;
-	}
-
-	sfcd.nr_cpus = nr_cpus;
-	sfcd.func = __func;
-	sfcd.arg = __arg;
-	ihk_atomic_set(&sfcd.cpus_left,
-			call_on_this_cpu ? nr_cpus - 1 : nr_cpus);
-
-	/* Add requests and send IPIs */
-	cpu_index = 0;
-	for_each_set_bit(cpu, (unsigned long *)&cpu_set,
-			sizeof(cpu_set) * BITS_PER_BYTE) {
-		unsigned long irq_flags;
-
-		reqs[cpu_index].cpu_index = cpu_index;
-		reqs[cpu_index].ret = 0;
-
-		if (cpu == ihk_mc_get_processor_id()) {
-			this_cpu_index = cpu_index;
-			++cpu_index;
-			continue;
-		}
-
-		reqs[cpu_index].sfcd = &sfcd;
-
-		irq_flags =
-			ihk_mc_spinlock_lock(&get_cpu_local_var(cpu)->smp_func_req_lock);
-		list_add_tail(&reqs[cpu_index].list,
-				&get_cpu_local_var(cpu)->smp_func_req_list);
-		ihk_mc_spinlock_unlock(&get_cpu_local_var(cpu)->smp_func_req_lock,
-			irq_flags);
-
-		ihk_mc_interrupt_cpu(cpu, LOCAL_SMP_FUNC_CALL_VECTOR);
-
-		++cpu_index;
-	}
-
-	/* Is this CPU involved? */
-	if (call_on_this_cpu) {
-		reqs[this_cpu_index].ret =
-			__func(this_cpu_index, nr_cpus, __arg);
-	}
-
-	/* Wait for the rest of the CPUs */
-	while (ihk_atomic_read(&sfcd.cpus_left) > 0) {
-		cpu_pause();
-	}
-
-	/* Check return values, if error, report the first non-zero */
-	for (cpu_index = 0; cpu_index < nr_cpus; ++cpu_index) {
-		if (reqs[cpu_index].ret != 0) {
-			ret = reqs[cpu_index].ret;
-			goto free_out;
-		}
-	}
-
-	ret = 0;
-
-free_out:
-	kfree(reqs);
-
-	return ret;
-}
-
 extern int nmi_mode;
 extern long freeze_thaw(void *nmi_ctx);

--- a/arch/x86_64/kernel/syscall.c
+++ b/arch/x86_64/kernel/syscall.c
@ -32,6 +32,7 @@
 #include <limits.h>
 #include <syscall.h>
 #include <rusage_private.h>
+#include <memory.h>
 #include <ihk/debug.h>

 void terminate_mcexec(int, int);
@ -2302,8 +2303,10 @@ int move_pages_smp_handler(int cpu_index, int nr_cpus, void *arg)
 			case 0:
 				memcpy(mpsr->virt_addr, mpsr->user_virt_addr,
 						sizeof(void *) * count);
-				memcpy(mpsr->nodes, mpsr->user_nodes,
-						sizeof(int) * count);
+				if (mpsr->user_nodes) {
+					memcpy(mpsr->nodes, mpsr->user_nodes,
+							sizeof(int) * count);
+				}
 				memset(mpsr->ptep, 0, sizeof(pte_t) * count);
 				memset(mpsr->status, 0, sizeof(int) * count);
 				memset(mpsr->nr_pages, 0, sizeof(int) * count);
@ -2321,8 +2324,10 @@ int move_pages_smp_handler(int cpu_index, int nr_cpus, void *arg)
 			case 0:
 				memcpy(mpsr->virt_addr, mpsr->user_virt_addr,
 						sizeof(void *) * count);
-				memcpy(mpsr->nodes, mpsr->user_nodes,
-						sizeof(int) * count);
+				if (mpsr->user_nodes) {
+					memcpy(mpsr->nodes, mpsr->user_nodes,
+							sizeof(int) * count);
+				}
 				mpsr->nodes_ready = 1;
 				break;
 			case 1:
@ -2344,8 +2349,10 @@ int move_pages_smp_handler(int cpu_index, int nr_cpus, void *arg)
 						sizeof(void *) * count);
 				break;
 			case 1:
-				memcpy(mpsr->nodes, mpsr->user_nodes,
-						sizeof(int) * count);
+				if (mpsr->user_nodes) {
+					memcpy(mpsr->nodes, mpsr->user_nodes,
+							sizeof(int) * count);
+				}
 				mpsr->nodes_ready = 1;
 				break;
 			case 2:
@ -2374,8 +2381,10 @@ int move_pages_smp_handler(int cpu_index, int nr_cpus, void *arg)
 						sizeof(void *) * (count / 2));
 				break;
 			case 2:
-				memcpy(mpsr->nodes, mpsr->user_nodes,
-						sizeof(int) * count);
+				if (mpsr->user_nodes) {
+					memcpy(mpsr->nodes, mpsr->user_nodes,
+							sizeof(int) * count);
+				}
 				mpsr->nodes_ready = 1;
 				break;
 			case 3:
@ -2401,13 +2410,15 @@ int move_pages_smp_handler(int cpu_index, int nr_cpus, void *arg)
 	}

 	/* NUMA verification in parallel */
-	for (i = i_s; i < i_e; i++) {
-		if (mpsr->nodes[i] < 0 ||
-				mpsr->nodes[i] >= ihk_mc_get_nr_numa_nodes() ||
-				!test_bit(mpsr->nodes[i],
-					mpsr->proc->vm->numa_mask)) {
-			mpsr->phase_ret = -EINVAL;
-			break;
+	if (mpsr->user_nodes) {
+		for (i = i_s; i < i_e; i++) {
+			if (mpsr->nodes[i] < 0 ||
+					mpsr->nodes[i] >= ihk_mc_get_nr_numa_nodes() ||
+					!test_bit(mpsr->nodes[i],
+						mpsr->proc->vm->numa_mask)) {
+				mpsr->phase_ret = -EINVAL;
+				break;
+			}
 		}
 	}

@ -2503,6 +2514,26 @@ pte_out:
 	dkprintf("%s: phase %d done\n", __FUNCTION__, phase);
 	++phase;

+	/*
+	 * When nodes array is NULL, move_pages doesn't move any pages,
+	 * instead will return the node where each page
+	 * currently resides by status array.
+	 */
+	if (!mpsr->user_nodes) {
+		/* get nid in parallel */
+		for (i = i_s; i < i_e; i++) {
+			if (mpsr->status[i] < 0) {
+				continue;
+			}
+			mpsr->status[i] = phys_to_nid(
+					pte_get_phys(mpsr->ptep[i]));
+		}
+		mpsr->phase_ret = 0;
+		goto out;  // return node information
+	}
+
+	/* Processing of move pages */
+
 	if (cpu_index == 0) {
 		/* Allocate new pages on target NUMA nodes */
 		for (i = 0; i < count; i++) {
--- a/docs/ihk.pdf
+++ b/docs/ihk.pdf
--- a/docs/install.rst
+++ b/docs/install.rst
@ -129,11 +129,29 @@ Create the tarball and the spec file:
   make dist
   cp mckernel-<version>.tar.gz <rpmbuild>/SOURCES

+(optional) Edit the following line in ``scripts/mckernel.spec`` to change
+cmake options. For example:
+
+::
+
+   %cmake -DCMAKE_BUILD_TYPE=Release \
+	-DUNAME_R=%{kernel_version} \
+	-DKERNEL_DIR=%{kernel_dir} \
+	%{?cmake_libdir:-DCMAKE_INSTALL_LIBDIR=%{cmake_libdir}} \
+	%{?build_target:-DBUILD_TARGET=%{build_target}} \
+	%{?toolchain_file:-DCMAKE_TOOLCHAIN_FILE=%{toolchain_file}} \
+	-DENABLE_TOFU=ON -DENABLE_FUGAKU_HACKS=ON \
+	-DENABLE_KRM_WORKAROUND=OFF -DWITH_KRM=ON \
+	-DENABLE_FUGAKU_DEBUG=OFF \
+	.
+
 Create the rpm package:

 When not cross-compiling:
 """""""""""""""""""""""""

+Then build the rpm:
+
 ::

   rpmbuild -ba scripts/mckernel.spec
--- a/docs/spec/ihk.pdf
+++ b/docs/spec/ihk.pdf
--- a/docs/spec/ihk.rst
+++ b/docs/spec/ihk.rst
@ -2,17 +2,6 @@
   :suffix: .
   :depth: 3

-External Specs
+Specifications
 ==============
-
-Overview
--------
-
-Function Specs
--------------
-
-Command / Daemon Specs
----------------------
-
-Booting LWK
-===========
+The specifications pdf is :download:`here <ihk.pdf>`
--- a/docs/spec/mckernel.pdf
+++ b/docs/spec/mckernel.pdf
--- a/docs/spec/mckernel.rst
+++ b/docs/spec/mckernel.rst
@ -2,8 +2,6 @@
   :suffix: .
   :depth: 3

-Interfaces
-==========
-
-Interface details
-=================
+Specifications
+==============
+The specifications pdf is :download:`here <mckernel.pdf>`
--- a/docs/users.rst
+++ b/docs/users.rst
@ -34,6 +34,19 @@ For example, with Fujitsu Technical Computing Suite (TCS), you need to specify `

   #PJM -L jobenv=mck1

+(Optional, Fujitsu TCS only) Specify boot parameters
+----------------------------------------------------
+
+You can specify the boot parameters by defining environmental variables and pass them to Fujitsu TCS.
+The parameters include the resource reservation settings, resource reservation amount, kernel arguments and routing of message channels between McKernel CPUs and Linux CPUs.
+See `IHK Specifications - ihk_create_os_str() <spec/ihk.html>`__ for the parameter names and allowed values.
+The example of setting the memory amount is shown below.
+
+.. code-block:: none
+
+   export IHK_MEM="7G@4,7G@5,7G@6,7G@7"
+   pjsub -X run.sh
+
 Insert ``mcexec`` into the command line
 ---------------------------------------

@ -189,3 +202,21 @@ Limitations
 28. munlockall() is not supported and returns zero.

 29. scheduling behavior is not Linux compatible. For example, sometimes one of the two processes on the same CPU continues to run after yielding.
+
+30. (Fujitsu TCS-only) A job following the one in which __mcctrl_os_read_write_cpu_register() returns ``-ETIME`` fails because xos_hwb related CPU state isn't finalized. You can tell if the function returned ``-ETIME`` by checking if the following line appeared in the Linux kernel message:
+
+    ::
+
+       __mcctrl_os_read_write_cpu_register: ERROR sending IKC msg: -62
+
+    You can re-initialize xos_hwb related CPU state by the following command:
+
+    ::
+
+       sudo systemctl restart xos_hwb
+
+31. System calls can write the mcexec VMAs with PROT_WRITE flag not
+    set. This is because we never turn off PROT_WRITE of the mcexec
+    VMAs to circumvent the issue "set_host_vma(): do NOT read protect
+    Linux VMA".
+
--- a/docs/uti.rst
+++ b/docs/uti.rst
@ -4,24 +4,41 @@ Advanced: Enable Utility Thread offloading Interface (UTI)
 UTI enables a runtime such as MPI runtime to spawn utility threads such
 as MPI asynchronous progress threads to Linux cores.

-Install capstone
-~~~~~~~~~~~~~~~~~~~~
+Install ``capstone`` and ``capstone-devel``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

-When compute nodes don't have access to repositories
-""""""""""""""""""""""""""""""""""""""""""""""""""""
+When compute nodes don't have access to EPEL repository
+"""""""""""""""""""""""""""""""""""""""""""""""""""""""

-Install EPEL capstone-devel:
+Install EPEL ``capstone`` and ``capstone-devel``:

 ::

   sudo yum install https://dl.fedoraproject.org/pub/epel/epel-release-latest-8.noarch.rpm
-   sudo yum install capstone-devel
+   sudo yum install capstone capstone-devel


-When compute nodes don't have access to repositories
-""""""""""""""""""""""""""""""""""""""""""""""""""""
+When compute nodes don't have access to EPEL repository
+"""""""""""""""""""""""""""""""""""""""""""""""""""""""

-Ask the system administrator to install ``capstone-devel``. Note that it is in the EPEL repository.
+A. Ask the system administrator to install ``capstone`` and ``capstone-devel``. Note that it is in the EPEL repository.
+
+B. Download the rpm with the machine in which you are the administrator:
+
+::
+
+   sudo yum install https://dl.fedoraproject.org/pub/epel/epel-release-latest-8.noarch.rpm
+   sudo yum install yum-utils
+   yumdownloader capstone capstone-devel
+
+and then install it to your home directory of the login node:
+
+::
+
+   cd $HOME/$(uname -p)
+   rpm2cpio capstone-4.0.1-9.el8.aarch64.rpm | cpio -idv
+   rpm2cpio capstone-devel-4.0.1-9.el8.aarch64.rpm | cpio -idv
+   sed -i 's#/usr/#'"$HOME"'/'"$(uname -p)"'/usr/#' $HOME/$(uname -p)/usr/lib64/pkgconfig/capstone.pc


 Install syscall_intercept
@ -31,7 +48,24 @@ Install syscall_intercept

   git clone https://github.com/RIKEN-SysSoft/syscall_intercept.git
   mkdir build && cd build
-   cmake <syscall_intercept>/arch/aarch64 -DCMAKE_INSTALL_PREFIX=<syscall-intercept-install> -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=gcc -DTREAT_WARNINGS_AS_ERRORS=OFF
+
+When ``capstone`` and ``capstone-devel`` are installed into the system directory:
+
+::
+
+   cmake ../syscall_intercept/arch/aarch64 -DCMAKE_INSTALL_PREFIX=${HOME}/$(uname -p)/usr -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=gcc -DTREAT_WARNINGS_AS_ERRORS=OFF
+
+When ``capstone`` and ``capstone-devel`` are installed into your home directory:
+
+::
+
+   CMAKE_PREFIX_PATH=${HOME}/$(uname -p)/usr cmake ../syscall_intercept/arch/aarch64 -DCMAKE_INSTALL_PREFIX=${HOME}/$(uname -p)/usr -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=gcc -DTREAT_WARNINGS_AS_ERRORS=OFF
+
+Install:
+
+::
+
+   make && make install && make test

 Install UTI for McKernel
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -48,16 +82,17 @@ Install:
 Install McKernel
 ~~~~~~~~~~~~~~~~~~~~

-Add ``-DENABLE_UTI=ON`` option to ``cmake``:
+``cmake`` with the additional options:

 ::

-   CMAKE_PREFIX_PATH=<syscall-intercept-install> cmake -DCMAKE_INSTALL_PREFIX=${HOME}/ihk+mckernel -DENABLE_UTI=ON $HOME/src/ihk+mckernel/mckernel
+   CMAKE_PREFIX_PATH=${HOME}/$(uname -p)/usr cmake -DCMAKE_INSTALL_PREFIX=${HOME}/ihk+mckernel -DENABLE_UTI=ON $HOME/src/ihk+mckernel/mckernel
+   make -j install

 Run programs
 ~~~~~~~~~~~~~~~~

-Add ``--enable-uti`` option to ``mcexec``:
+``mcexec`` with ``--enable-uti`` option:

 ::

--- a/executer/kernel/mcctrl/arch/arm64/archdeps.c
+++ b/executer/kernel/mcctrl/arch/arm64/archdeps.c
@ -8,6 +8,10 @@
 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0) */
 #include <linux/ptrace.h>
 #include <linux/uaccess.h>
+#include <linux/mmu_notifier.h>
+#include <linux/kref.h>
+#include <linux/file.h>
+#include <linux/proc_fs.h>
 #include <asm/vdso.h>
 #include "config.h"
 #include "../../mcctrl.h"
@ -36,6 +40,29 @@ int (*mcctrl_tof_utofu_release_cq)(struct inode *inode,
 struct file_operations *mcctrl_tof_utofu_procfs_ops_bch;
 int (*mcctrl_tof_utofu_release_bch)(struct inode *inode,
 		struct file *filp);
+int (*mcctrl_tof_core_cq_cacheflush)(int tni, int cqid);
+int (*mcctrl_tof_core_disable_bch)(int tni, int bgid);
+int (*mcctrl_tof_core_unset_bg)(int tni, int bgid);
+typedef void (*tof_core_signal_handler)(int, int, uint64_t, uint64_t);
+void (*mcctrl_tof_core_register_signal_bg)(int tni, int bgid,
+			tof_core_signal_handler handler);
+struct tof_utofu_bg;
+struct tof_utofu_bg *mcctrl_tof_utofu_bg;
+
+
+/* Tofu MMU notifier */
+struct mmu_notifier_ops *mcctrl_tof_utofu_mn_ops;
+struct mmu_notifier_ops __mcctrl_tof_utofu_mn_ops;
+static void (*mcctrl_tof_utofu_mn_invalidate_range_end)(
+	struct mmu_notifier *mn,
+	struct mm_struct *mm,
+	unsigned long start,
+	unsigned long end);
+void __mcctrl_tof_utofu_mn_invalidate_range_end(
+	struct mmu_notifier *mn,
+	struct mm_struct *mm,
+	unsigned long start,
+	unsigned long end);
 #endif

 int arch_symbols_init(void)
@ -74,6 +101,49 @@ int arch_symbols_init(void)
 		(void *)kallsyms_lookup_name("tof_utofu_release_bch");
 	if (WARN_ON(!mcctrl_tof_utofu_release_bch))
 		return -EFAULT;
+
+	mcctrl_tof_core_cq_cacheflush =
+		(void *)kallsyms_lookup_name("tof_core_cq_cacheflush");
+	if (WARN_ON(!mcctrl_tof_core_cq_cacheflush))
+		return -EFAULT;
+
+	mcctrl_tof_core_disable_bch =
+		(void *)kallsyms_lookup_name("tof_core_disable_bch");
+	if (WARN_ON(!mcctrl_tof_core_disable_bch))
+		return -EFAULT;
+
+	mcctrl_tof_core_unset_bg =
+		(void *)kallsyms_lookup_name("tof_core_unset_bg");
+	if (WARN_ON(!mcctrl_tof_core_unset_bg))
+		return -EFAULT;
+
+	mcctrl_tof_core_register_signal_bg =
+		(void *)kallsyms_lookup_name("tof_core_register_signal_bg");
+	if (WARN_ON(!mcctrl_tof_core_register_signal_bg))
+		return -EFAULT;
+
+	mcctrl_tof_utofu_bg =
+		(void *)kallsyms_lookup_name("tof_utofu_bg");
+	if (WARN_ON(!mcctrl_tof_utofu_bg))
+		return -EFAULT;
+
+	mcctrl_tof_utofu_mn_ops =
+		(void *)kallsyms_lookup_name("tof_utofu_mn_ops");
+	if (WARN_ON(!mcctrl_tof_utofu_mn_ops))
+		return -EFAULT;
+	/*
+	 * Copy original content and update redirected function,
+	 * CQ will be pointed to this structure after init ioctl()
+	 */
+	memcpy(&__mcctrl_tof_utofu_mn_ops, mcctrl_tof_utofu_mn_ops,
+			sizeof(*mcctrl_tof_utofu_mn_ops));
+	__mcctrl_tof_utofu_mn_ops.invalidate_range =
+		__mcctrl_tof_utofu_mn_invalidate_range_end;
+
+	mcctrl_tof_utofu_mn_invalidate_range_end =
+		(void *)kallsyms_lookup_name("tof_utofu_mn_invalidate_range_end");
+	if (WARN_ON(!mcctrl_tof_utofu_mn_invalidate_range_end))
+		return -EFAULT;
 #endif

 	return 0;
@ -474,6 +544,7 @@ void mcctrl_tofu_hijack_release_handlers(void)
 		__mcctrl_tof_utofu_release_cq;
 	mcctrl_tof_utofu_procfs_ops_bch->release =
 		__mcctrl_tof_utofu_release_bch;
+	wmb();
 }

 void mcctrl_tofu_restore_release_handlers(void)
@ -482,8 +553,327 @@ void mcctrl_tofu_restore_release_handlers(void)
 		mcctrl_tof_utofu_release_cq;
 	mcctrl_tof_utofu_procfs_ops_bch->release =
 		mcctrl_tof_utofu_release_bch;
+	wmb();
 }

+/*
+ * Tofu cleanup functions
+ */
+#include <tofu/tof_uapi.h>
+#include <tofu/tof_icc.h>
+#include <tofu/tofu_generated-tof_core_cq.h>
+#include <tofu/tofu_generated-tof_utofu_device.h>
+#include <tofu/tofu_generated-tof_utofu_cq.h>
+#include <tofu/tofu_generated-tof_utofu_mbpt.h>
+#include <tofu/tofu_generated-tof_utofu_bg.h>
+
+#define TOF_UTOFU_VERSION TOF_UAPI_VERSION
+#define TOF_UTOFU_NUM_STAG_NTYPES 3
+#define TOF_UTOFU_NUM_STAG_BITS(size) ((size) + 13)
+#define TOF_UTOFU_NUM_STAG(size) ((uint64_t)1 << TOF_UTOFU_NUM_STAG_BITS(size))
+#define TOF_UTOFU_STAG_TRANS_BITS 3
+#define TOF_UTOFU_STAG_TRANS_SIZE ((uint64_t)1 << TOF_UTOFU_STAG_TRANS_BITS)
+#define TOF_UTOFU_STAG_TRANS_TABLE_LEN(size) (TOF_UTOFU_NUM_STAG(size) * TOF_UTOFU_STAG_TRANS_SIZE)
+#define TOF_UTOFU_STEERING_TABLE_LEN(size) (TOF_UTOFU_NUM_STAG(size) * TOF_ICC_STEERING_SIZE)
+#define TOF_UTOFU_MB_TABLE_LEN(size) (TOF_UTOFU_NUM_STAG(size) * TOF_ICC_MB_SIZE)
+#define TOF_UTOFU_STAG_MEM_LEN(size) (TOF_UTOFU_STEERING_TABLE_LEN(size) * 4)
+#define TOF_UTOFU_SPECIAL_STAG 4096
+
+#define TOF_UTOFU_ICC_COMMON_REGISTER (tof_icc_reg_pa + 0x0B000000)
+#define TOF_UTOFU_REG_START tof_icc_reg_pa
+#define TOF_UTOFU_REG_END (TOF_UTOFU_ICC_COMMON_REGISTER + 0x000FFFFF)
+
+#define TOF_UTOFU_SET_SUBNET_TNI	0	/* This number is kernel TNIs number in setting subnet */
+#define TOF_UTOFU_KCQ			11
+#define TOF_UTOFU_LINKDOWN_PORT_MASK	0x000003FF
+
+#define TOF_UTOFU_ALLOC_STAG_LPG	0x2
+#define TOF_UTOFU_BLANK_MBVA (-1)
+
+#define TOF_UTOFU_MRU_EMPTY (-1)
+
+struct tof_utofu_trans_list {
+	int16_t prev;
+	int16_t next;
+	uint8_t pgszbits;
+	struct tof_utofu_mbpt *mbpt;
+};
+
+
+/*
+ * Bit 30 marks a kref as McKernel internal.
+ * This can be used to distinguish krefs from Linux and
+ * it also ensures that a non deallocated kref will not
+ * crash the Linux allocator.
+ */
+#define MCKERNEL_KREF_MARK	(1U << 30)
+static inline unsigned int mcctrl_kref_is_mckernel(const struct kref *kref)
+{
+	return (refcount_read(&kref->refcount) & (MCKERNEL_KREF_MARK));
+}
+
+/**
+ * kref_put - decrement refcount for object.
+ * @kref: object.
+ * @release: pointer to the function that will clean up the object when the
+ *	     last reference to the object is released.
+ *	     This pointer is required, and it is not acceptable to pass kfree
+ *	     in as this function.  If the caller does pass kfree to this
+ *	     function, you will be publicly mocked mercilessly by the kref
+ *	     maintainer, and anyone else who happens to notice it.  You have
+ *	     been warned.
+ *
+ * Decrement the refcount, and if 0, call release().
+ * Return 1 if the object was removed, otherwise return 0.  Beware, if this
+ * function returns 0, you still can not count on the kref from remaining in
+ * memory.  Only use the return value if you want to see if the kref is now
+ * gone, not present.
+ */
+static inline int mcctrl_kref_put(struct kref *kref, void (*release)(struct kref *kref))
+{
+	if (atomic_dec_return(&kref->refcount.refs) == MCKERNEL_KREF_MARK) {
+		release(kref);
+		return 1;
+	}
+	return 0;
+}
+
+static int tof_utofu_cq_cacheflush(struct tof_utofu_cq *ucq){
+	return mcctrl_tof_core_cq_cacheflush(ucq->tni, ucq->cqid);
+}
+
+static void tof_utofu_trans_mru_delete(struct tof_utofu_cq *ucq, int stag){
+	struct tof_utofu_trans_list *mru = ucq->trans.mru;
+	int prev = mru[stag].prev;
+	int next = mru[stag].next;
+	if(prev == TOF_UTOFU_MRU_EMPTY || next == TOF_UTOFU_MRU_EMPTY){ /* already deleted */
+		return;
+	}
+	if(prev == stag){  /* a single entry */
+		ucq->trans.mruhead = TOF_UTOFU_MRU_EMPTY;
+	}else{
+		if(ucq->trans.mruhead == stag){
+			ucq->trans.mruhead = next;
+		}
+		mru[prev].next = next;
+		mru[next].prev = prev;
+	}
+	mru[stag].prev = TOF_UTOFU_MRU_EMPTY;
+	mru[stag].next = TOF_UTOFU_MRU_EMPTY;
+}
+
+static void tof_utofu_trans_disable(struct tof_utofu_cq *ucq, int stag){
+	struct tof_trans_table *table = ucq->trans.table;
+	atomic64_set((atomic64_t *)&table[stag], 0);
+	tof_utofu_trans_mru_delete(ucq, stag);
+}
+
+/* McKernel scatterlist is simply a contiguous buffer. */
+struct scatterlist {
+	void *pages;
+	unsigned int	offset;
+	unsigned int	length;
+	unsigned long	dma_address;
+	unsigned int	dma_length;
+};
+
+static uintptr_t tof_utofu_disable_mbpt(struct tof_utofu_mbpt *mbpt, int idx){
+	int i0, i1;
+	struct tof_icc_mbpt_entry *ent;
+	uintptr_t ipa;
+	i0 = idx / (PAGE_SIZE / TOF_ICC_MBPT_SIZE);
+	i1 = idx - i0 * (PAGE_SIZE / TOF_ICC_MBPT_SIZE);
+	//ent = sg_virt(&mbpt->sg[i0]);
+	ent = mbpt->sg->pages + (i0 * PAGE_SIZE);
+	if(!ent[i1].enable){
+		return 0;
+	}
+	ent[i1].enable = 0;
+	ipa = (uint64_t)ent[i1].ipa << 12;
+	ent[i1].ipa = 0;
+	return ipa;
+}
+
+static void tof_utofu_free_mbpt(struct tof_utofu_cq *ucq, struct tof_utofu_mbpt *mbpt){
+	int i;
+
+	for(i = 0; i < mbpt->nsgents * PAGE_SIZE / sizeof(struct tof_icc_mbpt_entry); i++){
+		uintptr_t iova;
+		iova = tof_utofu_disable_mbpt(mbpt, i);
+#if 0
+		/*
+		 * NOTE: Not performed for McKernel managed stags.
+		 */
+		if(iova){
+			tof_smmu_release_ipa_cq(ucq->tni, ucq->cqid, iova, mbpt->pgsz);
+		}
+#endif
+	}
+
+#if 0
+	/*
+	 * NOTE: Everyhing below has been allocated in McKernel, do nothing here!!
+	 * This leaks memory in McKernel, but it doesn't crash Linux.
+	 * Memory will be released once McKernel is unbooted.
+	 */
+	tof_smmu_iova_unmap_sg(ucq->tni, ucq->cqid, mbpt->sg, mbpt->nsgents);
+
+	for(i = 0; i < mbpt->nsgents; i++){
+		tof_util_free_pages((unsigned long)sg_virt(&mbpt->sg[i]), 0);
+	}
+	tof_util_free(mbpt->sg);
+	tof_util_free(mbpt);
+#endif
+}
+
+static void tof_utofu_mbpt_release(struct kref *kref)
+{
+	struct tof_utofu_mbpt *mbpt = container_of(kref, struct tof_utofu_mbpt, kref);
+	//atomic64_inc((atomic64_t *)&kref_free_count);
+	tof_utofu_free_mbpt(mbpt->ucq, mbpt);
+}
+
+static int tof_utofu_free_stag(struct tof_utofu_cq *ucq, int stag){
+	if(stag < 0 || stag >= TOF_UTOFU_NUM_STAG(ucq->num_stag) ||
+	   ucq->steering == NULL){
+		return -EINVAL;
+	}
+	if(!(ucq->steering[stag].enable)){
+		return -ENOENT;
+	}
+	if (!mcctrl_kref_is_mckernel(&ucq->trans.mru[stag].mbpt->kref)) {
+		printk("%s: stag: %d is not an McKernel kref\n", __func__, stag);
+		return -EINVAL;
+	}
+	ucq->steering[stag].enable = 0;
+	ucq->mb[stag].enable = 0;
+	tof_utofu_trans_disable(ucq, stag);
+	dma_wmb();
+	tof_utofu_cq_cacheflush(ucq);
+	mcctrl_kref_put(&ucq->trans.mru[stag].mbpt->kref, tof_utofu_mbpt_release);
+	ucq->trans.mru[stag].mbpt = NULL;
+	dprintk("%s: TNI: %d, CQ: %d: stag %d deallocated\n",
+			__func__, ucq->tni, ucq->cqid, stag);
+	return 0;
+}
+
+void mcctrl_mckernel_tof_utofu_release_cq(void *pde_data)
+{
+	struct tof_utofu_cq *ucq;
+	struct tof_utofu_device *dev;
+	unsigned long irqflags;
+	int stag;
+
+	dev = (struct tof_utofu_device *)pde_data;
+	ucq = container_of(dev, struct tof_utofu_cq, common);
+
+	if (!ucq->common.enabled) {
+		return;
+	}
+
+	dprintk("%s: UCQ (PDE: 0x%lx) TNI %d CQ %d\n",
+		__func__, (unsigned long)pde_data, ucq->tni, ucq->cqid);
+
+	/*
+	 * Only release stags here, actual cleanup is still performed
+	 * in the Tofu driver
+	 */
+	for (stag = 0; stag < TOF_UTOFU_NUM_STAG(ucq->num_stag); stag++) {
+		spin_lock_irqsave(&ucq->trans.mru_lock, irqflags);
+		tof_utofu_free_stag(ucq, stag);
+		spin_unlock_irqrestore(&ucq->trans.mru_lock, irqflags);
+	}
+}
+
+static inline void tof_core_unregister_signal_bg(int tni, int bgid)
+{
+	return mcctrl_tof_core_register_signal_bg(tni, bgid, NULL);
+}
+
+static struct tof_utofu_bg *tof_utofu_bg_get(int tni, int bgid){
+	if((unsigned int)tni >= TOF_ICC_NTNIS ||
+	   (unsigned int)bgid >= TOF_ICC_NBGS){
+		return NULL;
+	}
+	//return &tof_utofu_bg[tni][bgid];
+
+	// Convert [][] notion into pointer aritmethic
+	return mcctrl_tof_utofu_bg + (tni * TOF_ICC_NBGS) + bgid;
+}
+
+static int __tof_utofu_unset_bg(struct tof_utofu_bg *ubg){
+	if(ubg->common.enabled){
+		mcctrl_tof_core_unset_bg(ubg->tni, ubg->bgid);
+		ubg->common.enabled = false;
+		tof_core_unregister_signal_bg(ubg->tni, ubg->bgid);
+	}
+	return 0;
+}
+
+static int mcctrl_tof_utofu_disable_bch(struct tof_utofu_bg *ubg){
+	int ret;
+	int tni, bgid;
+
+	if(!ubg->bch.enabled){
+		return -EPERM;
+	}
+
+	ret = mcctrl_tof_core_disable_bch(ubg->tni, ubg->bgid);
+	if(ret < 0){
+		return ret;
+	}
+
+	for(tni = 0; tni < TOF_ICC_NTNIS; tni++){
+		uint64_t mask = ubg->bch.bgmask[tni];
+		for(bgid = 0; bgid < TOF_ICC_NBGS; bgid++){
+			if((mask >> bgid) & 1){
+				ret = __tof_utofu_unset_bg(tof_utofu_bg_get(tni, bgid));
+				if(ret < 0){
+					/* OK? */
+					//BUG();
+					return ret;
+				}
+			}
+		}
+	}
+
+	/* Not performed in McKernel handler */
+	//tof_smmu_release_ipa_bg(ubg->tni, ubg->bgid, ubg->bch.iova, TOF_ICC_BCH_DMA_ALIGN);
+	//put_page(ubg->bch.page);
+	ubg->bch.enabled = false;
+	smp_mb();
+	dprintk("%s: tni=%d bgid=%d\n", __func__, ubg->tni, ubg->bgid);
+	return 0;
+}
+
+void mcctrl_mckernel_tof_utofu_release_bch(void *pde_data)
+{
+	struct tof_utofu_bg *ubg;
+	struct tof_utofu_device *dev = (struct tof_utofu_device *)pde_data;
+
+	ubg = container_of(dev, struct tof_utofu_bg, common);
+	//tof_log_if("tni=%d bgid=%d\n", ubg->tni, ubg->bgid);
+	dprintk("%s: tni=%d bgid=%d\n", __func__, ubg->tni, ubg->bgid);
+	mcctrl_tof_utofu_disable_bch(ubg);
+}
+
+void mcctrl_tofu_cleanup_file(struct mcctrl_file_to_pidfd *f2pfd)
+{
+	/* Figure out whether CQ or BCH */
+	if (strstr(f2pfd->tofu_dev_path, "cq")) {
+		dprintk("%s: PID: %d, fd: %d (%s) -> release CQ\n",
+			__func__, f2pfd->pid, f2pfd->fd, f2pfd->tofu_dev_path);
+		mcctrl_mckernel_tof_utofu_release_cq(f2pfd->pde_data);
+	}
+
+	else if (strstr(f2pfd->tofu_dev_path, "bch")) {
+		dprintk("%s: PID: %d, fd: %d (%s) -> release BCH\n",
+			__func__, f2pfd->pid, f2pfd->fd, f2pfd->tofu_dev_path);
+		mcctrl_mckernel_tof_utofu_release_bch(f2pfd->pde_data);
+	}
+}
+
+
 int __mcctrl_tof_utofu_release_handler(struct inode *inode, struct file *filp,
 		int (*__release_func)(struct inode *inode, struct file *filp))
 {
@ -528,28 +918,22 @@ int __mcctrl_tof_utofu_release_handler(struct inode *inode, struct file *filp,
 	ret = mcctrl_ikc_send_wait(f2pfd->os, ppd->ikc_target_cpu,
 			&isp, -20, NULL, NULL, 0);
 	if (ret != 0) {
-		dprintk("%s: WARNING: failed to send IKC msg: %d\n",
-				__func__, ret);
+		pr_err("%s: WARNING: IKC req for PID: %d, fd: %d failed\n",
+				__func__, f2pfd->pid, f2pfd->fd);
 	}

+	/* Disable any remaining STAGs/BCH in mcctrl anyway */
+	mcctrl_tofu_cleanup_file(f2pfd);
+
 	mcctrl_file_to_pidfd_hash_remove(filp, f2pfd->os,
 			current->group_leader, f2pfd->fd);

 	mcctrl_put_per_proc_data(ppd);

-	/* Do not call into Linux driver if timed out in SIGKILL.. */
-	if (ret == -ETIME && __fatal_signal_pending(current)) {
-		pr_err("%s: WARNING: failed to send IKC msg in SIGKILL: %d\n",
-				__func__, ret);
-		goto out_no_release;
-	}
 out:
 	dprintk("%s: current PID: %d, comm: %s -> calling release\n",
 			__func__, task_tgid_vnr(current), current->comm);
 	return __release_func(inode, filp);
-
-out_no_release:
-	return ret;
 }

 int __mcctrl_tof_utofu_release_cq(struct inode *inode, struct file *filp)
@ -563,4 +947,70 @@ int __mcctrl_tof_utofu_release_bch(struct inode *inode, struct file *filp)
 	return __mcctrl_tof_utofu_release_handler(inode, filp,
 			mcctrl_tof_utofu_release_bch);
 }
+
+/*
+ * Tofu MMU notifier functions
+ */
+void __mcctrl_tof_utofu_mn_invalidate_range_end(
+	struct mmu_notifier *mn,
+	struct mm_struct *mm,
+	unsigned long start,
+	unsigned long end)
+{
+	char tmpname[TASK_COMM_LEN];
+
+	/* Not an offloaded syscall? */
+	if (current->mm != mm) {
+		goto out_call_real;
+	}
+
+	/* Not mcexec? Just in case.. */
+	get_task_comm(tmpname, current);
+	if (strncmp(tmpname, "mcexec", TASK_COMM_LEN)) {
+		goto out_call_real;
+	}
+
+	/* This is only called for Tofu enabled mcexec processes */
+	dprintk("%s: skipping tof_utofu_mn_invalidate_range_end() "
+			"for mcexec PID %d\n",
+			__func__, task_tgid_vnr(current));
+	return;
+
+out_call_real:
+	return mcctrl_tof_utofu_mn_invalidate_range_end(mn, mm, start, end);
+}
+
+int __mcctrl_tof_utofu_ioctl_init_cq(struct tof_utofu_device *dev,
+		unsigned long arg) {
+	struct tof_utofu_cq *ucq;
+
+	ucq = container_of(dev, struct tof_utofu_cq, common);
+	if (!ucq->common.enabled) {
+		return -EINVAL;
+	}
+
+	dprintk("%s: Tofu TNI %d CQ %d (PDE: 0x%lx) MMU notifier to be hijacked\n",
+		__func__, ucq->tni, ucq->cqid, (unsigned long)dev);
+	/* Override the MMU notifier */
+	ucq->mn.ops = &__mcctrl_tof_utofu_mn_ops;
+
+	return 0;
+}
+
+long __mcctrl_tof_utofu_unlocked_ioctl_cq(void *pde_data, unsigned int cmd,
+					unsigned long arg) {
+	struct tof_utofu_device *dev = (struct tof_utofu_device *)pde_data;
+	int ret;
+
+	switch (cmd) {
+		/* We only care about init, where we hijack the MMU notifier */
+		case TOF_IOCTL_INIT_CQ:
+			ret = __mcctrl_tof_utofu_ioctl_init_cq(dev, arg);
+			break;
+		default:
+			ret = 0;
+	}
+
+	return ret;
+}
 #endif
--- a/executer/kernel/mcctrl/arch/arm64/include/tofu/generate_headers.sh
+++ b/executer/kernel/mcctrl/arch/arm64/include/tofu/generate_headers.sh
@ -0,0 +1,41 @@
+#!/bin/bash
+
+SCRIPT="`readlink -f ${BASH_SOURCE[0]:-}`"
+SCRIPT_DIR=$(dirname ${SCRIPT})
+CURRENT_DIR=`pwd`
+
+cd ${SCRIPT_DIR}
+
+DWARF_TOOL=${SCRIPT_DIR}/../../../../../../../tools/dwarf-extract-struct/dwarf-extract-struct
+if [ ! -x ${DWARF_TOOL} ]; then
+	echo "error: couldn't find DWARF extractor executable (${DWARF_TOOL}), have you compiled it?"
+	cd -
+	exit 1
+fi
+
+echo "Looking for Tofu driver debug symbols..."
+if [ "`find /lib/modules/ -name "tof_module.tar.gz" | xargs -r ls -t | head -n 1 | wc -l`" == "0" ]; then
+	echo "error: couldn't find Tofu modules with debug symbols"
+	cd -
+	exit 1
+fi
+
+MODULE_TAR_GZ=`find /lib/modules/ -name "tof_module.tar.gz" | xargs ls -t | head -n 1`
+echo "Using Tofu driver debug symbols: ${MODULE_TAR_GZ}"
+
+KMODULE=tof_utofu.ko
+if ! tar zxvf ${MODULE_TAR_GZ} ${KMODULE} 2>&1 > /dev/null; then
+	echo "error: uncompressing kernel module with debug symbols"
+	cd -
+	exit 1
+fi
+
+${DWARF_TOOL} ${KMODULE} tof_utofu_device enabled subnet gpid > tofu_generated-tof_utofu_device.h
+${DWARF_TOOL} ${KMODULE} tof_utofu_cq common tni cqid mn trans steering mb num_stag | sed "s/struct FILL_IN_MANUALLY trans;/#include \"tof_utofu_cq_trans.h\"/g" > tofu_generated-tof_utofu_cq.h
+${DWARF_TOOL} ${KMODULE} tof_utofu_mbpt ucq iova sg nsgents mbptstart pgsz kref > tofu_generated-tof_utofu_mbpt.h
+${DWARF_TOOL} ${KMODULE} tof_utofu_bg common tni bgid bch | sed "s/struct FILL_IN_MANUALLY bch;/#include \"tof_utofu_bg_bch.h\"/g" > tofu_generated-tof_utofu_bg.h
+rm ${KMODULE}
+
+
+#cat tofu_generated*.h
+cd - > /dev/null
--- a/executer/kernel/mcctrl/arch/arm64/include/tofu/tof_icc.h
+++ b/executer/kernel/mcctrl/arch/arm64/include/tofu/tof_icc.h
@ -0,0 +1,831 @@
+#ifndef _TOF_ICC_H_
+#define _TOF_ICC_H_
+
+#include <linux/types.h>
+#ifdef __KERNEL__
+#include <linux/bitops.h>
+#else
+#include <stdint.h>
+typedef uint64_t phys_addr_t;
+#endif
+
+/* constants related to the Tofu Interconnect D */
+
+#define TOF_ICC_NTNIS 6
+#define TOF_ICC_NCQS 12
+#define TOF_ICC_NBGS 48
+#define TOF_ICC_NBCHS 16
+#define TOF_ICC_NPORTS 10
+#define TOF_ICC_NVMSIDS 16
+
+#define TOF_ICC_RH_LEN 8
+#define TOF_ICC_ECRC_LEN 4
+#define TOF_ICC_FRAME_ALIGN 32
+#define TOF_ICC_TLP_LEN(len) (((len) + 1) * TOF_ICC_FRAME_ALIGN)
+#define TOF_ICC_TLP_PAYLOAD_MAX (TOF_ICC_TLP_LEN(61) - TOF_ICC_ECRC_LEN)
+#define TOF_ICC_FRAME_LEN(len) (TOF_ICC_RH_LEN + TOF_ICC_TLP_LEN(len))
+#define TOF_ICC_FRAME_LEN_MIN TOF_ICC_FRAME_LEN(2)
+#define TOF_ICC_FRAME_LEN_MAX TOF_ICC_FRAME_LEN(61)
+#define TOF_ICC_FRAME_BUF_SIZE_BITS 11
+#define TOF_ICC_FRAME_BUF_SIZE (1 << TOF_ICC_FRAME_BUF_SIZE_BITS)
+#define TOF_ICC_FRAME_BUF_ALIGN_BITS 8
+#define TOF_ICC_FRAME_BUF_ALIGN (1 << TOF_ICC_FRAME_BUF_ALIGN_BITS)
+#define TOF_ICC_PB_SIZE_BITS 11
+#define TOF_ICC_PB_SIZE (1 << TOF_ICC_PB_SIZE_BITS)
+#define TOF_ICC_PB_ALIGN_BITS 11
+#define TOF_ICC_PB_ALIGN (1 << TOF_ICC_PB_ALIGN_BITS)
+
+#define TOF_ICC_ST_ALIGN_BITS 8
+#define TOF_ICC_ST_ALIGN (1 << TOF_ICC_ST_ALIGN_BITS)
+
+#define TOF_ICC_MBT_ALIGN_BITS 8
+#define TOF_ICC_MBT_ALIGN (1 << TOF_ICC_MBT_ALIGN_BITS)
+
+#define TOF_ICC_MBPT_ALIGN_BITS 8
+#define TOF_ICC_MBPT_ALIGN (1 << TOF_ICC_MBPT_ALIGN_BITS)
+
+#define TOF_ICC_BG_BSEQ_SIZE_BITS 24
+#define TOF_ICC_BG_BSEQ_SIZE (1 << TOF_ICC_BG_BSEQ_SIZE_BITS)
+
+#define TOF_ICC_BCH_DMA_ALIGN_BITS 8
+#define TOF_ICC_BCH_DMA_ALIGN (1 << TOF_ICC_BCH_DMA_ALIGN_BITS)
+
+/* this is a CPU-specific constant, but referred in the ICC spec. */
+#define TOF_ICC_CACHE_LINE_SIZE_BITS 8
+#define TOF_ICC_CACHE_LINE_SIZE (1 << TOF_ICC_CACHE_LINE_SIZE_BITS)
+
+#define TOF_ICC_TOQ_DESC_SIZE_BITS 5
+#define TOF_ICC_TOQ_DESC_SIZE (1 << TOF_ICC_TOQ_DESC_SIZE_BITS)
+#define TOF_ICC_TCQ_DESC_SIZE_BITS 3
+#define TOF_ICC_TCQ_DESC_SIZE (1 << TOF_ICC_TCQ_DESC_SIZE_BITS)
+#define TOF_ICC_TCQ_NLINE_BITS (TOF_ICC_CACHE_LINE_SIZE_BITS - TOF_ICC_TCQ_DESC_SIZE_BITS)
+#define TOF_ICC_MRQ_DESC_SIZE_BITS 5
+#define TOF_ICC_MRQ_DESC_SIZE (1 << TOF_ICC_MRQ_DESC_SIZE_BITS)
+#define TOF_ICC_PBQ_DESC_SIZE_BITS 3
+#define TOF_ICC_PBQ_DESC_SIZE (1 << TOF_ICC_PBQ_DESC_SIZE_BITS)
+#define TOF_ICC_PRQ_DESC_SIZE_BITS 3
+#define TOF_ICC_PRQ_DESC_SIZE (1 << TOF_ICC_PRQ_DESC_SIZE_BITS)
+#define TOF_ICC_PRQ_NLINE_BITS (TOF_ICC_CACHE_LINE_SIZE_BITS - TOF_ICC_PBQ_DESC_SIZE_BITS)
+
+#define TOF_ICC_TOQ_SIZE_NTYPES 6
+#define TOF_ICC_TOQ_SIZE_BITS(size) ((size) * 2 + 11)
+#define TOF_ICC_TOQ_SIZE(size) (1 << TOF_ICC_TOQ_SIZE_BITS(size))
+#define TOF_ICC_TOQ_LEN(size) (TOF_ICC_TOQ_SIZE(size) * TOF_ICC_TOQ_DESC_SIZE)
+#define TOF_ICC_TCQ_LEN(size) (TOF_ICC_TOQ_SIZE(size) * TOF_ICC_TCQ_DESC_SIZE)
+
+#define TOF_ICC_MRQ_SIZE_NTYPES 6
+#define TOF_ICC_MRQ_SIZE_BITS(size) ((size) * 2 + 11)
+#define TOF_ICC_MRQ_SIZE(size) (1 << TOF_ICC_MRQ_SIZE_BITS(size))
+#define TOF_ICC_MRQ_LEN(size) (TOF_ICC_MRQ_SIZE(size) * TOF_ICC_MRQ_DESC_SIZE)
+
+#define TOF_ICC_PBQ_SIZE_NTYPES 6
+#define TOF_ICC_PBQ_SIZE_BITS(size) ((size) * 2 + 11)
+#define TOF_ICC_PBQ_SIZE(size) (1 << TOF_ICC_PBQ_SIZE_BITS(size))
+#define TOF_ICC_PBQ_LEN(size) (TOF_ICC_PBQ_SIZE(size) * TOF_ICC_PBQ_DESC_SIZE)
+
+#define TOF_ICC_PRQ_SIZE_NTYPES 6
+#define TOF_ICC_PRQ_SIZE_BITS(size) ((size) * 2 + 11)
+#define TOF_ICC_PRQ_SIZE(size) (1 << TOF_ICC_PRQ_SIZE_BITS(size))
+#define TOF_ICC_PRQ_LEN(size) (TOF_ICC_PRQ_SIZE(size) * TOF_ICC_PRQ_DESC_SIZE)
+
+#define TOF_ICC_STEERING_TABLE_ALIGN_BITS 8
+#define TOF_ICC_STEERING_TABLE_ALIGN (1 << TOF_ICC_STEERING_TABLE_ALIGN_BITS)
+#define TOF_ICC_STEERING_SIZE_BITS 4
+#define TOF_ICC_STEERING_SIZE (1 << TOF_ICC_STEERING_SIZE_BITS)
+
+#define TOF_ICC_MB_TABLE_ALIGN_BITS 8
+#define TOF_ICC_MB_TABLE_ALIGN (1 << TOF_ICC_MB_TABLE_ALIGN_BITS)
+#define TOF_ICC_MB_SIZE_BITS 4
+#define TOF_ICC_MB_SIZE (1 << TOF_ICC_MB_SIZE_BITS)
+#define TOF_ICC_MB_PS_ENCODE(bits) ((bits) % 9 == 3 ? (bits) / 9 - 1 : (bits) / 13 + 3)
+
+#define TOF_ICC_MBPT_ALIGN_BITS 8
+#define TOF_ICC_MBPT_ALIGN (1 << TOF_ICC_MBPT_ALIGN_BITS)
+#define TOF_ICC_MBPT_SIZE_BITS 3
+#define TOF_ICC_MBPT_SIZE (1 << TOF_ICC_MBPT_SIZE_BITS)
+
+#define TOF_ICC_X_BITS 5
+#define TOF_ICC_Y_BITS 5
+#define TOF_ICC_Z_BITS 5
+#define TOF_ICC_A_BITS 1
+#define TOF_ICC_B_BITS 2
+#define TOF_ICC_C_BITS 1
+#define TOF_ICC_MAX_X_SIZE (1 << TOF_ICC_X_BITS)
+#define TOF_ICC_MAX_Y_SIZE (1 << TOF_ICC_Y_BITS)
+#define TOF_ICC_MAX_Z_SIZE (1 << TOF_ICC_Z_BITS)
+#define TOF_ICC_A_SIZE 2
+#define TOF_ICC_B_SIZE 3
+#define TOF_ICC_C_SIZE 2
+#define TOF_ICC_X_MASK ((1 << TOF_ICC_X_BITS) - 1)
+#define TOF_ICC_Y_MASK ((1 << TOF_ICC_Y_BITS) - 1)
+#define TOF_ICC_Z_MASK ((1 << TOF_ICC_Z_BITS) - 1)
+#define TOF_ICC_A_MASK ((1 << TOF_ICC_A_BITS) - 1)
+#define TOF_ICC_B_MASK ((1 << TOF_ICC_B_BITS) - 1)
+#define TOF_ICC_C_MASK ((1 << TOF_ICC_C_BITS) - 1)
+#define TOF_ICC_ABC_SIZE (TOF_ICC_A_SIZE * TOF_ICC_B_SIZE * TOF_ICC_C_SIZE)
+
+static inline int tof_icc_get_framelen(int len){
+	len = TOF_ICC_RH_LEN + round_up(len + TOF_ICC_ECRC_LEN, TOF_ICC_FRAME_ALIGN);
+	if(len < TOF_ICC_FRAME_LEN_MIN){
+		len = TOF_ICC_FRAME_LEN_MIN;
+	}
+	return len;
+}
+
+/** Descriptors **/
+/** commands and rcodes **/
+enum {
+	TOF_ICC_TOQ_NOP,
+	TOF_ICC_TOQ_PUT,
+	TOF_ICC_TOQ_WRITE_PIGGYBACK_BUFFER,
+	TOF_ICC_TOQ_PUT_PIGGYBACK,
+	TOF_ICC_TOQ_GET,
+	TOF_ICC_TOQ_GETL,
+	TOF_ICC_TOQ_ATOMIC_READ_MODIFY_WRITE = 0xe,
+	TOF_ICC_TOQ_TRANSMIT_RAW_PACKET1 = 0x10,
+	TOF_ICC_TOQ_TRANSMIT_RAW_PACKET2,
+	TOF_ICC_TOQ_TRANSMIT_SYSTEM_PACKET1,
+	TOF_ICC_TOQ_TRANSMIT_SYSTEM_PACKET2,
+
+	TOF_ICC_TOQ_NCOMMANDS,
+};
+
+enum {
+	TOF_ICC_MRQ_ATOMIC_READ_MODIFY_WRITE_HALFWAY_NOTICE = 0x1,
+	TOF_ICC_MRQ_ATOMIC_READ_MODIFY_WRITE_NOTICE,
+	TOF_ICC_MRQ_ATOMIC_READ_MODIFY_WRITE_REMOTE_ERROR,
+	TOF_ICC_MRQ_PUT_HALFWAY_NOTICE,
+	TOF_ICC_MRQ_PUT_LAST_HALFWAY_NOTICE,
+	TOF_ICC_MRQ_GET_HALFWAY_NOTICE,
+	TOF_ICC_MRQ_GET_LAST_HALFWAY_NOTICE,
+	TOF_ICC_MRQ_PUT_NOTICE,
+	TOF_ICC_MRQ_PUT_LAST_NOTICE,
+	TOF_ICC_MRQ_GET_NOTICE,
+	TOF_ICC_MRQ_GET_LAST_NOTICE,
+	TOF_ICC_MRQ_PUT_REMOTE_ERROR,
+	TOF_ICC_MRQ_PUT_LAST_REMOTE_ERROR,
+	TOF_ICC_MRQ_GET_REMOTE_ERROR,
+	TOF_ICC_MRQ_GET_LAST_REMOTE_ERROR,
+
+	TOF_ICC_MRQ_NCOMMANDS,
+};
+
+enum {
+	TOF_ICC_PRQ_UNKNOWN_TLP,
+	TOF_ICC_PRQ_SYSTEM_TLP,
+	TOF_ICC_PRQ_ADDRESS_RANGE_EXCEPTION = 0x6,
+	TOF_ICC_PRQ_CQ_EXCEPTION = 0x8,
+	TOF_ICC_PRQ_ILLEGAL_TLP_FLAGS,
+	TOF_ICC_PRQ_ILLEGAL_TLP_LENGTH,
+	TOF_ICC_PRQ_CQ_ERROR = 0xc,
+};
+
+/** structures **/
+struct tof_icc_steering_entry {
+	uint64_t res1:6;
+	uint64_t readonly:1;
+	uint64_t enable:1;
+	uint64_t mbva:32;
+	uint64_t res2:8;
+	uint64_t mbid:16;
+	uint64_t length;  /* for optimization */
+};
+
+struct tof_icc_mb_entry {
+	uint64_t ps:3;
+	uint64_t res1:4;
+	uint64_t enable:1;
+	uint64_t ipa:32;
+	uint64_t res2:24;
+	uint64_t npage;  /* for optimization */
+};
+
+struct tof_icc_mbpt_entry {
+	uint64_t res1:7;
+	uint64_t enable:1;
+	uint64_t res2:4;
+	uint64_t ipa:28;
+	uint64_t res3:24;
+};
+
+struct tof_icc_cq_stag_offset {
+	uint64_t offset:40;
+	uint64_t stag:18;
+	uint64_t cqid:6;
+};
+
+struct tof_icc_toq_common_header1 {
+	uint8_t interrupt:1;
+	uint8_t res1:4;
+	uint8_t source_type:2;
+	uint8_t flip:1;
+	uint8_t command;
+	union {
+		uint8_t mtu;
+		struct {
+			uint8_t res:4;
+			uint8_t op:4;
+		} armw;
+	} mtuop;
+	uint8_t sps:4;
+	uint8_t pa:1;
+	uint8_t pb:2;
+	uint8_t pc:1;
+	uint8_t rx;
+	uint8_t ry;
+	uint8_t rz;
+	uint8_t ra:1;
+	uint8_t rb:2;
+	uint8_t rc:1;
+	uint8_t res3:1;
+	uint8_t ri:3;
+};
+
+struct tof_icc_toq_common_header2 {
+	uint8_t gap;
+	uint8_t s:1;
+	uint8_t r:1;
+	uint8_t q:1;
+	uint8_t p:1;
+	uint8_t res1:1;
+	uint8_t j:1;
+	uint8_t res2:2;
+	uint16_t edata;
+	union{
+		struct {
+			uint32_t length:24;
+			uint32_t res:8;
+		} normal;
+		struct {
+			uint32_t length:6;
+			uint32_t res:26;
+		} piggyback;
+	} len;
+};
+
+struct tof_icc_toq_descriptor {
+	struct tof_icc_toq_common_header1 head1;
+	uint64_t res[3];
+};
+
+struct tof_icc_toq_nop {
+	struct tof_icc_toq_common_header1 head1;
+	uint64_t res[3];
+};
+
+struct tof_icc_toq_put {
+	struct tof_icc_toq_common_header1 head1;
+	struct tof_icc_toq_common_header2 head2;
+	struct tof_icc_cq_stag_offset remote;
+	struct tof_icc_cq_stag_offset local;
+};
+
+struct tof_icc_toq_write_piggyback_buffer {
+	struct tof_icc_toq_common_header1 head1;
+	uint64_t data[3];
+};
+
+struct tof_icc_toq_put_piggyback {
+	struct tof_icc_toq_common_header1 head1;
+	struct tof_icc_toq_common_header2 head2;
+	struct tof_icc_cq_stag_offset remote;
+	uint64_t data;
+};
+
+struct tof_icc_toq_get {
+	struct tof_icc_toq_common_header1 head1;
+	struct tof_icc_toq_common_header2 head2;
+	struct tof_icc_cq_stag_offset remote;
+	struct tof_icc_cq_stag_offset local;
+};
+
+struct tof_icc_toq_atomic_read_modify_write {
+	struct tof_icc_toq_common_header1 head1;
+	struct tof_icc_toq_common_header2 head2;
+	struct tof_icc_cq_stag_offset remote;
+	uint64_t data;
+};
+
+struct tof_icc_toq_transmit_raw_packet1 {
+	struct tof_icc_toq_common_header1 head1;
+	uint8_t gap;
+	uint8_t res4[3];
+	uint32_t length:12;
+	uint32_t res5:20;
+	uint64_t res6;
+	uint64_t pa:48;  /* for optimization */
+	uint64_t res7:16;
+};
+
+struct tof_icc_toq_transmit_raw_packet2 {
+	uint8_t interrupt:1;
+	uint8_t res1:4;
+	uint8_t source_type:2;
+	uint8_t flip:1;
+	uint8_t command;
+	uint8_t res2:7;
+	uint8_t e:1;
+	uint8_t res3[4];
+	uint8_t port:5;
+	uint8_t res4:1;
+	uint8_t vc:2;
+	uint8_t gap;
+	uint8_t res5[3];
+	uint32_t length:12;
+	uint32_t res6:20;
+	uint64_t res7;
+	uint64_t pa:48;  /* for optimization */
+	uint64_t res8:16;
+};
+
+struct tof_icc_toq_transmit_system_packet {
+	struct tof_icc_toq_common_header1 head1;  /* rx, ry, rz should be rdx, rdy, rdz */
+	uint8_t gap;
+	uint8_t res4[3];
+	uint32_t length:12;
+	uint32_t res5:20;
+	uint64_t res6;
+	uint64_t pa:48;  /* for optimization */
+	uint64_t res7:16;
+};
+
+struct tof_icc_tcq_descriptor {
+	uint8_t res1:5;
+	uint8_t counter_unmatch:1;
+	uint8_t res2:1;
+	uint8_t flip:1;
+	uint8_t rcode;
+	uint8_t res3[2];
+	union{
+		struct {
+			uint32_t length:24;
+			uint32_t res:8;
+		} normal;
+		struct {
+			uint32_t length:6;
+			uint32_t res:26;
+		} piggyback;
+	} len;
+};
+
+struct tof_icc_mrq_common_header1 {
+	uint8_t res1:7;
+	uint8_t flip:1;
+	uint8_t id;
+	uint8_t rcode;
+	uint8_t res2:4;
+	uint8_t pa:1;
+	uint8_t pb:2;
+	uint8_t pc:1;
+	uint8_t x;
+	uint8_t y;
+	uint8_t z;
+	uint8_t a:1;
+	uint8_t b:2;
+	uint8_t c:1;
+	uint8_t res3:1;
+	uint8_t i:3;
+};
+
+struct tof_icc_mrq_common_header2 {
+	uint8_t res1;
+	uint8_t res2:4;
+	uint8_t initial:1;
+	uint8_t res3:3;
+	uint16_t edata;
+	union {
+		struct {
+			uint32_t length:11;
+			uint32_t res:21;
+		} normal;
+		struct {
+			uint32_t op:4;
+			uint32_t res:28;
+		} armw;
+	} lenop;
+};
+
+struct tof_icc_mrq_atomic_read_modify_write_halfway_notice {
+	struct tof_icc_mrq_common_header1 head1;
+	struct tof_icc_mrq_common_header2 head2;
+	struct tof_icc_cq_stag_offset local;
+	struct tof_icc_cq_stag_offset remote;
+};
+
+struct tof_icc_mrq_descriptor {
+	struct tof_icc_mrq_common_header1 head1;
+	struct tof_icc_mrq_common_header2 head2;
+	struct tof_icc_cq_stag_offset cso1;
+	struct tof_icc_cq_stag_offset cso2;
+};
+
+struct tof_icc_pbq_descriptor {
+	uint64_t res1:7;
+	uint64_t f:1;
+	uint64_t res2:3;
+	uint64_t pa:29;
+	uint64_t res3:24;
+};
+
+struct tof_icc_prq_descriptor {
+	uint64_t rcode:7;
+	uint64_t f:1;
+	uint64_t res1:3;
+	uint64_t pa:29;
+	uint64_t res2:8;
+	uint64_t w:1;
+	uint64_t res3:5;
+	uint64_t l:1;
+	uint64_t e:1;
+	uint64_t res4:8;
+};
+
+
+/** Registers **/
+/* useful packed structures */
+struct tof_icc_reg_subnet {
+	uint64_t lz:6;
+	uint64_t sz:6;
+	uint64_t nz:6;
+	uint64_t ly:6;
+	uint64_t sy:6;
+	uint64_t ny:6;
+	uint64_t lx:6;
+	uint64_t sx:6;
+	uint64_t nx:6;
+	uint64_t res:10;
+};
+
+struct tof_icc_reg_bg_address {
+	uint32_t bgid:6;
+	uint32_t tni:3;
+	uint32_t c:1;
+	uint32_t b:2;
+	uint32_t a:1;
+	uint32_t z:5;
+	uint32_t y:5;
+	uint32_t x:5;
+	uint32_t pc:1;
+	uint32_t pb:2;
+	uint32_t pa:1;
+};
+
+/* relative offset of interrupt controller registers */
+#define TOF_ICC_IRQREG_IRR 0x0
+#define TOF_ICC_IRQREG_IMR 0x8
+#define TOF_ICC_IRQREG_IRC 0x10
+#define TOF_ICC_IRQREG_IMC 0x18
+#define TOF_ICC_IRQREG_ICL 0x20
+
+/* TOFU REGISTERS */
+#define  tof_icc_reg_pa 0x40000000
+
+/* CQ */
+#define TOF_ICC_REG_CQ_PA(tni, cqid) (tof_icc_reg_pa + 0 + (tni) * 0x1000000 + (cqid) * 0x10000)
+#define TOF_ICC_REG_CQ_TOQ_DIRECT_DESCRIPTOR 0x0
+#define TOF_ICC_REG_CQ_TOQ_FETCH_START 0x40
+#define TOF_ICC_REG_CQ_MRQ_FULL_POINTER 0x48
+#define TOF_ICC_REG_CQ_TOQ_PIGGYBACK_BUFFER0 0x50
+#define TOF_ICC_REG_CQ_TOQ_PIGGYBACK_BUFFER1 0x58
+#define TOF_ICC_REG_CQ_TOQ_PIGGYBACK_BUFFER2 0x60
+#define TOF_ICC_REG_CQ_TCQ_NUM_NOTICE 0x68
+#define TOF_ICC_REG_CQ_MRQ_NUM_NOTICE 0x70
+#define TOF_ICC_REG_CQ_TX_PAYLOAD_BYTE 0x78
+#define TOF_ICC_REG_CQ_RX_PAYLOAD_BYTE 0x80
+#define TOF_ICC_REG_CQ_DUMP_START 0x0
+#define TOF_ICC_REG_CQ_DUMP_END 0x88
+
+/* BCH */
+#define TOF_ICC_REG_BCH_PA(tni, bgid) (tof_icc_reg_pa + 0x0000e00000 + (tni) * 0x1000000 + (bgid) * 0x10000)
+#define TOF_ICC_REG_BCH_IDATA 0x800
+#define TOF_ICC_REG_BCH_READY 0x840
+#define TOF_ICC_REG_BCH_READY_STATE BIT(63)
+#define TOF_ICC_REG_BCH_IGNORED_SIGNAL_COUNT 0x848
+#define TOF_ICC_REG_BCH_DUMP_START 0x800
+#define TOF_ICC_REG_BCH_DUMP_END 0x850
+
+/* CQS */
+#define TOF_ICC_REG_CQS_PA(tni, cqid) (tof_icc_reg_pa + 0x0000400000 + (tni) * 0x1000000 + (cqid) * 0x10000)
+#define TOF_ICC_REG_CQS_STATUS 0x0
+#define TOF_ICC_REG_CQS_STATUS_DESCRIPTOR_PROCESS_STOP BIT(63)
+#define TOF_ICC_REG_CQS_STATUS_DESCRIPTOR_FETCH_STOP BIT(62)
+#define TOF_ICC_REG_CQS_STATUS_BLANK_ENTRY_FLIP_BIT BIT(61)
+#define TOF_ICC_REG_CQS_STATUS_CACHE_FLUSH_BUSY BIT(60)
+#define TOF_ICC_REG_CQS_STATUS_CQ_ENABLE BIT(59)
+#define TOF_ICC_REG_CQS_STATUS_SESSION_DEAD BIT(58)
+#define TOF_ICC_REG_CQS_STATUS_SESSION_OFFSET_OVERFLOW BIT(57)
+#define TOF_ICC_REG_CQS_STATUS_SESSION_OFFSET GENMASK(56, 32)
+#define TOF_ICC_REG_CQS_STATUS_NEXT_DESCRIPTOR_OFFSET GENMASK(29, 5)
+#define TOF_ICC_REG_CQS_ENABLE 0x8
+#define TOF_ICC_REG_CQS_CACHE_FLUSH 0x10
+#define TOF_ICC_REG_CQS_FETCH_STOP 0x18
+#define TOF_ICC_REG_CQS_MODE 0x20
+#define TOF_ICC_REG_CQS_MODE_SYSTEM BIT(63)
+#define TOF_ICC_REG_CQS_MODE_TRP2_ENABLE BIT(62)
+#define TOF_ICC_REG_CQS_MODE_TRP1_ENABLE BIT(61)
+#define TOF_ICC_REG_CQS_MODE_SESSION BIT(60)
+#define TOF_ICC_REG_CQS_MODE_SUBNET_NX GENMASK(53, 48)
+#define TOF_ICC_REG_CQS_MODE_SUBNET_SX GENMASK(47, 42)
+#define TOF_ICC_REG_CQS_MODE_SUBNET_LX GENMASK(41, 36)
+#define TOF_ICC_REG_CQS_MODE_SUBNET_NY GENMASK(35, 30)
+#define TOF_ICC_REG_CQS_MODE_SUBNET_SY GENMASK(29, 24)
+#define TOF_ICC_REG_CQS_MODE_SUBNET_LY GENMASK(23, 18)
+#define TOF_ICC_REG_CQS_MODE_SUBNET_NZ GENMASK(17, 12)
+#define TOF_ICC_REG_CQS_MODE_SUBNET_SZ GENMASK(11, 6)
+#define TOF_ICC_REG_CQS_MODE_SUBNET_LZ GENMASK(5, 0)
+#define TOF_ICC_REG_CQS_GPID 0x28
+#define TOF_ICC_REG_CQS_TOQ_IPA 0x30
+#define TOF_ICC_REG_CQS_TOQ_SIZE 0x38
+#define TOF_ICC_REG_CQS_TCQ_IPA 0x40
+#define TOF_ICC_REG_CQS_TCQ_IPA_CACHE_INJECTION BIT(63)
+#define TOF_ICC_REG_CQS_MRQ_IPA 0x48
+#define TOF_ICC_REG_CQS_MRQ_IPA_CACHE_INJECTION BIT(63)
+#define TOF_ICC_REG_CQS_MRQ_SIZE 0x50
+#define TOF_ICC_REG_CQS_MRQ_MASK 0x58
+#define TOF_ICC_REG_CQS_TCQ_DESCRIPTOR_COALESCING_TIMER 0x60
+#define TOF_ICC_REG_CQS_MRQ_DESCRIPTOR_COALESCING_TIMER 0x68
+#define TOF_ICC_REG_CQS_MRQ_INTERRUPT_COALESCING_TIMER 0x70
+#define TOF_ICC_REG_CQS_MRQ_INTERRUPT_COALESCING_COUNT 0x78
+#define TOF_ICC_REG_CQS_TOQ_DIRECT_SOURCE_COUNT 0x80
+#define TOF_ICC_REG_CQS_TOQ_DIRECT_DESCRIPTOR_COUNT 0x88
+#define TOF_ICC_REG_CQS_MEMORY_BLOCK_TABLE_ENABLE 0x90
+#define TOF_ICC_REG_CQS_MEMORY_BLOCK_TABLE_IPA 0x98
+#define TOF_ICC_REG_CQS_MEMORY_BLOCK_TABLE_SIZE 0xa0
+#define TOF_ICC_REG_CQS_STEERING_TABLE_ENABLE 0xa8
+#define TOF_ICC_REG_CQS_STEERING_TABLE_IPA 0xb0
+#define TOF_ICC_REG_CQS_STEERING_TABLE_SIZE 0xb8
+#define TOF_ICC_REG_CQS_MRQ_INTERRUPT_MASK 0xc0
+#define TOF_ICC_REG_CQS_IRR 0xc8
+#define TOF_ICC_REG_CQS_IMR 0xd0
+#define TOF_ICC_REG_CQS_IRC 0xd8
+#define TOF_ICC_REG_CQS_IMC 0xe0
+#define TOF_ICC_REG_CQS_ICL 0xe8
+#define TOF_ICC_REG_CQS_DUMP_START 0x0
+#define TOF_ICC_REG_CQS_DUMP_END 0xf0
+
+/* BGS */
+#define TOF_ICC_REG_BGS_PA(tni, bgid) (tof_icc_reg_pa + 0x0000800000 + (tni) * 0x1000000 + (bgid) * 0x10000)
+#define TOF_ICC_REG_BGS_ENABLE 0x0
+#define TOF_ICC_REG_BGS_IRR 0x8
+#define TOF_ICC_REG_BGS_IMR 0x10
+#define TOF_ICC_REG_BGS_IRC 0x18
+#define TOF_ICC_REG_BGS_IMC 0x20
+#define TOF_ICC_REG_BGS_ICL 0x28
+#define TOF_ICC_REG_BGS_STATE 0x30
+#define TOF_ICC_REG_BGS_STATE_ENABLE BIT(0)
+#define TOF_ICC_REG_BGS_EXCEPTION_INFO_GPID_UNMATCH 0x38
+#define TOF_ICC_REG_BGS_EXCEPTION_INFO_GPID_UNMATCH_BG_ADDRESS GENMASK(27, 0)
+#define TOF_ICC_REG_BGS_EXCEPTION_INFO_ADDRESS_UNMATCH 0x40
+#define TOF_ICC_REG_BGS_EXCEPTION_INFO_ADDRESS_UNMATCH_BG_ADDRESS GENMASK(27, 0)
+#define TOF_ICC_REG_BGS_SIGNAL_A 0x48
+#define TOF_ICC_REG_BGS_SIGNAL_A_SIG_RECV BIT(63)
+#define TOF_ICC_REG_BGS_SIGNAL_A_TLP_RECV BIT(62)
+#define TOF_ICC_REG_BGS_SIGNAL_A_SIG_SEND BIT(61)
+#define TOF_ICC_REG_BGS_SIGNAL_A_OP_TYPE GENMASK(3, 0)
+#define TOF_ICC_REG_BGS_SIGNAL_B 0x50
+#define TOF_ICC_REG_BGS_SIGNAL_B_SIG_RECV BIT(63)
+#define TOF_ICC_REG_BGS_SIGNAL_B_TLP_RECV BIT(62)
+#define TOF_ICC_REG_BGS_SIGNAL_B_SIG_SEND BIT(61)
+#define TOF_ICC_REG_BGS_SIGNAL_B_OP_TYPE GENMASK(3, 0)
+#define TOF_ICC_REG_BGS_SIGNAL_MASK 0x58
+#define TOF_ICC_REG_BGS_SIGNAL_MASK_SIG_RECV BIT(63)
+#define TOF_ICC_REG_BGS_SIGNAL_MASK_TLP_RECV BIT(62)
+#define TOF_ICC_REG_BGS_SIGNAL_MASK_SIG_SEND BIT(61)
+#define TOF_ICC_REG_BGS_SIGNAL_MASK_TLP_SEND BIT(60)
+#define TOF_ICC_REG_BGS_LOCAL_LINK 0x60
+#define TOF_ICC_REG_BGS_LOCAL_LINK_BGID_RECV GENMASK(37, 32)
+#define TOF_ICC_REG_BGS_LOCAL_LINK_BGID_SEND GENMASK(5, 0)
+#define TOF_ICC_REG_BGS_REMOTE_LINK 0x68
+#define TOF_ICC_REG_BGS_REMOTE_LINK_BG_ADDRESS_RECV GENMASK(59, 32)
+#define TOF_ICC_REG_BGS_REMOTE_LINK_BG_ADDRESS_SEND GENMASK(31, 0)
+#define TOF_ICC_REG_BGS_SUBNET_SIZE 0x70
+#define TOF_ICC_REG_BGS_GPID_BSEQ 0x78
+#define TOF_ICC_REG_BGS_DATA_A0 0x108
+#define TOF_ICC_REG_BGS_DATA_AE 0x178
+#define TOF_ICC_REG_BGS_DATA_B0 0x188
+#define TOF_ICC_REG_BGS_DATA_BE 0x1f8
+#define TOF_ICC_REG_BGS_BCH_MASK 0x800
+#define TOF_ICC_REG_BGS_BCH_MASK_MASK BIT(63)
+#define TOF_ICC_REG_BGS_BCH_MASK_STATUS 0x808
+#define TOF_ICC_REG_BGS_BCH_MASK_STATUS_RUN BIT(63)
+#define TOF_ICC_REG_BGS_BCH_NOTICE_IPA 0x810
+#define TOF_ICC_REG_BGS_DUMP_START 0x0
+#define TOF_ICC_REG_BGS_DUMP_END 0x818
+
+/* TNI */
+#define TOF_ICC_REG_TNI_PA(tni) (tof_icc_reg_pa + 0x0000c00000 + (tni) * 0x1000000)
+#define TOF_ICC_REG_TNI_IRR 0x8
+#define TOF_ICC_REG_TNI_IMR 0x10
+#define TOF_ICC_REG_TNI_IRC 0x18
+#define TOF_ICC_REG_TNI_IMC 0x20
+#define TOF_ICC_REG_TNI_ICL 0x28
+#define TOF_ICC_REG_TNI_STATE 0x30
+#define TOF_ICC_REG_TNI_STATE_MASK GENMASK(1, 0)
+#define TOF_ICC_REG_TNI_STATE_DISABLE 0
+#define TOF_ICC_REG_TNI_STATE_NORMAL 2
+#define TOF_ICC_REG_TNI_STATE_ERROR 3
+#define TOF_ICC_REG_TNI_ENABLE 0x38
+#define TOF_ICC_REG_TNI_CQ_PRESENT 0x40
+#define TOF_ICC_REG_TNI_EXCEPTION_INFO_INACTIVE_BG 0x48
+#define TOF_ICC_REG_TNI_EXCEPTION_INFO_INACTIVE_BG_DEST_BG GENMASK(37, 32)
+#define TOF_ICC_REG_TNI_EXCEPTION_INFO_INACTIVE_BG_SOURCE_BG_ADDRESS GENMASK(27, 0)
+#define TOF_ICC_REG_TNI_PRQ_FULL_POINTER 0x100
+#define TOF_ICC_REG_TNI_PBQ_PA 0x108
+#define TOF_ICC_REG_TNI_PBQ_SIZE 0x110
+#define TOF_ICC_REG_TNI_PRQ_PA 0x118
+#define TOF_ICC_REG_TNI_PRQ_PA_CACHE_INJECTION BIT(63)
+#define TOF_ICC_REG_TNI_PRQ_SIZE 0x120
+#define TOF_ICC_REG_TNI_PRQ_MASK 0x128
+#define TOF_ICC_REG_TNI_PRQ_ENTRY_COALESCING_TIMER 0x130
+#define TOF_ICC_REG_TNI_PRQ_INTERRUPT_COALESCING_TIMER 0x138
+#define TOF_ICC_REG_TNI_PRQ_INTERRUPT_COALESCING_COUNT 0x140
+#define TOF_ICC_REG_TNI_SEND_COUNT 0x148
+#define TOF_ICC_REG_TNI_NO_SEND_COUNT 0x150
+#define TOF_ICC_REG_TNI_BLOCK_SEND_COUNT 0x158
+#define TOF_ICC_REG_TNI_RECEIVE_COUNT 0x160
+#define TOF_ICC_REG_TNI_NO_RECEIVE_COUNT 0x168
+#define TOF_ICC_REG_TNI_NUM_SEND_TLP 0x170
+#define TOF_ICC_REG_TNI_BYTE_SEND_TLP 0x178
+#define TOF_ICC_REG_TNI_NUM_SEND_SYSTEM_TLP 0x180
+#define TOF_ICC_REG_TNI_NUM_RECEIVE_TLP 0x188
+#define TOF_ICC_REG_TNI_BYTE_RECEIVE_TLP 0x190
+#define TOF_ICC_REG_TNI_NUM_RECEIVE_NULLIFIED_TLP 0x198
+#define TOF_ICC_REG_TNI_RX_NUM_UNKNOWN_TLP 0x1a0
+#define TOF_ICC_REG_TNI_RX_NUM_SYSTEM_TLP 0x1a8
+#define TOF_ICC_REG_TNI_RX_NUM_EXCEPTION_TLP 0x1b0
+#define TOF_ICC_REG_TNI_RX_NUM_DISCARD_UNKNOWN_TLP 0x1b8
+#define TOF_ICC_REG_TNI_RX_NUM_DISCARD_SYSTEM_TLP 0x1c0
+#define TOF_ICC_REG_TNI_RX_NUM_DISCARD_EXCEPTION_TLP 0x1c8
+#define TOF_ICC_REG_TNI_DUMP_START 0x8
+#define TOF_ICC_REG_TNI_DUMP_END 0x1d0
+
+/* Port */
+#define TOF_ICC_REG_PORT_PA(port) (tof_icc_reg_pa + 0x0006000000 + (port) * 0x1000)
+#define TOF_ICC_REG_PORT_TX_VC0_ZERO_CREDIT_COUNT 0x0
+#define TOF_ICC_REG_PORT_TX_VC1_ZERO_CREDIT_COUNT 0x8
+#define TOF_ICC_REG_PORT_TX_VC2_ZERO_CREDIT_COUNT 0x10
+#define TOF_ICC_REG_PORT_TX_VC3_ZERO_CREDIT_COUNT 0x18
+#define TOF_ICC_REG_PORT_FREE_RUN_COUNT 0x80
+#define TOF_ICC_REG_PORT_NUM_SEND_DLLP 0xc0
+#define TOF_ICC_REG_PORT_NUM_SEND_TLP 0xc8
+#define TOF_ICC_REG_PORT_BYTE_SEND_TLP 0xd0
+#define TOF_ICC_REG_PORT_NUM_SEND_SYSTEM_TLP 0xd8
+#define TOF_ICC_REG_PORT_NUM_SEND_NULLIFIED_TLP 0xe0
+#define TOF_ICC_REG_PORT_NUM_TX_DISCARD_SYSTEM_TLP 0xe8
+#define TOF_ICC_REG_PORT_NUM_TX_DISCARD_NORMAL_TLP 0xf0
+#define TOF_ICC_REG_PORT_NUM_TX_FILTERED_NORMAL_TLP 0xf8
+#define TOF_ICC_REG_PORT_NUM_VIRTUAL_CUT_THROUGH_TLP 0x100
+#define TOF_ICC_REG_PORT_NUM_GENERATE_NULLIFIED_TLP 0x108
+#define TOF_ICC_REG_PORT_NUM_RECEIVE_DLLP 0x110
+#define TOF_ICC_REG_PORT_NUM_RECEIVE_TLP 0x118
+#define TOF_ICC_REG_PORT_BYTE_RECEIVE_TLP 0x120
+#define TOF_ICC_REG_PORT_NUM_RECEIVE_SYSTEM_TLP 0x128
+#define TOF_ICC_REG_PORT_NUM_RECEIVE_NULLIFIED_TLP 0x130
+#define TOF_ICC_REG_PORT_NUM_RX_DISCARD_SYSTEM_TLP 0x138
+#define TOF_ICC_REG_PORT_NUM_RX_DISCARD_NORMAL_TLP 0x140
+#define TOF_ICC_REG_PORT_NUM_RX_FILTERED_NORMAL_TLP 0x158
+#define TOF_ICC_REG_PORT_NUM_RX_DISCARD_NULLIFIED_TLP 0x160
+#define TOF_ICC_REG_PORT_FRAME_LCRC_ERROR_COUNT 0x170
+#define TOF_ICC_REG_PORT_TX_RETRY_BUFFER_CE_COUNT 0x180
+#define TOF_ICC_REG_PORT_RX_VC_BUFFER_CE_COUNT 0x188
+#define TOF_ICC_REG_PORT_XB_CE_COUNT 0x190
+#define TOF_ICC_REG_PORT_ACK_NACK_TIME_OUT_COUNT 0x198
+#define TOF_ICC_REG_PORT_SLICE0_FCS_ERROR_COUNT 0x1a0
+#define TOF_ICC_REG_PORT_SLICE1_FCS_ERROR_COUNT 0x1a8
+#define TOF_ICC_REG_PORT_DUMP_START 0x0
+#define TOF_ICC_REG_PORT_DUMP_END 0x1b0
+
+/* XB */
+#define TOF_ICC_REG_XB_PA (tof_icc_reg_pa + 0x000600f000)
+#define TOF_ICC_REG_XB_STQ_ENABLE 0x0
+#define TOF_ICC_REG_XB_STQ_UPDATE_INTERVAL 0x8
+#define TOF_ICC_REG_XB_STQ_PA 0x10
+#define TOF_ICC_REG_XB_STQ_SIZE 0x18
+#define TOF_ICC_REG_XB_STQ_NEXT_OFFSET 0x20
+#define TOF_ICC_REG_XB_DUMP_START 0x0
+#define TOF_ICC_REG_XB_DUMP_END 0x28
+
+#define TOF_ICC_XB_TC_DATA_CYCLE_COUNT(tni) ((tni) * 0x10 + 0x0)
+#define TOF_ICC_XB_TC_WAIT_CYCLE_COUNT(tni) ((tni) * 0x10 + 0x8)
+#define TOF_ICC_XB_TD_DATA_CYCLE_COUNT(tnr) ((tnr) * 0x10 + 0x60)
+#define TOF_ICC_XB_TD_WAIT_CYCLE_COUNT(tnr) ((tnr) * 0x10 + 0x68)
+
+/* Tofu */
+#define TOF_ICC_REG_TOFU_PA (tof_icc_reg_pa + 0x0007000000)
+#define TOF_ICC_REG_TOFU_NODE_ADDRESS 0x0
+#define TOF_ICC_REG_TOFU_NODE_ADDRESS_X GENMASK(22, 18)
+#define TOF_ICC_REG_TOFU_NODE_ADDRESS_Y GENMASK(17, 13)
+#define TOF_ICC_REG_TOFU_NODE_ADDRESS_Z GENMASK(12, 8)
+#define TOF_ICC_REG_TOFU_NODE_ADDRESS_A BIT(7)
+#define TOF_ICC_REG_TOFU_NODE_ADDRESS_B GENMASK(6, 5)
+#define TOF_ICC_REG_TOFU_NODE_ADDRESS_C BIT(4)
+#define TOF_ICC_REG_TOFU_PORT_SETTING 0x8
+#define TOF_ICC_REG_TOFU_TD_TLP_FILTER(tnr) ((tnr) * 0x10 + 0x10)
+#define TOF_ICC_REG_TOFU_TD_SETTINGS(tnr) ((tnr) * 0x10 + 0x18)
+#define TOF_ICC_REG_TOFU_TNR_MSI_BASE 0xc0
+#define TOF_ICC_REG_TOFU_TNR_IRR 0xc8
+#define TOF_ICC_REG_TOFU_TNR_IMR 0xd0
+#define TOF_ICC_REG_TOFU_TNR_IRC 0xd8
+#define TOF_ICC_REG_TOFU_TNR_IMC 0xe0
+#define TOF_ICC_REG_TOFU_TNR_ICL 0xe8
+#define TOF_ICC_REG_TOFU_TNI_VMS(tni, vmsid) ((tni) * 0x100 + (vmsid) * 0x8 + 0x100)
+#define TOF_ICC_REG_TOFU_TNI_VMS_CQ00(tni) ((tni) * 0x100 + 0x180)
+#define TOF_ICC_REG_TOFU_TNI_VMS_BG00(tni) ((tni) * 0x100 + 0x1a0)
+#define TOF_ICC_REG_TOFU_TNI_VMS_BG16(tni) ((tni) * 0x100 + 0x1a8)
+#define TOF_ICC_REG_TOFU_TNI_VMS_BG32(tni) ((tni) * 0x100 + 0x1b0)
+#define TOF_ICC_REG_TOFU_TNI_MSI_BASE(tni) ((tni) * 0x100 + 0x1c0)
+#define TOF_ICC_REG_TOFU_DUMP_START 0x0
+#define TOF_ICC_REG_TOFU_DUMP_END 0x6c8
+
+/** Interrupts **/
+#define TOF_ICC_IRQ_CQS_TOQ_READ_EXCEPTION BIT(0)
+#define TOF_ICC_IRQ_CQS_TOQ_DIRECT_DESCRIPTOR_EXCEPTION BIT(1)
+#define TOF_ICC_IRQ_CQS_TOQ_MARKED_UE BIT(2)
+#define TOF_ICC_IRQ_CQS_TCQ_WRITE_EXCEPTION BIT(3)
+#define TOF_ICC_IRQ_CQS_TOQ_SOURCE_TYPE_EXCEPTION BIT(4)
+#define TOF_ICC_IRQ_CQS_TCQ_WRITE_ACKNOWLEDGE BIT(5)
+#define TOF_ICC_IRQ_CQS_MRQ_WRITE_ACKNOWLEDGE BIT(7)
+#define TOF_ICC_IRQ_CQS_MRQ_WRITE_EXCEPTION BIT(8)
+#define TOF_ICC_IRQ_CQS_MRQ_OVERFLOW BIT(9)
+#define TOF_ICC_IRQ_CQS_STEERING_READ_EXCEPTION BIT(36)
+#define TOF_ICC_IRQ_CQS_MB_READ_EXCEPTION BIT(38)
+#define TOF_ICC_IRQ_CQS_PAYLOAD_READ_EXCEPTION BIT(39)
+#define TOF_ICC_IRQ_CQS_PAYLOAD_WRITE_EXCEPTION BIT(40)
+/* Just for convinience of irr value, no exists CQS CACHEFLUSH_TIMEOUT interrupt  */
+#define TOF_ICC_DUMMY_IRQ_CQS_CACHEFLUSH_TIMEOUT BIT(63)
+
+#define TOF_ICC_IRQ_BGS_NODE_ADDRESS_UNMATCH BIT(0)
+#define TOF_ICC_IRQ_BGS_BG_RECV_ADDRESS_EXCEPTION BIT(1)
+#define TOF_ICC_IRQ_BGS_BG_SEND_ADDRESS_EXCEPTION BIT(2)
+#define TOF_ICC_IRQ_BGS_GPID_UNMATCH BIT(3)
+#define TOF_ICC_IRQ_BGS_BSEQ_UNMATCH BIT(4)
+#define TOF_ICC_IRQ_BGS_SIGNAL_STATE_ERROR BIT(5)
+#define TOF_ICC_IRQ_BGS_SYNCHRONIZATION_ACKNOWLEDGE BIT(24)
+#define TOF_ICC_IRQ_BGS_ERROR_SYNCHRONIZATION_ACKNOWLEDGE BIT(25)
+#define TOF_ICC_IRQ_BGS_DMA_COMPLETION_EXCEPTION BIT(26)
+
+#define TOF_ICC_IRQ_TNI_PBQ_READ_EXCEPTION BIT(0)
+#define TOF_ICC_IRQ_TNI_PBQ_MARKED_UE BIT(1)
+#define TOF_ICC_IRQ_TNI_PBQ_UNDERFLOW BIT(2)
+#define TOF_ICC_IRQ_TNI_PRQ_PACKET_DISCARD BIT(3)
+#define TOF_ICC_IRQ_TNI_PRQ_WRITE_ACKNOWLEDGE BIT(4)
+#define TOF_ICC_IRQ_TNI_PRQ_WRITE_EXCEPTION BIT(5)
+#define TOF_ICC_IRQ_TNI_PRQ_OVERFLOW BIT(6)
+#define TOF_ICC_IRQ_TNI_INACTIVE_BG BIT(16)
+#define TOF_ICC_IRQ_TNI_STAGE2_TRANSLATION_FAULT BIT(32)
+
+#define TOF_ICC_IRQ_TNR_TNR0_RX_FILTER_OUT BIT(0)
+#define TOF_ICC_IRQ_TNR_TNR0_TX_FILTER_OUT BIT(1)
+#define TOF_ICC_IRQ_TNR_TNR0_PORT_ERROR BIT(2)
+#define TOF_ICC_IRQ_TNR_TNR0_DATELINE_ERROR BIT(3)
+#define TOF_ICC_IRQ_TNR_TNR0_ROUTING_ERROR BIT(4)
+#define TOF_ICC_IRQ_TNR_TNR1_RX_FILTER_OUT BIT(6)
+#define TOF_ICC_IRQ_TNR_TNR1_TX_FILTER_OUT BIT(7)
+#define TOF_ICC_IRQ_TNR_TNR1_PORT_ERROR BIT(8)
+#define TOF_ICC_IRQ_TNR_TNR1_DATELINE_ERROR BIT(9)
+#define TOF_ICC_IRQ_TNR_TNR1_ROUTING_ERROR BIT(10)
+#define TOF_ICC_IRQ_TNR_TNR2_RX_FILTER_OUT BIT(12)
+#define TOF_ICC_IRQ_TNR_TNR2_TX_FILTER_OUT BIT(13)
+#define TOF_ICC_IRQ_TNR_TNR2_PORT_ERROR BIT(14)
+#define TOF_ICC_IRQ_TNR_TNR2_DATELINE_ERROR BIT(15)
+#define TOF_ICC_IRQ_TNR_TNR2_ROUTING_ERROR BIT(16)
+#define TOF_ICC_IRQ_TNR_TNR3_RX_FILTER_OUT BIT(18)
+#define TOF_ICC_IRQ_TNR_TNR3_TX_FILTER_OUT BIT(19)
+#define TOF_ICC_IRQ_TNR_TNR3_PORT_ERROR BIT(20)
+#define TOF_ICC_IRQ_TNR_TNR3_DATELINE_ERROR BIT(21)
+#define TOF_ICC_IRQ_TNR_TNR3_ROUTING_ERROR BIT(22)
+#define TOF_ICC_IRQ_TNR_TNR4_RX_FILTER_OUT BIT(24)
+#define TOF_ICC_IRQ_TNR_TNR4_TX_FILTER_OUT BIT(25)
+#define TOF_ICC_IRQ_TNR_TNR4_PORT_ERROR BIT(26)
+#define TOF_ICC_IRQ_TNR_TNR4_DATELINE_ERROR BIT(27)
+#define TOF_ICC_IRQ_TNR_TNR4_ROUTING_ERROR BIT(28)
+#define TOF_ICC_IRQ_TNR_TNR5_RX_FILTER_OUT BIT(30)
+#define TOF_ICC_IRQ_TNR_TNR5_TX_FILTER_OUT BIT(31)
+#define TOF_ICC_IRQ_TNR_TNR5_PORT_ERROR BIT(32)
+#define TOF_ICC_IRQ_TNR_TNR5_DATELINE_ERROR BIT(33)
+#define TOF_ICC_IRQ_TNR_TNR5_ROUTING_ERROR BIT(34)
+#define TOF_ICC_IRQ_TNR_TNR6_RX_FILTER_OUT BIT(36)
+#define TOF_ICC_IRQ_TNR_TNR6_TX_FILTER_OUT BIT(37)
+#define TOF_ICC_IRQ_TNR_TNR6_PORT_ERROR BIT(38)
+#define TOF_ICC_IRQ_TNR_TNR6_DATELINE_ERROR BIT(39)
+#define TOF_ICC_IRQ_TNR_TNR6_ROUTING_ERROR BIT(40)
+#define TOF_ICC_IRQ_TNR_TNR7_RX_FILTER_OUT BIT(42)
+#define TOF_ICC_IRQ_TNR_TNR7_TX_FILTER_OUT BIT(43)
+#define TOF_ICC_IRQ_TNR_TNR7_PORT_ERROR BIT(44)
+#define TOF_ICC_IRQ_TNR_TNR7_DATELINE_ERROR BIT(45)
+#define TOF_ICC_IRQ_TNR_TNR7_ROUTING_ERROR BIT(46)
+#define TOF_ICC_IRQ_TNR_TNR8_RX_FILTER_OUT BIT(48)
+#define TOF_ICC_IRQ_TNR_TNR8_TX_FILTER_OUT BIT(49)
+#define TOF_ICC_IRQ_TNR_TNR8_PORT_ERROR BIT(50)
+#define TOF_ICC_IRQ_TNR_TNR8_DATELINE_ERROR BIT(51)
+#define TOF_ICC_IRQ_TNR_TNR8_ROUTING_ERROR BIT(52)
+#define TOF_ICC_IRQ_TNR_TNR9_RX_FILTER_OUT BIT(54)
+#define TOF_ICC_IRQ_TNR_TNR9_TX_FILTER_OUT BIT(55)
+#define TOF_ICC_IRQ_TNR_TNR9_PORT_ERROR BIT(56)
+#define TOF_ICC_IRQ_TNR_TNR9_DATELINE_ERROR BIT(57)
+#define TOF_ICC_IRQ_TNR_TNR9_ROUTING_ERROR BIT(58)
+
+#endif
+
+/* vim: set noet ts=8 sw=8 sts=0 tw=0 : */
+
--- a/executer/kernel/mcctrl/arch/arm64/include/tofu/tof_uapi.h
+++ b/executer/kernel/mcctrl/arch/arm64/include/tofu/tof_uapi.h
@ -0,0 +1,345 @@
+#ifndef _TOF_UAPI_H_
+#define _TOF_UAPI_H_
+
+#ifdef __KERNEL__
+#include <linux/types.h>
+#else
+#include <stdint.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#endif
+
+enum tof_sig_errno_cq {
+	TOF_TOQ_DIRECT_DESCRIPTOR_EXCEPTION,
+	TOF_TOQ_SOURCE_TYPE_EXCEPTION,
+	TOF_MRQ_OVERFLOW,
+	TOF_CQS_CACHEFLUSH_TIMEOUT,
+};
+
+enum tof_sig_errno_bg {
+	TOF_NODE_ADDRESS_UNMATCH,
+	TOF_BSEQ_UNMATCH,
+	TOF_SIGNAL_STATE_ERROR,
+	TOF_ERROR_SYNCHRONIZATION_ACKNOWLEDGE,
+};
+
+#define TOF_UAPI_VERSION 0x2a00
+
+struct tof_init_cq {
+	uint16_t version;
+	uint8_t session_mode;
+	uint8_t toq_size;
+	uint8_t mrq_size;
+	uint8_t num_stag;
+	uint8_t tcq_cinj;
+	uint8_t mrq_cinj;
+	void *toq_mem;
+	void *tcq_mem;
+	void *mrq_mem;
+};
+
+struct tof_alloc_stag {
+	uint32_t flags;
+	int stag;
+	uint64_t offset;
+	void *va;
+	uint64_t len;
+};
+
+struct tof_free_stags {
+	uint16_t num;
+	int *stags;
+};
+
+struct tof_addr {
+	uint8_t pa;
+	uint8_t pb;
+	uint8_t pc;
+	uint8_t x;
+	uint8_t y;
+	uint8_t z;
+	uint8_t a;
+	uint8_t b;
+	uint8_t c;
+};
+
+struct tof_set_bg {
+	int tni;
+	int gate;
+	int source_lgate;
+	struct tof_addr source_raddr;
+	int source_rtni;
+	int source_rgate;
+	int dest_lgate;
+	struct tof_addr dest_raddr;
+	int dest_rtni;
+	int dest_rgate;
+};
+
+struct tof_enable_bch {
+	void *addr;
+	int bseq;
+	int num;
+	struct tof_set_bg *bgs;
+};
+
+struct tof_set_subnet {
+	int res0;
+	int res1;
+	uint8_t nx;
+	uint8_t sx;
+	uint8_t lx;
+	uint8_t ny;
+	uint8_t sy;
+	uint8_t ly;
+	uint8_t nz;
+	uint8_t sz;
+	uint8_t lz;
+};
+
+struct tof_reg_user {
+	uid_t uid;
+	uint32_t gpid;
+	struct tof_set_subnet subnet;
+	uint64_t *cqmask;
+	uint64_t *bgmask;
+};
+
+struct tof_notify_linkdown {
+	int num;
+	struct {
+		uint8_t x;
+		uint8_t y;
+		uint8_t z;
+		uint8_t a;
+		uint8_t b;
+		uint8_t c;
+		uint16_t ports;
+	} *items;
+};
+
+struct tof_get_port_stat {
+	int port_no;
+	uint64_t mask;
+	uint64_t pa[31];
+};
+
+struct tof_get_cq_stat {
+	int tni;
+	int cqid;
+	uint64_t txbyte;
+	uint64_t rxbyte;
+};
+
+struct tof_load_register {
+	uint64_t pa;
+	uint64_t len;
+	void *buf;
+};
+
+struct tof_load_resource {
+	uint64_t rsc_id;
+	uint64_t offset;
+	uint64_t len;
+	void *buf;
+};
+
+union tof_trans_table_bitfield {
+	struct {
+		uint64_t start:36;
+		uint64_t len:27;
+		uint64_t ps_code:1;
+	} bits;
+	uint64_t atomic;
+};
+
+struct tof_trans_table {
+	union tof_trans_table_bitfield steering;
+	union tof_trans_table_bitfield mbpt;
+};
+
+void tof_utofu_set_linkdown_callback(void (*callback)(int, const void *));
+void tof_utofu_unset_linkdown_callback(void);
+
+#define TOF_MMAP_CQ_REGISTER 0
+#ifdef __KERNEL__
+#define TOF_MMAP_CQ_TRANSTABLE (PAGE_SIZE)
+#else
+#define TOF_MMAP_CQ_TRANSTABLE (sysconf(_SC_PAGESIZE))
+#endif
+#define TOF_MMAP_BCH_REGISTER 0
+#define TOF_MMAP_XB_STQ 0
+
+#define TOF_ST_RDWR 0x0
+#define TOF_ST_RDONLY 0x1
+#define TOF_ST_LPG 0x2
+
+#define TOF_STAG_TRANS_PS_CODE_64KB 0
+#define TOF_STAG_TRANS_PS_CODE_2MB  1
+
+#define TOF_IOC_MAGIC 'd'
+#define TOF_IOCTL_INIT_CQ _IOWR(TOF_IOC_MAGIC, 0, long)
+#define TOF_IOCTL_ALLOC_STAG _IOWR(TOF_IOC_MAGIC, 1, long)
+#define TOF_IOCTL_FREE_STAGS _IOWR(TOF_IOC_MAGIC, 2, long)
+#define TOF_IOCTL_ENABLE_BCH _IOWR(TOF_IOC_MAGIC, 3, long)
+#define TOF_IOCTL_DISABLE_BCH _IOWR(TOF_IOC_MAGIC, 4, long)
+#define TOF_IOCTL_SET_RT_SIGNAL _IOWR(TOF_IOC_MAGIC, 5, long)
+#define TOF_IOCTL_SET_SUBNET _IOWR(TOF_IOC_MAGIC, 6, long)
+#define TOF_IOCTL_REG_USER _IOWR(TOF_IOC_MAGIC, 7, long)
+#define TOF_IOCTL_NOTIFY_LINKDOWN _IOWR(TOF_IOC_MAGIC, 8, long)
+#define TOF_IOCTL_GET_PORT_STAT _IOWR(TOF_IOC_MAGIC, 9, long)
+#define TOF_IOCTL_GET_CQ_STAT _IOWR(TOF_IOC_MAGIC, 10, long)
+#define TOF_IOCTL_LOAD_REGISTER _IOWR(TOF_IOC_MAGIC, 11, long)
+#define TOF_IOCTL_LOAD_RESOURCE _IOWR(TOF_IOC_MAGIC, 12, long)
+
+#ifndef __KERNEL__
+#define TOF_INIT_CQ TOF_IOCTL_INIT_CQ
+#define TOF_ALLOC_STAG TOF_IOCTL_ALLOC_STAG
+#define TOF_FREE_STAGS TOF_IOCTL_FREE_STAGS
+#define TOF_ENABLE_BCH TOF_IOCTL_ENABLE_BCH
+#define TOF_DISABLE_BCH TOF_IOCTL_DISABLE_BCH
+#define TOF_SET_RT_SIGNAL TOF_IOCTL_SET_RT_SIGNAL
+#define TOF_SET_SUBNET TOF_IOCTL_SET_SUBNET
+#define TOF_REG_USER TOF_IOCTL_REG_USER
+#define TOF_NOTIFY_LINKDOWN TOF_IOCTL_NOTIFY_LINKDOWN
+#define TOF_GET_PORT_STAT TOF_IOCTL_GET_PORT_STAT
+#define TOF_GET_CQ_STAT TOF_IOCTL_GET_CQ_STAT
+#define TOF_LOAD_REGISTER TOF_IOCTL_LOAD_REGISTER
+#define TOF_LOAD_RESOURCE TOF_IOCTL_LOAD_RESOURCE
+#endif
+
+enum {
+	/* TOQ (0 - 71) */
+	TOF_RSC_TNI0_TOQ0 = 0, TOF_RSC_TNI0_TOQ1, TOF_RSC_TNI0_TOQ2, TOF_RSC_TNI0_TOQ3,
+	TOF_RSC_TNI0_TOQ4, TOF_RSC_TNI0_TOQ5, TOF_RSC_TNI0_TOQ6, TOF_RSC_TNI0_TOQ7,
+	TOF_RSC_TNI0_TOQ8, TOF_RSC_TNI0_TOQ9, TOF_RSC_TNI0_TOQ10, TOF_RSC_TNI0_TOQ11,
+	TOF_RSC_TNI1_TOQ0, TOF_RSC_TNI1_TOQ1, TOF_RSC_TNI1_TOQ2, TOF_RSC_TNI1_TOQ3,
+	TOF_RSC_TNI1_TOQ4, TOF_RSC_TNI1_TOQ5, TOF_RSC_TNI1_TOQ6, TOF_RSC_TNI1_TOQ7,
+	TOF_RSC_TNI1_TOQ8, TOF_RSC_TNI1_TOQ9, TOF_RSC_TNI1_TOQ10, TOF_RSC_TNI1_TOQ11,
+	TOF_RSC_TNI2_TOQ0, TOF_RSC_TNI2_TOQ1, TOF_RSC_TNI2_TOQ2, TOF_RSC_TNI2_TOQ3,
+	TOF_RSC_TNI2_TOQ4, TOF_RSC_TNI2_TOQ5, TOF_RSC_TNI2_TOQ6, TOF_RSC_TNI2_TOQ7,
+	TOF_RSC_TNI2_TOQ8, TOF_RSC_TNI2_TOQ9, TOF_RSC_TNI2_TOQ10, TOF_RSC_TNI2_TOQ11,
+	TOF_RSC_TNI3_TOQ0, TOF_RSC_TNI3_TOQ1, TOF_RSC_TNI3_TOQ2, TOF_RSC_TNI3_TOQ3,
+	TOF_RSC_TNI3_TOQ4, TOF_RSC_TNI3_TOQ5, TOF_RSC_TNI3_TOQ6, TOF_RSC_TNI3_TOQ7,
+	TOF_RSC_TNI3_TOQ8, TOF_RSC_TNI3_TOQ9, TOF_RSC_TNI3_TOQ10, TOF_RSC_TNI3_TOQ11,
+	TOF_RSC_TNI4_TOQ0, TOF_RSC_TNI4_TOQ1, TOF_RSC_TNI4_TOQ2, TOF_RSC_TNI4_TOQ3,
+	TOF_RSC_TNI4_TOQ4, TOF_RSC_TNI4_TOQ5, TOF_RSC_TNI4_TOQ6, TOF_RSC_TNI4_TOQ7,
+	TOF_RSC_TNI4_TOQ8, TOF_RSC_TNI4_TOQ9, TOF_RSC_TNI4_TOQ10, TOF_RSC_TNI4_TOQ11,
+	TOF_RSC_TNI5_TOQ0, TOF_RSC_TNI5_TOQ1, TOF_RSC_TNI5_TOQ2, TOF_RSC_TNI5_TOQ3,
+	TOF_RSC_TNI5_TOQ4, TOF_RSC_TNI5_TOQ5, TOF_RSC_TNI5_TOQ6, TOF_RSC_TNI5_TOQ7,
+	TOF_RSC_TNI5_TOQ8, TOF_RSC_TNI5_TOQ9, TOF_RSC_TNI5_TOQ10, TOF_RSC_TNI5_TOQ11,
+
+	/* TOQ (72 - 143) */
+	TOF_RSC_TNI0_TCQ0, TOF_RSC_TNI0_TCQ1, TOF_RSC_TNI0_TCQ2, TOF_RSC_TNI0_TCQ3,
+	TOF_RSC_TNI0_TCQ4, TOF_RSC_TNI0_TCQ5, TOF_RSC_TNI0_TCQ6, TOF_RSC_TNI0_TCQ7,
+	TOF_RSC_TNI0_TCQ8, TOF_RSC_TNI0_TCQ9, TOF_RSC_TNI0_TCQ10, TOF_RSC_TNI0_TCQ11,
+	TOF_RSC_TNI1_TCQ0, TOF_RSC_TNI1_TCQ1, TOF_RSC_TNI1_TCQ2, TOF_RSC_TNI1_TCQ3,
+	TOF_RSC_TNI1_TCQ4, TOF_RSC_TNI1_TCQ5, TOF_RSC_TNI1_TCQ6, TOF_RSC_TNI1_TCQ7,
+	TOF_RSC_TNI1_TCQ8, TOF_RSC_TNI1_TCQ9, TOF_RSC_TNI1_TCQ10, TOF_RSC_TNI1_TCQ11,
+	TOF_RSC_TNI2_TCQ0, TOF_RSC_TNI2_TCQ1, TOF_RSC_TNI2_TCQ2, TOF_RSC_TNI2_TCQ3,
+	TOF_RSC_TNI2_TCQ4, TOF_RSC_TNI2_TCQ5, TOF_RSC_TNI2_TCQ6, TOF_RSC_TNI2_TCQ7,
+	TOF_RSC_TNI2_TCQ8, TOF_RSC_TNI2_TCQ9, TOF_RSC_TNI2_TCQ10, TOF_RSC_TNI2_TCQ11,
+	TOF_RSC_TNI3_TCQ0, TOF_RSC_TNI3_TCQ1, TOF_RSC_TNI3_TCQ2, TOF_RSC_TNI3_TCQ3,
+	TOF_RSC_TNI3_TCQ4, TOF_RSC_TNI3_TCQ5, TOF_RSC_TNI3_TCQ6, TOF_RSC_TNI3_TCQ7,
+	TOF_RSC_TNI3_TCQ8, TOF_RSC_TNI3_TCQ9, TOF_RSC_TNI3_TCQ10, TOF_RSC_TNI3_TCQ11,
+	TOF_RSC_TNI4_TCQ0, TOF_RSC_TNI4_TCQ1, TOF_RSC_TNI4_TCQ2, TOF_RSC_TNI4_TCQ3,
+	TOF_RSC_TNI4_TCQ4, TOF_RSC_TNI4_TCQ5, TOF_RSC_TNI4_TCQ6, TOF_RSC_TNI4_TCQ7,
+	TOF_RSC_TNI4_TCQ8, TOF_RSC_TNI4_TCQ9, TOF_RSC_TNI4_TCQ10, TOF_RSC_TNI4_TCQ11,
+	TOF_RSC_TNI5_TCQ0, TOF_RSC_TNI5_TCQ1, TOF_RSC_TNI5_TCQ2, TOF_RSC_TNI5_TCQ3,
+	TOF_RSC_TNI5_TCQ4, TOF_RSC_TNI5_TCQ5, TOF_RSC_TNI5_TCQ6, TOF_RSC_TNI5_TCQ7,
+	TOF_RSC_TNI5_TCQ8, TOF_RSC_TNI5_TCQ9, TOF_RSC_TNI5_TCQ10, TOF_RSC_TNI5_TCQ11,
+
+	/* MRQ (144 - 215) */
+	TOF_RSC_TNI0_MRQ0, TOF_RSC_TNI0_MRQ1, TOF_RSC_TNI0_MRQ2, TOF_RSC_TNI0_MRQ3,
+	TOF_RSC_TNI0_MRQ4, TOF_RSC_TNI0_MRQ5, TOF_RSC_TNI0_MRQ6, TOF_RSC_TNI0_MRQ7,
+	TOF_RSC_TNI0_MRQ8, TOF_RSC_TNI0_MRQ9, TOF_RSC_TNI0_MRQ10, TOF_RSC_TNI0_MRQ11,
+	TOF_RSC_TNI1_MRQ0, TOF_RSC_TNI1_MRQ1, TOF_RSC_TNI1_MRQ2, TOF_RSC_TNI1_MRQ3,
+	TOF_RSC_TNI1_MRQ4, TOF_RSC_TNI1_MRQ5, TOF_RSC_TNI1_MRQ6, TOF_RSC_TNI1_MRQ7,
+	TOF_RSC_TNI1_MRQ8, TOF_RSC_TNI1_MRQ9, TOF_RSC_TNI1_MRQ10, TOF_RSC_TNI1_MRQ11,
+	TOF_RSC_TNI2_MRQ0, TOF_RSC_TNI2_MRQ1, TOF_RSC_TNI2_MRQ2, TOF_RSC_TNI2_MRQ3,
+	TOF_RSC_TNI2_MRQ4, TOF_RSC_TNI2_MRQ5, TOF_RSC_TNI2_MRQ6, TOF_RSC_TNI2_MRQ7,
+	TOF_RSC_TNI2_MRQ8, TOF_RSC_TNI2_MRQ9, TOF_RSC_TNI2_MRQ10, TOF_RSC_TNI2_MRQ11,
+	TOF_RSC_TNI3_MRQ0, TOF_RSC_TNI3_MRQ1, TOF_RSC_TNI3_MRQ2, TOF_RSC_TNI3_MRQ3,
+	TOF_RSC_TNI3_MRQ4, TOF_RSC_TNI3_MRQ5, TOF_RSC_TNI3_MRQ6, TOF_RSC_TNI3_MRQ7,
+	TOF_RSC_TNI3_MRQ8, TOF_RSC_TNI3_MRQ9, TOF_RSC_TNI3_MRQ10, TOF_RSC_TNI3_MRQ11,
+	TOF_RSC_TNI4_MRQ0, TOF_RSC_TNI4_MRQ1, TOF_RSC_TNI4_MRQ2, TOF_RSC_TNI4_MRQ3,
+	TOF_RSC_TNI4_MRQ4, TOF_RSC_TNI4_MRQ5, TOF_RSC_TNI4_MRQ6, TOF_RSC_TNI4_MRQ7,
+	TOF_RSC_TNI4_MRQ8, TOF_RSC_TNI4_MRQ9, TOF_RSC_TNI4_MRQ10, TOF_RSC_TNI4_MRQ11,
+	TOF_RSC_TNI5_MRQ0, TOF_RSC_TNI5_MRQ1, TOF_RSC_TNI5_MRQ2, TOF_RSC_TNI5_MRQ3,
+	TOF_RSC_TNI5_MRQ4, TOF_RSC_TNI5_MRQ5, TOF_RSC_TNI5_MRQ6, TOF_RSC_TNI5_MRQ7,
+	TOF_RSC_TNI5_MRQ8, TOF_RSC_TNI5_MRQ9, TOF_RSC_TNI5_MRQ10, TOF_RSC_TNI5_MRQ11,
+
+	/* PBQ (216 - 221) */
+	TOF_RSC_TNI0_PBQ, TOF_RSC_TNI1_PBQ, TOF_RSC_TNI2_PBQ, TOF_RSC_TNI3_PBQ,
+	TOF_RSC_TNI4_PBQ, TOF_RSC_TNI5_PBQ,
+
+	/* PRQ (222 - 227) */
+	TOF_RSC_TNI0_PRQ, TOF_RSC_TNI1_PRQ, TOF_RSC_TNI2_PRQ, TOF_RSC_TNI3_PRQ,
+	TOF_RSC_TNI4_PRQ, TOF_RSC_TNI5_PRQ,
+
+	/* STEERINGTABLE (228 - 299) */
+	TOF_RSC_TNI0_STEERINGTABLE0, TOF_RSC_TNI0_STEERINGTABLE1, TOF_RSC_TNI0_STEERINGTABLE2,
+	TOF_RSC_TNI0_STEERINGTABLE3, TOF_RSC_TNI0_STEERINGTABLE4, TOF_RSC_TNI0_STEERINGTABLE5,
+	TOF_RSC_TNI0_STEERINGTABLE6, TOF_RSC_TNI0_STEERINGTABLE7, TOF_RSC_TNI0_STEERINGTABLE8,
+	TOF_RSC_TNI0_STEERINGTABLE9, TOF_RSC_TNI0_STEERINGTABLE10, TOF_RSC_TNI0_STEERINGTABLE11,
+	TOF_RSC_TNI1_STEERINGTABLE0, TOF_RSC_TNI1_STEERINGTABLE1, TOF_RSC_TNI1_STEERINGTABLE2,
+	TOF_RSC_TNI1_STEERINGTABLE3, TOF_RSC_TNI1_STEERINGTABLE4, TOF_RSC_TNI1_STEERINGTABLE5,
+	TOF_RSC_TNI1_STEERINGTABLE6, TOF_RSC_TNI1_STEERINGTABLE7, TOF_RSC_TNI1_STEERINGTABLE8,
+	TOF_RSC_TNI1_STEERINGTABLE9, TOF_RSC_TNI1_STEERINGTABLE10, TOF_RSC_TNI1_STEERINGTABLE11,
+	TOF_RSC_TNI2_STEERINGTABLE0, TOF_RSC_TNI2_STEERINGTABLE1, TOF_RSC_TNI2_STEERINGTABLE2,
+	TOF_RSC_TNI2_STEERINGTABLE3, TOF_RSC_TNI2_STEERINGTABLE4, TOF_RSC_TNI2_STEERINGTABLE5,
+	TOF_RSC_TNI2_STEERINGTABLE6, TOF_RSC_TNI2_STEERINGTABLE7, TOF_RSC_TNI2_STEERINGTABLE8,
+	TOF_RSC_TNI2_STEERINGTABLE9, TOF_RSC_TNI2_STEERINGTABLE10, TOF_RSC_TNI2_STEERINGTABLE11,
+	TOF_RSC_TNI3_STEERINGTABLE0, TOF_RSC_TNI3_STEERINGTABLE1, TOF_RSC_TNI3_STEERINGTABLE2,
+	TOF_RSC_TNI3_STEERINGTABLE3, TOF_RSC_TNI3_STEERINGTABLE4, TOF_RSC_TNI3_STEERINGTABLE5,
+	TOF_RSC_TNI3_STEERINGTABLE6, TOF_RSC_TNI3_STEERINGTABLE7, TOF_RSC_TNI3_STEERINGTABLE8,
+        TOF_RSC_TNI3_STEERINGTABLE9, TOF_RSC_TNI3_STEERINGTABLE10, TOF_RSC_TNI3_STEERINGTABLE11,
+        TOF_RSC_TNI4_STEERINGTABLE0, TOF_RSC_TNI4_STEERINGTABLE1, TOF_RSC_TNI4_STEERINGTABLE2,
+        TOF_RSC_TNI4_STEERINGTABLE3, TOF_RSC_TNI4_STEERINGTABLE4, TOF_RSC_TNI4_STEERINGTABLE5,
+        TOF_RSC_TNI4_STEERINGTABLE6, TOF_RSC_TNI4_STEERINGTABLE7, TOF_RSC_TNI4_STEERINGTABLE8,
+        TOF_RSC_TNI4_STEERINGTABLE9, TOF_RSC_TNI4_STEERINGTABLE10, TOF_RSC_TNI4_STEERINGTABLE11,
+        TOF_RSC_TNI5_STEERINGTABLE3, TOF_RSC_TNI5_STEERINGTABLE4, TOF_RSC_TNI5_STEERINGTABLE5,
+        TOF_RSC_TNI5_STEERINGTABLE6, TOF_RSC_TNI5_STEERINGTABLE7, TOF_RSC_TNI5_STEERINGTABLE8,
+        TOF_RSC_TNI5_STEERINGTABLE9, TOF_RSC_TNI5_STEERINGTABLE10, TOF_RSC_TNI5_STEERINGTABLE11,
+
+        /* MBTABLE (300 - 371) */
+        TOF_RSC_TNI0_MBTABLE0, TOF_RSC_TNI0_MBTABLE1, TOF_RSC_TNI0_MBTABLE2,
+        TOF_RSC_TNI0_MBTABLE3, TOF_RSC_TNI0_MBTABLE4, TOF_RSC_TNI0_MBTABLE5,
+        TOF_RSC_TNI0_MBTABLE6, TOF_RSC_TNI0_MBTABLE7, TOF_RSC_TNI0_MBTABLE8,
+        TOF_RSC_TNI0_MBTABLE9, TOF_RSC_TNI0_MBTABLE10, TOF_RSC_TNI0_MBTABLE11,
+        TOF_RSC_TNI1_MBTABLE0, TOF_RSC_TNI1_MBTABLE1, TOF_RSC_TNI1_MBTABLE2,
+        TOF_RSC_TNI1_MBTABLE3, TOF_RSC_TNI1_MBTABLE4, TOF_RSC_TNI1_MBTABLE5,
+        TOF_RSC_TNI1_MBTABLE6, TOF_RSC_TNI1_MBTABLE7, TOF_RSC_TNI1_MBTABLE8,
+        TOF_RSC_TNI1_MBTABLE9, TOF_RSC_TNI1_MBTABLE10, TOF_RSC_TNI1_MBTABLE11,
+        TOF_RSC_TNI2_MBTABLE0, TOF_RSC_TNI2_MBTABLE1, TOF_RSC_TNI2_MBTABLE2,
+        TOF_RSC_TNI2_MBTABLE3, TOF_RSC_TNI2_MBTABLE4, TOF_RSC_TNI2_MBTABLE5,
+        TOF_RSC_TNI2_MBTABLE6, TOF_RSC_TNI2_MBTABLE7, TOF_RSC_TNI2_MBTABLE8,
+        TOF_RSC_TNI2_MBTABLE9, TOF_RSC_TNI2_MBTABLE10, TOF_RSC_TNI2_MBTABLE11,
+        TOF_RSC_TNI3_MBTABLE0, TOF_RSC_TNI3_MBTABLE1, TOF_RSC_TNI3_MBTABLE2,
+        TOF_RSC_TNI3_MBTABLE3, TOF_RSC_TNI3_MBTABLE4, TOF_RSC_TNI3_MBTABLE5,
+        TOF_RSC_TNI3_MBTABLE6, TOF_RSC_TNI3_MBTABLE7, TOF_RSC_TNI3_MBTABLE8,
+        TOF_RSC_TNI3_MBTABLE9, TOF_RSC_TNI3_MBTABLE10, TOF_RSC_TNI3_MBTABLE11,
+        TOF_RSC_TNI4_MBTABLE0, TOF_RSC_TNI4_MBTABLE1, TOF_RSC_TNI4_MBTABLE2,
+        TOF_RSC_TNI4_MBTABLE3, TOF_RSC_TNI4_MBTABLE4, TOF_RSC_TNI4_MBTABLE5,
+        TOF_RSC_TNI4_MBTABLE6, TOF_RSC_TNI4_MBTABLE7, TOF_RSC_TNI4_MBTABLE8,
+        TOF_RSC_TNI4_MBTABLE9, TOF_RSC_TNI4_MBTABLE10, TOF_RSC_TNI4_MBTABLE11,
+        TOF_RSC_TNI5_MBTABLE0, TOF_RSC_TNI5_MBTABLE1, TOF_RSC_TNI5_MBTABLE2,
+        TOF_RSC_TNI5_MBTABLE3, TOF_RSC_TNI5_MBTABLE4, TOF_RSC_TNI5_MBTABLE5,
+        TOF_RSC_TNI5_MBTABLE6, TOF_RSC_TNI5_MBTABLE7, TOF_RSC_TNI5_MBTABLE8,
+        TOF_RSC_TNI5_MBTABLE9, TOF_RSC_TNI5_MBTABLE10, TOF_RSC_TNI5_MBTABLE11,
+
+        TOF_RSC_NUM     /* 372 */
+};
+#define TOF_RSC_TOQ(TNI, CQID)  (TOF_RSC_TNI0_TOQ0 + (TNI * 12) + CQID)
+#define TOF_RSC_TCQ(TNI, CQID)  (TOF_RSC_TNI0_TCQ0 + (TNI * 12) + CQID)
+#define TOF_RSC_MRQ(TNI, CQID)  (TOF_RSC_TNI0_MRQ0 + (TNI * 12) + CQID)
+#define TOF_RSC_PBQ(TNI)        (TOF_RSC_TNI0_PBQ + TNI)
+#define TOF_RSC_PRQ(TNI)        (TOF_RSC_TNI0_PRQ + TNI)
+#define TOF_RSC_STT(TNI, CQID)  (TOF_RSC_TNI0_STEERINGTABLE0 + (TNI * 12) + CQID)
+#define TOF_RSC_MBT(TNI, CQID)  (TOF_RSC_TNI0_MBTABLE0 + (TNI * 12) + CQID)
+
+#endif
+
+/* vim: set noet ts=8 sw=8 sts=0 tw=0 : */
+
--- a/executer/kernel/mcctrl/arch/arm64/include/tofu/tof_utofu_bg_bch.h
+++ b/executer/kernel/mcctrl/arch/arm64/include/tofu/tof_utofu_bg_bch.h
@ -0,0 +1,6 @@
+	struct {
+		bool enabled;
+		uint64_t bgmask[TOF_ICC_NTNIS];
+		uintptr_t iova;
+		void *kaddr;
+	} bch;
--- a/executer/kernel/mcctrl/arch/arm64/include/tofu/tof_utofu_cq_trans.h
+++ b/executer/kernel/mcctrl/arch/arm64/include/tofu/tof_utofu_cq_trans.h
@ -0,0 +1,6 @@
+			struct {
+				struct tof_utofu_trans_list *mru;
+				struct tof_trans_table *table;
+				int mruhead;
+				ihk_spinlock_t mru_lock;
+			} trans;
--- a/executer/kernel/mcctrl/arch/arm64/include/tofu/tofu_generated-tof_utofu_bg.h
+++ b/executer/kernel/mcctrl/arch/arm64/include/tofu/tofu_generated-tof_utofu_bg.h
@ -0,0 +1,21 @@
+struct tof_utofu_bg {
+	union {
+		char whole_struct[160];
+		struct {
+			char padding0[0];
+			struct tof_utofu_device common;
+		};
+		struct {
+			char padding1[80];
+			uint8_t tni;
+		};
+		struct {
+			char padding2[81];
+			uint8_t bgid;
+		};
+		struct {
+			char padding3[88];
+			#include "tof_utofu_bg_bch.h"
+		};
+	};
+};
--- a/executer/kernel/mcctrl/arch/arm64/include/tofu/tofu_generated-tof_utofu_cq.h
+++ b/executer/kernel/mcctrl/arch/arm64/include/tofu/tofu_generated-tof_utofu_cq.h
@ -0,0 +1,37 @@
+struct tof_utofu_cq {
+	union {
+		char whole_struct[384];
+		struct {
+			char padding0[0];
+			struct tof_utofu_device common;
+		};
+		struct {
+			char padding1[80];
+			uint8_t tni;
+		};
+		struct {
+			char padding2[81];
+			uint8_t cqid;
+		};
+		struct {
+			char padding3[104];
+			#include "tof_utofu_cq_trans.h"
+		};
+		struct {
+			char padding4[128];
+			struct tof_icc_steering_entry *steering;
+		};
+		struct {
+			char padding5[136];
+			struct tof_icc_mb_entry *mb;
+		};
+		struct {
+			char padding6[186];
+			uint8_t num_stag;
+		};
+		struct {
+			char padding7[336];
+			struct mmu_notifier mn;
+		};
+	};
+};
--- a/executer/kernel/mcctrl/arch/arm64/include/tofu/tofu_generated-tof_utofu_device.h
+++ b/executer/kernel/mcctrl/arch/arm64/include/tofu/tofu_generated-tof_utofu_device.h
@ -0,0 +1,17 @@
+struct tof_utofu_device {
+	union {
+		char whole_struct[80];
+		struct {
+			char padding0[0];
+			bool enabled;
+		};
+		struct {
+			char padding1[12];
+			uint32_t gpid;
+		};
+		struct {
+			char padding2[24];
+			uint64_t subnet;
+		};
+	};
+};
--- a/executer/kernel/mcctrl/arch/arm64/include/tofu/tofu_generated-tof_utofu_mbpt.h
+++ b/executer/kernel/mcctrl/arch/arm64/include/tofu/tofu_generated-tof_utofu_mbpt.h
@ -0,0 +1,33 @@
+struct tof_utofu_mbpt {
+	union {
+		char whole_struct[56];
+		struct {
+			char padding0[0];
+			struct kref kref;
+		};
+		struct {
+			char padding1[8];
+			struct tof_utofu_cq *ucq;
+		};
+		struct {
+			char padding2[16];
+			uintptr_t iova;
+		};
+		struct {
+			char padding3[24];
+			struct scatterlist *sg;
+		};
+		struct {
+			char padding4[32];
+			size_t nsgents;
+		};
+		struct {
+			char padding5[40];
+			uintptr_t mbptstart;
+		};
+		struct {
+			char padding6[48];
+			size_t pgsz;
+		};
+	};
+};
--- a/executer/kernel/mcctrl/control.c
+++ b/executer/kernel/mcctrl/control.c
@ -230,6 +230,9 @@ static long mcexec_prepare_image(ihk_os_t os,

 	dprintk("%s: pid %d, rpgtable: 0x%lx added\n",
 		__FUNCTION__, ppd->pid, ppd->rpgtable);
+#ifdef ENABLE_TOFU
+	ppd->enable_tofu = pdesc->enable_tofu;
+#endif

 	ret = 0;

@ -267,18 +270,24 @@ int mcexec_transfer_image(ihk_os_t os, struct remote_transfer *__user upt)
 		return -EFAULT;
 	}

+#ifdef CONFIG_MIC
 	if (pt.size > PAGE_SIZE) {
 		printk("mcexec_transfer_image(): ERROR: size exceeds PAGE_SIZE\n");
 		return -EFAULT;
 	}
-	
+
 	phys = ihk_device_map_memory(ihk_os_to_dev(os), pt.rphys, PAGE_SIZE);
-#ifdef CONFIG_MIC
 	rpm = ioremap_wc(phys, PAGE_SIZE);
 #else
-	rpm = ihk_device_map_virtual(ihk_os_to_dev(os), phys, PAGE_SIZE, NULL, 0);
+	phys = ihk_device_map_memory(ihk_os_to_dev(os), pt.rphys, pt.size);
+	rpm = ihk_device_map_virtual(ihk_os_to_dev(os), phys, pt.size, NULL, 0);
 #endif
-	
+
+	if (!rpm) {
+		pr_err("%s(): error: invalid remote address\n", __func__);
+		return -EFAULT;
+	}
+
 	if (pt.direction == MCEXEC_UP_TRANSFER_TO_REMOTE) {
 		if (copy_from_user(rpm, pt.userp, pt.size)) {
 			ret = -EFAULT;
@ -296,10 +305,11 @@ int mcexec_transfer_image(ihk_os_t os, struct remote_transfer *__user upt)

 #ifdef CONFIG_MIC
 	iounmap(rpm);
+	ihk_device_unmap_memory(ihk_os_to_dev(os), phys, PAGE_SIZE);
 #else
-	ihk_device_unmap_virtual(ihk_os_to_dev(os), rpm, PAGE_SIZE);
+	ihk_device_unmap_virtual(ihk_os_to_dev(os), rpm, pt.size);
+	ihk_device_unmap_memory(ihk_os_to_dev(os), phys, pt.size);
 #endif
-	ihk_device_unmap_memory(ihk_os_to_dev(os), phys, PAGE_SIZE);	

 	return ret;

@ -1258,7 +1268,7 @@ void mcctrl_put_per_proc_data(struct mcctrl_per_proc_data *ppd)
 			   process is gone and the application should be terminated. */
 			packet = (struct ikc_scd_packet *)ptd->data;
 			dprintk("%s: calling __return_syscall (hash),target pid=%d,tid=%d\n", __FUNCTION__, ppd->pid, packet->req.rtid);
-			__return_syscall(ppd->ud->os, packet, -ERESTARTSYS,
+			__return_syscall(ppd->ud->os, ppd, packet, -ERESTARTSYS,
 					 packet->req.rtid);
 			ihk_ikc_release_packet((struct ihk_ikc_free_packet *)packet);

@ -1282,7 +1292,7 @@ void mcctrl_put_per_proc_data(struct mcctrl_per_proc_data *ppd)

 		/* We use ERESTARTSYS to tell the LWK that the proxy
 		 * process is gone and the application should be terminated */
-		__return_syscall(ppd->ud->os, packet, -ERESTARTSYS,
+		__return_syscall(ppd->ud->os, ppd, packet, -ERESTARTSYS,
 				packet->req.rtid);
 		ihk_ikc_release_packet((struct ihk_ikc_free_packet *)packet);
 	}
@ -1323,7 +1333,7 @@ int mcexec_syscall(struct mcctrl_usrdata *ud, struct ikc_scd_packet *packet)

 		/* We use ERESTARTSYS to tell the LWK that the proxy
 		 * process is gone and the application should be terminated */
-		__return_syscall(ud->os, packet, -ERESTARTSYS,
+		__return_syscall(ud->os, NULL, packet, -ERESTARTSYS,
 				packet->req.rtid);
 		ihk_ikc_release_packet((struct ihk_ikc_free_packet *)packet);

@ -1766,7 +1776,7 @@ long mcexec_ret_syscall(ihk_os_t os, struct syscall_ret_desc *__user arg)
 		ihk_device_unmap_memory(ihk_os_to_dev(os), phys, ret.size);
 	} 

-	__return_syscall(os, packet, ret.ret, task_pid_vnr(current));
+	__return_syscall(os, ppd, packet, ret.ret, task_pid_vnr(current));

 	error = 0;
 out:
@ -2794,7 +2804,7 @@ static long mcexec_terminate_thread_unsafe(ihk_os_t os, int pid, int tid, long c
 				__FUNCTION__, tid);
 		goto no_ptd;
 	}
-	__return_syscall(usrdata->os, packet, code, tid);
+	__return_syscall(usrdata->os, ppd, packet, code, tid);
 	ihk_ikc_release_packet((struct ihk_ikc_free_packet *)packet);

 	/* Drop reference for this function */
@ -3636,7 +3646,8 @@ int __mcctrl_os_read_write_cpu_register(ihk_os_t os, int cpu,
 	isp.op = op;
 	isp.pdesc = virt_to_phys(ldesc);

-	ret = mcctrl_ikc_send_wait(os, cpu, &isp, 0, NULL, &do_free, 1, ldesc);
+	/* 1 sec timeout for the case where McKernel can't respond */
+	ret = mcctrl_ikc_send_wait(os, cpu, &isp, -1000, NULL, &do_free, 1, ldesc);
 	if (ret != 0) {
 		printk("%s: ERROR sending IKC msg: %d\n", __FUNCTION__, ret);
 		goto out;
--- a/executer/kernel/mcctrl/ikc.c
+++ b/executer/kernel/mcctrl/ikc.c
@ -536,9 +536,6 @@ int prepare_ikc_channels(ihk_os_t os)
 	usrdata->os = os;
 	ihk_host_os_set_usrdata(os, usrdata);

-	ihk_ikc_listen_port(os, &lp_ikc2linux);
-	ihk_ikc_listen_port(os, &lp_ikc2mckernel);
-
 	init_waitqueue_head(&usrdata->wq_procfs);
 	mutex_init(&usrdata->reserve_lock);
 	mutex_init(&usrdata->part_exec_lock);
@ -555,6 +552,16 @@ int prepare_ikc_channels(ihk_os_t os)
 	INIT_LIST_HEAD(&usrdata->wakeup_descs_list);
 	spin_lock_init(&usrdata->wakeup_descs_lock);

+	/* ihk_ikc_listen_port should be performed after
+	 * usrdata->cpu_topology_list is initialized because the
+	 * function enables syscall_packet_handler which accesses
+	 * the list (the call path is sysfsm_packet_handler -->
+	 * sysfsm_work_main --> sysfsm_setup --> setup_sysfs_files
+	 * --> setup_cpus_sysfs_files).
+	 */
+	ihk_ikc_listen_port(os, &lp_ikc2linux);
+	ihk_ikc_listen_port(os, &lp_ikc2mckernel);
+
 	return 0;

 error:
--- a/executer/kernel/mcctrl/mcctrl.h
+++ b/executer/kernel/mcctrl/mcctrl.h
@ -263,6 +263,7 @@ struct mcctrl_per_proc_data {

 	struct list_head devobj_pager_list;
 	struct semaphore devobj_pager_lock;
+	int enable_tofu;
 };

 struct sysfsm_req {
@ -464,7 +465,8 @@ struct mcctrl_per_thread_data *mcctrl_get_per_thread_data(struct mcctrl_per_proc
 							  struct task_struct *task);
 int mcctrl_clear_pte_range(uintptr_t start, uintptr_t len);

-void __return_syscall(ihk_os_t os, struct ikc_scd_packet *packet, 
+void __return_syscall(ihk_os_t os, struct mcctrl_per_proc_data *ppd,
+		struct ikc_scd_packet *packet,
 		long ret, int stid);
 int clear_pte_range(uintptr_t start, uintptr_t len);

@ -577,10 +579,13 @@ struct mcctrl_file_to_pidfd {
 	int pid;
 	int fd;
 	struct list_head hash;
+	char tofu_dev_path[128];
+	void *pde_data;
 };

 int mcctrl_file_to_pidfd_hash_insert(struct file *filp,
-	ihk_os_t os, int pid, struct task_struct *group_leader, int fd);
+	ihk_os_t os, int pid, struct task_struct *group_leader, int fd,
+	char *path, void *pde_data);
 struct mcctrl_file_to_pidfd *mcctrl_file_to_pidfd_hash_lookup(
 	struct file *filp, struct task_struct *group_leader);
 int mcctrl_file_to_pidfd_hash_remove(struct file *filp,
--- a/executer/kernel/mcctrl/syscall.c
+++ b/executer/kernel/mcctrl/syscall.c
@ -1864,7 +1864,8 @@ void mcctrl_file_to_pidfd_hash_init(void)
 }

 int mcctrl_file_to_pidfd_hash_insert(struct file *filp,
-	ihk_os_t os, int pid, struct task_struct *group_leader, int fd)
+	ihk_os_t os, int pid, struct task_struct *group_leader, int fd,
+	char *path, void *pde_data)
 {
 	unsigned long irqflags;
 	struct mcctrl_file_to_pidfd *file2pidfd_iter;
@ -1882,6 +1883,9 @@ int mcctrl_file_to_pidfd_hash_insert(struct file *filp,
 	file2pidfd->pid = pid;
 	file2pidfd->group_leader = group_leader;
 	file2pidfd->fd = fd;
+	/* Only copy the name under /proc/tofu/dev/ */
+	strncpy(file2pidfd->tofu_dev_path, path + 15, 128);
+	file2pidfd->pde_data = pde_data;

 	spin_lock_irqsave(&mcctrl_file_to_pidfd_hash_lock, irqflags);
 	list_for_each_entry(file2pidfd_iter,
@ -1980,7 +1984,8 @@ unlock_out:
 }
 #endif

-void __return_syscall(ihk_os_t os, struct ikc_scd_packet *packet,
+void __return_syscall(ihk_os_t os, struct mcctrl_per_proc_data *ppd,
+		struct ikc_scd_packet *packet,
 		long ret, int stid)
 {
 	unsigned long phys;
@ -2011,54 +2016,104 @@ void __return_syscall(ihk_os_t os, struct ikc_scd_packet *packet,
 	res->stid = stid;

 #ifdef ENABLE_TOFU
-	/* Record PDE_DATA after open() calls for Tofu driver */
-	if (packet->req.number == __NR_openat && ret > 1) {
+	/* Tofu enabled process? */
+	if (ppd && ppd->enable_tofu) {
 		char *pathbuf, *fullpath;
-		struct fd f;
-		int fd;

-		fd = ret;
-		f = fdget(fd);
+		/* Record PDE_DATA after open() calls for Tofu driver */
+		if (packet->req.number == __NR_openat && ret > 1) {
+			struct fd f;
+			int fd;

-		if (!f.file) {
-			goto out_notify;
+			fd = ret;
+			f = fdget(fd);
+
+			if (!f.file) {
+				goto out_notify;
+			}
+
+			pathbuf = (char *)__get_free_page(GFP_ATOMIC);
+			if (!pathbuf) {
+				goto out_fdput_open;
+			}
+
+			fullpath = d_path(&f.file->f_path, pathbuf, PAGE_SIZE);
+			if (IS_ERR(fullpath)) {
+				goto out_free_open;
+			}
+
+			if (!strncmp("/proc/tofu/dev/", fullpath, 15)) {
+				res->pde_data = PDE_DATA(file_inode(f.file));
+				dprintk("%s: fd: %d, path: %s, PDE_DATA: 0x%lx\n",
+						__func__,
+						fd,
+						fullpath,
+						(unsigned long)res->pde_data);
+				dprintk("%s: pgd_index: %ld, pmd_index: %ld, pte_index: %ld\n",
+						__func__,
+						pgd_index((unsigned long)res->pde_data),
+						pmd_index((unsigned long)res->pde_data),
+						pte_index((unsigned long)res->pde_data));
+				dprintk("MAX_USER_VA_BITS: %d, PGDIR_SHIFT: %d\n",
+						MAX_USER_VA_BITS, PGDIR_SHIFT);
+				mcctrl_file_to_pidfd_hash_insert(f.file, os,
+						task_tgid_vnr(current),
+						current->group_leader, fd,
+						fullpath, res->pde_data);
+			}
+
+out_free_open:
+			free_page((unsigned long)pathbuf);
+out_fdput_open:
+			fdput(f);
 		}

-		pathbuf = kmalloc(PATH_MAX, GFP_ATOMIC);
-		if (!pathbuf) {
-			goto out_fdput;
-		}
+		/* Ioctl on Tofu CQ? */
+		else if (packet->req.number == __NR_ioctl &&
+				packet->req.args[0] > 0 && ret == 0) {
+			struct fd f;
+			int fd;
+			int tni, cq;
+			long __ret;

-		fullpath = d_path(&f.file->f_path, pathbuf, PATH_MAX);
-		if (IS_ERR(fullpath)) {
-			goto out_free;
-		}
+			fd = packet->req.args[0];
+			f = fdget(fd);

-		if (!strncmp("/proc/tofu/dev/", fullpath, 15)) {
-			res->pde_data = PDE_DATA(file_inode(f.file));
-			dprintk("%s: fd: %d, path: %s, PDE_DATA: 0x%lx\n",
-					__func__,
-					fd,
-					fullpath,
-					(unsigned long)res->pde_data);
-			dprintk("%s: pgd_index: %ld, pmd_index: %ld, pte_index: %ld\n",
-				__func__,
-				pgd_index((unsigned long)res->pde_data),
-				pmd_index((unsigned long)res->pde_data),
-				pte_index((unsigned long)res->pde_data));
-#ifdef CONFIG_ARM64
-			dprintk("CONFIG_ARM64_VA_BITS: %d, PGDIR_SHIFT: %d\n",
-				CONFIG_ARM64_VA_BITS, PGDIR_SHIFT);
-#endif
-			mcctrl_file_to_pidfd_hash_insert(f.file, os,
-					task_tgid_vnr(current),
-					current->group_leader, fd);
-		}
+			if (!f.file) {
+				goto out_notify;
+			}

-out_free:
-		kfree(pathbuf);
-out_fdput:
-		fdput(f);
+			pathbuf = (char *)__get_free_page(GFP_ATOMIC);
+			if (!pathbuf) {
+				goto out_fdput_ioctl;
+			}
+
+			fullpath = d_path(&f.file->f_path, pathbuf, PAGE_SIZE);
+			if (IS_ERR(fullpath)) {
+				goto out_free_ioctl;
+			}
+
+			/* Looking for /proc/tofu/dev/tniXcqY pattern */
+			__ret = sscanf(fullpath, "/proc/tofu/dev/tni%dcq%d", &tni, &cq);
+			if (__ret == 2) {
+				extern long __mcctrl_tof_utofu_unlocked_ioctl_cq(void *pde_data,
+						unsigned int cmd, unsigned long arg);
+
+				dprintk("%s: ioctl(): fd: %d, path: %s\n",
+						__func__,
+						fd,
+						fullpath);
+
+				__ret = __mcctrl_tof_utofu_unlocked_ioctl_cq(
+						PDE_DATA(file_inode(f.file)),
+						packet->req.args[1], packet->req.args[2]);
+			}
+
+out_free_ioctl:
+			free_page((unsigned long)pathbuf);
+out_fdput_ioctl:
+			fdput(f);
+		}
 	}

 out_notify:
@ -2365,7 +2420,7 @@ int __do_in_kernel_irq_syscall(ihk_os_t os, struct ikc_scd_packet *packet)
 	if (ret == -ENOSYS)
 		return -ENOSYS;

-	__return_syscall(os, packet, ret, 0);
+	__return_syscall(os, NULL, packet, ret, 0);

 	return 0;
 }
@ -2590,7 +2645,7 @@ sched_setparam_out:
 		break;
 	}

-	__return_syscall(os, packet, ret, 0);
+	__return_syscall(os, NULL, packet, ret, 0);

 out_no_syscall_return:
 	ihk_ikc_release_packet((struct ihk_ikc_free_packet *)packet);
--- a/executer/user/mcexec.c
+++ b/executer/user/mcexec.c
@ -1957,14 +1957,14 @@ opendev()
 			fprintf(stderr, "%s: warning: LD_PRELOAD line is too long\n", __FUNCTION__); \
 			return; \
 		} \
-		strncat(envbuf, elembuf, remainder); \
+		strncat(envbuf, elembuf, remainder - 1); \
 		remainder = PATH_MAX - (strlen(envbuf) + 1); \
 		nelem++; \
 	} while (0)

 static ssize_t find_libdir(char *libdir, size_t len)
 {
-	FILE *filep;
+	FILE *filep = NULL;
 	ssize_t rc;
 	size_t linelen = 0;
 	char *line = NULL;
@ -2020,7 +2020,9 @@ static ssize_t find_libdir(char *libdir, size_t len)
 	}

 out:
-	pclose(filep);
+	if (filep) {
+		pclose(filep);
+	}
 	free(line);
 	return rc;
 }
@ -4121,6 +4123,7 @@ int main_loop(struct thread_data_s *my_thread)
 #endif

 		case __NR_gettid:{
+			int rc = 0;
 			/*
 			 * Number of TIDs and the remote physical address where TIDs are
 			 * expected are passed in arg 4 and 5, respectively.
@ -4132,6 +4135,7 @@ int main_loop(struct thread_data_s *my_thread)
 				int *tids = malloc(sizeof(int) * w.sr.args[4]);
 				if (!tids) {
 					fprintf(stderr, "__NR_gettid(): error allocating TIDs\n");
+					rc = -ENOMEM;
 					goto gettid_out;
 				}

@ -4152,13 +4156,14 @@ int main_loop(struct thread_data_s *my_thread)
 				trans.direction = MCEXEC_UP_TRANSFER_TO_REMOTE;

 				if (ioctl(fd, MCEXEC_UP_TRANSFER, &trans) != 0) {
+					rc = -EFAULT;
 					fprintf(stderr, "__NR_gettid(): error transfering TIDs\n");
 				}

 				free(tids);
 			}
 gettid_out:
-			do_syscall_return(fd, cpu, 0, 0, 0, 0, 0);
+			do_syscall_return(fd, cpu, rc, 0, 0, 0, 0);
 			break;
 		}

--- a/2
+++ b/2
--- a/kernel/ap.c
+++ b/kernel/ap.c
@ -267,3 +267,154 @@ cpu_sysfs_setup(void)

 	return;
 } /* cpu_sysfs_setup() */
+
+/*
+ * Generic remote CPU function invocation facility.
+ */
+void smp_func_call_handler(void)
+{
+	unsigned long irq_flags;
+	struct smp_func_call_request *req;
+	int reqs_left;
+
+reiterate:
+	req = NULL;
+	reqs_left = 0;
+
+	irq_flags = ihk_mc_spinlock_lock(
+			&cpu_local_var(smp_func_req_lock));
+
+	/* Take requests one-by-one */
+	if (!list_empty(&cpu_local_var(smp_func_req_list))) {
+		req = list_first_entry(&cpu_local_var(smp_func_req_list),
+			struct smp_func_call_request, list);
+		list_del(&req->list);
+
+		reqs_left = !list_empty(&cpu_local_var(smp_func_req_list));
+	}
+
+	ihk_mc_spinlock_unlock(&cpu_local_var(smp_func_req_lock),
+			irq_flags);
+
+	if (req) {
+		req->ret = req->sfcd->func(req->cpu_index,
+				req->sfcd->nr_cpus, req->sfcd->arg);
+		ihk_atomic_dec(&req->sfcd->cpus_left);
+	}
+
+	if (reqs_left)
+		goto reiterate;
+}
+
+int smp_call_func(cpu_set_t *__cpu_set, smp_func_t __func, void *__arg)
+{
+	int cpu, nr_cpus = 0;
+	int cpu_index = 0;
+	int this_cpu_index = 0;
+	struct smp_func_call_data sfcd;
+	struct smp_func_call_request *reqs;
+	int ret = 0;
+	int call_on_this_cpu = 0;
+	cpu_set_t cpu_set;
+	int max_nr_cpus = 4;
+
+	/* Sanity checks */
+	if (!__cpu_set || !__func) {
+		return -EINVAL;
+	}
+
+	/* Make sure it won't change in between */
+	cpu_set = *__cpu_set;
+
+	for_each_set_bit(cpu, (unsigned long *)&cpu_set,
+			sizeof(cpu_set) * BITS_PER_BYTE) {
+
+		if (cpu == ihk_mc_get_processor_id()) {
+			call_on_this_cpu = 1;
+		}
+		++nr_cpus;
+
+		if (nr_cpus == max_nr_cpus)
+			break;
+	}
+
+	if (!nr_cpus) {
+		return -EINVAL;
+	}
+
+	reqs = kmalloc(sizeof(*reqs) * nr_cpus, IHK_MC_AP_NOWAIT);
+	if (!reqs) {
+		ret = -ENOMEM;
+		goto free_out;
+	}
+
+	kprintf("%s: interrupting %d CPUs for SMP call..\n", __func__, nr_cpus);
+	sfcd.nr_cpus = nr_cpus;
+	sfcd.func = __func;
+	sfcd.arg = __arg;
+	ihk_atomic_set(&sfcd.cpus_left,
+			call_on_this_cpu ? nr_cpus - 1 : nr_cpus);
+	smp_wmb();
+
+	/* Add requests and send IPIs */
+	cpu_index = 0;
+	for_each_set_bit(cpu, (unsigned long *)&cpu_set,
+			sizeof(cpu_set) * BITS_PER_BYTE) {
+		unsigned long irq_flags;
+
+		reqs[cpu_index].cpu_index = cpu_index;
+		reqs[cpu_index].ret = 0;
+
+		if (cpu == ihk_mc_get_processor_id()) {
+			this_cpu_index = cpu_index;
+			++cpu_index;
+			continue;
+		}
+
+		reqs[cpu_index].sfcd = &sfcd;
+
+		irq_flags =
+			ihk_mc_spinlock_lock(&get_cpu_local_var(cpu)->smp_func_req_lock);
+		list_add_tail(&reqs[cpu_index].list,
+				&get_cpu_local_var(cpu)->smp_func_req_list);
+		ihk_mc_spinlock_unlock(&get_cpu_local_var(cpu)->smp_func_req_lock,
+			irq_flags);
+
+		dkprintf("%s: interrupting IRQ: %d -> CPU: %d\n", __func__,
+			ihk_mc_get_smp_handler_irq(), cpu);
+		ihk_mc_interrupt_cpu(cpu, ihk_mc_get_smp_handler_irq());
+
+		++cpu_index;
+		if (cpu_index == max_nr_cpus)
+			break;
+	}
+
+	/* Is this CPU involved? */
+	if (call_on_this_cpu) {
+		reqs[this_cpu_index].ret =
+			__func(this_cpu_index, nr_cpus, __arg);
+	}
+
+	dkprintf("%s: waiting for remote CPUs..\n", __func__);
+	/* Wait for the rest of the CPUs */
+	while (smp_load_acquire(&sfcd.cpus_left.counter) > 0) {
+		cpu_pause();
+	}
+
+	/* Check return values, if error, report the first non-zero */
+	for (cpu_index = 0; cpu_index < nr_cpus; ++cpu_index) {
+		if (reqs[cpu_index].ret != 0) {
+			ret = reqs[cpu_index].ret;
+			goto free_out;
+		}
+	}
+
+	kprintf("%s: all CPUs finished SMP call successfully\n", __func__);
+	ret = 0;
+
+free_out:
+	kfree(reqs);
+
+	return ret;
+}
+
--- a/kernel/include/cls.h
+++ b/kernel/include/cls.h
@ -106,9 +106,7 @@ struct cpu_local_var {
 	ihk_spinlock_t migq_lock;
 	struct list_head migq;
 	int in_interrupt;
-#ifdef ENABLE_FUGAKU_HACKS
 	int in_page_fault;
-#endif
 	int no_preempt;
 	int timer_enabled;
 	unsigned long nr_ctx_switches;
--- a/kernel/include/process.h
+++ b/kernel/include/process.h
@ -406,6 +406,7 @@ struct vm_range_numa_policy {
 	unsigned long start, end;
 	DECLARE_BITMAP(numa_mask, PROCESS_NUMA_MASK_BITS);
 	int numa_mem_policy;
+	int il_prev;
 };

 struct vm_regions {
@ -797,6 +798,7 @@ struct process_vm {
 	long currss;
 	DECLARE_BITMAP(numa_mask, PROCESS_NUMA_MASK_BITS);
 	int numa_mem_policy;
+	int il_prev;
 	/* Protected by memory_range_lock */
 	struct rb_root vm_range_numa_policy_tree;
 	struct vm_range *range_cache[VM_RANGE_CACHE_SIZE];
--- a/kernel/include/tofu/generate_headers.sh
+++ b/kernel/include/tofu/generate_headers.sh
@ -6,10 +6,25 @@ CURRENT_DIR=`pwd`

 cd ${SCRIPT_DIR}

-DWARF_TOOL=~/src/mckernel-apollo+a64fx/mckernel/tools/dwarf-extract-struct/dwarf-extract-struct
+DWARF_TOOL=${SCRIPT_DIR}/../../../tools/dwarf-extract-struct/dwarf-extract-struct
+if [ ! -x ${DWARF_TOOL} ]; then
+	echo "error: couldn't find DWARF extractor executable (${DWARF_TOOL}), have you compiled it?"
+	cd -
+	exit 1
+fi
+
+echo "Looking for Tofu driver debug symbols..."
+if [ "`find /lib/modules/ -name "tof_module.tar.gz" | xargs -r ls -t | head -n 1 | wc -l`" == "0" ]; then
+	echo "error: couldn't find Tofu modules with debug symbols"
+	cd -
+	exit 1
+fi
+
+MODULE_TAR_GZ=`find /lib/modules/ -name "tof_module.tar.gz" | xargs ls -t | head -n 1`
+echo "Using Tofu driver debug symbols: ${MODULE_TAR_GZ}"

 KMODULE=tof_utofu.ko 
-if ! tar zxvf /lib/modules/`uname -r`+debug/extra/tof_module.tar.gz ${KMODULE} 2>&1 > /dev/null; then
+if ! tar zxvf ${MODULE_TAR_GZ} ${KMODULE} 2>&1 > /dev/null; then
 	echo "error: uncompressing kernel module with debug symbols"
 	cd -
 	exit 1
@ -22,7 +37,7 @@ ${DWARF_TOOL} ${KMODULE} tof_utofu_bg common tni bgid bch | sed "s/struct FILL_I
 rm ${KMODULE}

 KMODULE=tof_core.ko 
-if ! tar zxvf /lib/modules/`uname -r`+debug/extra/tof_module.tar.gz ${KMODULE} 2>&1 > /dev/null; then
+if ! tar zxvf ${MODULE_TAR_GZ} ${KMODULE} 2>&1 > /dev/null; then
 	echo "error: uncompressing kernel module with debug symbols"
 	cd -
 	exit 1
@ -33,4 +48,4 @@ ${DWARF_TOOL} ${KMODULE} tof_core_bg lock reg irq subnet gpid sighandler | sed "
 rm ${KMODULE}

 #cat tofu_generated*.h
-cd -
+cd - > /dev/null
--- a/kernel/mem.c
+++ b/kernel/mem.c
@ -523,6 +523,18 @@ static void reserve_pages(struct ihk_page_allocator_desc *pa_allocator,
 	ihk_pagealloc_reserve(pa_allocator, start, end);
 }

+static int interleave_nodes(int off, unsigned long *numa_mask)
+{
+	int next;
+
+	next = find_next_bit(numa_mask, PROCESS_NUMA_MASK_BITS, off + 1);
+	if (next >= PROCESS_NUMA_MASK_BITS) {
+		next = find_first_bit(numa_mask, PROCESS_NUMA_MASK_BITS);
+	}
+
+	return next;
+}
+
 extern int cpu_local_var_initialized;
 static void *mckernel_allocate_aligned_pages_node(int npages, int p2align,
 		ihk_mc_ap_flag flag, int pref_node, int is_user, uintptr_t virt_addr)
@ -538,7 +550,9 @@ static void *mckernel_allocate_aligned_pages_node(int npages, int p2align,
 	int numa_mem_policy = -1;
 	struct process_vm *vm;
 	struct vm_range *range = NULL;
-	int chk_shm = 0;
+	int chk_shm = 0, il_start, looping;
+	int *il_prev = NULL;
+	unsigned long *numa_mask = NULL;

 	if(npages <= 0)
 		return NULL;
@ -549,31 +563,39 @@ static void *mckernel_allocate_aligned_pages_node(int npages, int p2align,
 			!cpu_local_var(current)->vm)
 		goto distance_based;

-	/* No explicitly requested NUMA or user policy? */
-	if ((pref_node == -1) && (!(flag & IHK_MC_AP_USER) ||
-				cpu_local_var(current)->vm->numa_mem_policy == MPOL_DEFAULT)) {
+	vm = cpu_local_var(current)->vm;
+	node = ihk_mc_get_numa_id();

-		if (virt_addr != -1) {
-			vm = cpu_local_var(current)->vm;
-			range_policy_iter = vm_range_policy_search(vm, virt_addr);
-			if (range_policy_iter) {
-				range = lookup_process_memory_range(vm, (uintptr_t)virt_addr, ((uintptr_t)virt_addr) + 1);
-				if (range) {
-					if( (range->memobj) && (range->memobj->flags == MF_SHM)) {
-						chk_shm = 1;
-					}
-				}
+	/* Get mempolicy user requested */
+	if (virt_addr != -1) {
+		range_policy_iter = vm_range_policy_search(vm, virt_addr);
+
+		if (range_policy_iter) {
+			range = lookup_process_memory_range(vm,
+					(uintptr_t)virt_addr,
+					((uintptr_t)virt_addr) + 1);
+			if ((range && (range->memobj->flags == MF_SHM))) {
+				chk_shm = 1;
 			}
+
+			/* Use range policy */
+			numa_mem_policy = range_policy_iter->numa_mem_policy;
+			numa_mask = range_policy_iter->numa_mask;
+			il_prev = &range_policy_iter->il_prev;
+		} else {
+			/* Use process policy */
+			numa_mem_policy = vm->numa_mem_policy;
+			numa_mask = vm->numa_mask;
+			il_prev = &vm->il_prev;
 		}
-
-
-		if ((!((range_policy_iter) && (range_policy_iter->numa_mem_policy != MPOL_DEFAULT))) && (chk_shm == 0))
-			goto distance_based;
 	}

-	node = ihk_mc_get_numa_id();
-	if (!memory_nodes[node].nodes_by_distance)
-		goto order_based;
+	/* No explicitly requested NUMA or user policy? */
+	if ((pref_node == -1) && !(flag & IHK_MC_AP_USER)) {
+		if ((numa_mem_policy == MPOL_DEFAULT) && (chk_shm == 0)) {
+			goto distance_based;
+		}
+	}

 	/* Explicit valid node? */
 	if (pref_node > -1 && pref_node < ihk_mc_get_nr_numa_nodes()) {
@ -615,27 +637,6 @@ static void *mckernel_allocate_aligned_pages_node(int npages, int p2align,
 		}
 	}

-	if ((virt_addr != -1) && (chk_shm == 0)) {
-
-		vm = cpu_local_var(current)->vm;
-
-		if (!(range_policy_iter)) {
-			range_policy_iter = vm_range_policy_search(vm, virt_addr);
-		}
-
-		if (range_policy_iter) {
-			range = lookup_process_memory_range(vm, (uintptr_t)virt_addr, ((uintptr_t)virt_addr) + 1);
-			if ((range && (range->memobj->flags == MF_SHM))) {
-				chk_shm = 1;
-			} else {
-				numa_mem_policy = range_policy_iter->numa_mem_policy;
-			}
-		}
-	}
-
-	if (numa_mem_policy == -1)
-		numa_mem_policy = cpu_local_var(current)->vm->numa_mem_policy;
-
 	switch (numa_mem_policy) {
 		case MPOL_BIND:
 		case MPOL_PREFERRED:
@ -644,9 +645,8 @@ static void *mckernel_allocate_aligned_pages_node(int npages, int p2align,
 			 * only the ones requested in user policy */
 			for (i = 0; i < ihk_mc_get_nr_numa_nodes(); ++i) {

-				/* Not part of user requested policy? */
 				if (!test_bit(memory_nodes[node].nodes_by_distance[i].id,
-						cpu_local_var(current)->proc->vm->numa_mask)) {
+						numa_mask)) {
 					continue;
 				}

@ -687,7 +687,55 @@ static void *mckernel_allocate_aligned_pages_node(int npages, int p2align,
 			break;

 		case MPOL_INTERLEAVE:
-			/* TODO: */
+			/* Initialize interleave */
+			il_start = *il_prev;
+			looping = 0;
+
+retry_interleave:
+			/* Find next node */
+			numa_id = interleave_nodes(*il_prev, numa_mask);
+			*il_prev = numa_id;
+
+			if (il_start == *il_prev && looping) {
+				/* All interleave nodes are full */
+				pa = 0;
+				break;
+			}
+			looping = 1;
+#ifdef IHK_RBTREE_ALLOCATOR
+			{
+				if (rusage_check_oom(numa_id, npages, is_user)
+						== -ENOMEM) {
+					goto retry_interleave;
+				} else {
+					pa = ihk_numa_alloc_pages(
+							&memory_nodes[numa_id],
+							npages, p2align);
+				}
+#else
+			list_for_each_entry(pa_allocator,
+					&memory_nodes[numa_id].allocators,
+					list) {
+				if (rusage_check_oom(numa_id, npages, is_user)
+						== -ENOMEM) {
+					goto retry_interleave;
+				} else {
+					pa = ihk_pagealloc_alloc(pa_allocator,
+							npages, p2align);
+				}
+#endif
+
+				if (pa) {
+					rusage_page_add(numa_id, npages,
+							is_user);
+					dkprintf("%s: policy: CPU @ node %d allocated "
+							"%d pages from node %d\n",
+							__func__,
+							ihk_mc_get_numa_id(),
+							npages, node);
+
+				}
+			}
 			break;

 		default:
@ -1395,7 +1443,6 @@ static void page_fault_handler(void *fault_addr, uint64_t reason, void *regs)
 			__FUNCTION__, fault_addr, reason, regs);

 	preempt_disable();
-#ifdef ENABLE_FUGAKU_HACKS
 	++cpu_local_var(in_page_fault);
 	if (cpu_local_var(in_page_fault) > 1) {
 		kprintf("%s: PF in PF??\n", __func__);
@ -1408,7 +1455,6 @@ static void page_fault_handler(void *fault_addr, uint64_t reason, void *regs)
 			panic("PANIC");
 		}
 	}
-#endif

 	cpu_enable_interrupt();

@ -1475,6 +1521,7 @@ out_linux:
 			__func__, thread ? thread->tid : -1, fault_addr,
 			reason, error);
 		unhandled_page_fault(thread, fault_addr, reason, regs);
+		--cpu_local_var(in_page_fault);
 		preempt_enable();

 #ifdef ENABLE_FUGAKU_DEBUG
@ -1511,9 +1558,7 @@ out_linux:
 out_ok:
 #endif
 	error = 0;
-#ifdef ENABLE_FUGAKU_HACKS
 	--cpu_local_var(in_page_fault);
-#endif
 	preempt_enable();
 out:
 	dkprintf("%s: addr: %p, reason: %lx, regs: %p -> error: %d\n",
@ -2885,3 +2930,44 @@ retry:

 	return ptep;
 }
+
+int phys_to_nid(unsigned long p)
+{
+   int i, numa_id = -1, _numa_id;
+   unsigned long _start, _end;
+
+   for (i = 0; i < ihk_mc_get_nr_memory_chunks(); i++) {
+	   ihk_mc_get_memory_chunk(i, &_start, &_end, &_numa_id);
+
+	   if (p >= _start && p < _end) {
+		   numa_id = _numa_id;
+		   goto out;
+	   }
+   }
+
+out:
+   return numa_id;
+}
+
+int lookup_node(struct process_vm *vm, void *addr)
+{
+	int node, err, reason = PF_POPULATE | PF_USER;
+	pte_t *ptep;
+
+	err = page_fault_process_vm(vm, (void *)addr, reason);
+	if (err) {
+		node = err;
+		goto out;
+	}
+
+	ptep = ihk_mc_pt_lookup_pte(vm->address_space->page_table,
+			(void *)addr, 0, NULL, NULL, NULL);
+	if (!ptep || !pte_is_present(ptep)) {
+		node = -ENOENT;
+		goto out;
+	}
+
+	node = phys_to_nid(pte_get_phys(ptep));
+out:
+	return node;
+}
--- a/kernel/process.c
+++ b/kernel/process.c
@ -833,6 +833,8 @@ static int copy_user_ranges(struct process_vm *vm, struct process_vm *orgvm)
 		range->objoff = src_range->objoff;
 		range->pgshift = src_range->pgshift;
 		range->private_data = src_range->private_data;
+		range->straight_start = src_range->straight_start;
+
 		if (range->memobj) {
 			memobj_ref(range->memobj);
 		}
@ -965,8 +967,18 @@ int split_process_memory_range(struct process_vm *vm, struct vm_range *range,
 	newrange->private_data = range->private_data;

 #ifdef ENABLE_TOFU
-	/* TODO: figure out which entries to put on which list! */
 	INIT_LIST_HEAD(&newrange->tofu_stag_list);
+	{
+		extern int tofu_stag_split_vm_range_on_addr(struct process_vm *vm,
+				struct vm_range *range_low, struct vm_range *range_high,
+				uintptr_t addr);
+
+		int moved =
+			tofu_stag_split_vm_range_on_addr(vm, range, newrange, addr);
+		if (moved > 0) {
+			kprintf("%s: moved %d stag ranges\n", __func__, moved);
+		}
+	}
 #endif

 	if (range->memobj) {
@ -1182,7 +1194,7 @@ straight_out:

 		entries = tofu_stag_range_remove_overlapping(vm, range);
 		if (entries > 0) {
-			kprintf("%s: removed %d Tofu stag entries for range 0x%lx:%lu\n",
+			dkprintf("%s: removed %d Tofu stag entries for range 0x%lx:%lu\n",
 				__func__,
 				entries,
 				range->start,
--- a/kernel/syscall.c
+++ b/kernel/syscall.c
@ -9676,7 +9676,9 @@ SYSCALL_DECLARE(mbind)
 		return -EINVAL;
 	}

+#ifdef ENABLE_FUGAKU_HACKS
 	return 0;
+#endif

 	memset(numa_mask, 0, sizeof(numa_mask));

@ -9921,6 +9923,10 @@ mbind_update_only:
 					sizeof(numa_mask));
 			}
 			range_policy->numa_mem_policy = mode;
+			if (mode == MPOL_INTERLEAVE) {
+				range_policy->il_prev =
+						PROCESS_NUMA_MASK_BITS - 1;
+			}

 			break;

@ -10082,6 +10088,9 @@ SYSCALL_DECLARE(set_mempolicy)
 			}

 			vm->numa_mem_policy = mode;
+			if (mode == MPOL_INTERLEAVE) {
+				vm->il_prev = PROCESS_NUMA_MASK_BITS - 1;
+			}
 			error = 0;
 			break;

@ -10144,6 +10153,20 @@ SYSCALL_DECLARE(get_mempolicy)
 		}
 	}

+	/* case of MPOL_F_NODE and MPOL_F_ADDR are specified */
+	if (flags & MPOL_F_NODE && flags & MPOL_F_ADDR) {
+		/* return the node ID which addr is allocated by mode */
+		int nid;
+
+		nid = lookup_node(vm, (void *)addr);
+		error = copy_to_user(mode, &nid, sizeof(int));
+		if (error) {
+			error = -EFAULT;
+			goto out;
+		}
+		goto out;
+	}
+
 	/* Special case of MPOL_F_MEMS_ALLOWED */
 	if (flags == MPOL_F_MEMS_ALLOWED) {
 		if (nodemask) {
@ -10227,7 +10250,7 @@ SYSCALL_DECLARE(move_pages)
 	struct move_pages_smp_req mpsr;

 	struct process_vm *vm = cpu_local_var(current)->vm;
-	int ret = 0;
+	int i, ret = 0;

 	unsigned long t_s, t_e;

@ -10237,18 +10260,20 @@ SYSCALL_DECLARE(move_pages)
 	if (pid) {
 		kprintf("%s: ERROR: only self (pid == 0)"
 				" is supported\n", __FUNCTION__);
-		return -EINVAL;
+		ret = -EINVAL;
+		goto out;
 	}

-	switch (flags) {
-	case MPOL_MF_MOVE_ALL:
+    /* Check flags */
+	if (flags & ~(MPOL_MF_MOVE|MPOL_MF_MOVE_ALL)) {
+		ret = -EINVAL;
+		goto out;
+	}
+	if (flags & MPOL_MF_MOVE_ALL) {
 		kprintf("%s: ERROR: MPOL_MF_MOVE_ALL"
 			" not supported\n", __func__);
-		return -EINVAL;
-	case MPOL_MF_MOVE:
-		break;
-	default:
-		return -EINVAL;
+		ret = -EINVAL;
+		goto out;
 	}

 	/* Allocate kernel arrays */
@ -10296,7 +10321,7 @@ t_e = rdtsc(); kprintf("%s: init malloc: %lu \n", __FUNCTION__, t_e - t_s); t_s
 		goto dealloc_out;
 	}

-	if (verify_process_vm(cpu_local_var(current)->vm,
+	if (user_nodes && verify_process_vm(cpu_local_var(current)->vm,
 				user_nodes, sizeof(int) * count)) {
 		ret = -EFAULT;
 		goto dealloc_out;
@ -10307,6 +10332,18 @@ t_e = rdtsc(); kprintf("%s: init malloc: %lu \n", __FUNCTION__, t_e - t_s); t_s
 		ret = -EFAULT;
 		goto dealloc_out;
 	}
+
+	/* Check node ID */
+	if (user_nodes) {
+		copy_from_user(nodes, user_nodes, sizeof(int) * count);
+		for (i = 0; i < count; i++) {
+			if (nodes[i] < 0 || nodes[i] >= ihk_mc_get_nr_numa_nodes()) {
+				ret = -ENODEV;
+				goto dealloc_out;
+			}
+		}
+	}
+
 t_e = rdtsc(); kprintf("%s: init verify: %lu \n", __FUNCTION__, t_e - t_s); t_s = t_e;

 #if 0
@ -10399,6 +10436,7 @@ dealloc_out:
 	kfree(ptep);
 	kfree(dst_phys);

+out:
 	return ret;
 }

--- a/kernel/tofu/tof_utofu_main.c
+++ b/kernel/tofu/tof_utofu_main.c
@ -160,6 +160,83 @@ int tofu_stag_range_remove_overlapping(struct process_vm *vm,
 	return entries;
 }

+void tofu_stag_range_remove_by_addr(struct process_vm *vm,
+	uintptr_t addr, size_t len)
+{
+	struct tofu_stag_range *tsr, *next;
+	int hash;
+
+	ihk_mc_spinlock_lock_noirq(&vm->tofu_stag_lock);
+	for (hash = 0; hash < TOFU_STAG_HASH_SIZE; ++hash) {
+		list_for_each_entry_safe(tsr, next,
+				&vm->tofu_stag_hash[hash], hash) {
+
+			if (tsr->start >= addr && tsr->end <= (addr + len)) {
+				linux_spin_lock(&tsr->ucq->trans.mru_lock);
+				tof_utofu_free_stag(tsr->ucq, tsr->stag);
+				linux_spin_unlock(&tsr->ucq->trans.mru_lock);
+
+				kprintf("%s: removed stag %d in %p:%lu\n",
+						__func__, tsr->stag, addr, len);
+				__tofu_stag_range_remove(vm, tsr);
+			}
+
+			{
+				uintptr_t max_start, min_end;
+
+				max_start = addr > tsr->start ? addr : tsr->start;
+				min_end = (addr + len) < tsr->end ? (addr + len) : tsr->end;
+
+				if ((tsr->start != 0 || vm->proc->status == PS_EXITED) &&
+						(max_start < min_end)) {
+					linux_spin_lock(&tsr->ucq->trans.mru_lock);
+					tof_utofu_free_stag(tsr->ucq, tsr->stag);
+					linux_spin_unlock(&tsr->ucq->trans.mru_lock);
+
+					kprintf("%s: removed stag %p:%lu (overlaps with range %p:%lu)\n",
+						__func__, tsr->start, (tsr->end - tsr->start), addr, len);
+					__tofu_stag_range_remove(vm, tsr);
+				}
+			}
+		}
+	}
+	ihk_mc_spinlock_unlock_noirq(&vm->tofu_stag_lock);
+}
+
+int tofu_stag_split_vm_range_on_addr(struct process_vm *vm,
+		struct vm_range *range_low, struct vm_range *range_high,
+		uintptr_t addr)
+{
+	struct tofu_stag_range *tsr, *next;
+	int moved = 0;
+
+	ihk_mc_spinlock_lock_noirq(&vm->tofu_stag_lock);
+
+	list_for_each_entry_safe(tsr, next,
+			&range_low->tofu_stag_list, list) {
+
+		if (tsr->start >= addr) {
+			list_del(&tsr->list);
+			list_add_tail(&tsr->list, &range_high->tofu_stag_list);
+			++moved;
+
+			kprintf("%s: stag: %d @ %p:%lu moved to high range..\n",
+					__func__,
+					tsr->stag,
+					tsr->start,
+					(unsigned long)(tsr->end - tsr->start));
+		}
+
+		if (tsr->start < addr && tsr->end > addr) {
+			kprintf("%s: WARNING: VM range split in middle of stag range..\n", __func__);
+		}
+	}
+
+	ihk_mc_spinlock_unlock_noirq(&vm->tofu_stag_lock);
+
+	return moved;
+}
+


 #define TOF_UTOFU_VERSION TOF_UAPI_VERSION
@ -1159,6 +1236,7 @@ static int tof_utofu_ioctl_alloc_stag(struct tof_utofu_device *dev, unsigned lon

 	readonly = (req.flags & 1) != 0;

+retry:
 	ihk_rwspinlock_read_lock_noirq(&vm->memory_range_lock);

 	/* Assume smallest page size at first */
@ -1194,6 +1272,20 @@ static int tof_utofu_ioctl_alloc_stag(struct tof_utofu_device *dev, unsigned lon
 	}

 	if (!range) {
+		if (vm->region.stack_start <= start &&
+				vm->region.stack_end > end) {
+
+			ihk_rwspinlock_read_unlock_noirq(&vm->memory_range_lock);
+
+			if (page_fault_process_vm(vm, (void *)start,
+						PF_POPULATE | PF_WRITE | PF_USER) < 0) {
+				ret = -EINVAL;
+				goto out;
+			}
+
+			goto retry;
+		}
+
 		ret = -EINVAL;
 		goto unlock_out;
 	}
@ -1281,6 +1373,7 @@ static int tof_utofu_ioctl_alloc_stag(struct tof_utofu_device *dev, unsigned lon
 unlock_out:
 	ihk_rwspinlock_read_unlock_noirq(&vm->memory_range_lock);

+out:
 	if(ret == 0){
 		if(copy_to_user((void *)arg, &req, sizeof(req)) != 0){
 			kprintf("%s: ret: %d\n", __func__, -EFAULT);
@ -1463,7 +1556,8 @@ static int tof_utofu_free_stag(struct tof_utofu_cq *ucq, int stag){
 #endif // PROFILE_ENABLE
 	kref_put(&ucq->trans.mru[stag].mbpt->kref, tof_utofu_mbpt_release);
 	ucq->trans.mru[stag].mbpt = NULL;
-	dkprintf("%s: stag: %d deallocated\n", __func__, stag);
+	dkprintf("%s: TNI: %d, CQ: %d, STAG: %d deallocated\n",
+			__func__, ucq->tni, ucq->cqid, stag);
 #ifdef PROFILE_ENABLE
 	profile_event_add(PROFILE_tofu_stag_free_stag_dealloc, rdtsc() - ts_rolling);
 	profile_event_add(PROFILE_tofu_stag_free_stag, rdtsc() - ts);
@ -1486,7 +1580,7 @@ static int tof_utofu_ioctl_free_stags(struct tof_utofu_device *dev, unsigned lon
 		return -EFAULT;
 	}
 	//tof_log_if("[IN] tni=%d cqid=%d num=%u stags=%p\n", ucq->tni, ucq->cqid, req.num, req.stags);
-	dkprintf("%: [IN] tni=%d cqid=%d num=%u stags=%p\n",
+	dkprintf("%s: [IN] tni=%d cqid=%d num=%u stags=%p\n",
 			__func__, ucq->tni, ucq->cqid, req.num, req.stags);

 	if(req.num > 1024 || req.stags == NULL){
@ -1559,10 +1653,8 @@ static int tof_utofu_ioctl_free_stags(struct tof_utofu_device *dev, unsigned lon
 void tof_utofu_release_cq(void *pde_data)
 {
 	struct tof_utofu_cq *ucq;
-	//int stag;
 	struct tof_utofu_device *dev;
 	unsigned long irqflags;
-	struct process_vm *vm = cpu_local_var(current)->vm;
 	int do_free = 1;

 	dev = (struct tof_utofu_device *)pde_data;
@ -1574,15 +1666,10 @@ void tof_utofu_release_cq(void *pde_data)
 		do_free = 0;
 	}

-#if 0
-	for (stag = 0; stag < TOF_UTOFU_NUM_STAG(ucq->num_stag); stag++) {
-		linux_spin_lock_irqsave(&ucq->trans.mru_lock, irqflags);
-		tof_utofu_free_stag(ucq, stag);
-		linux_spin_unlock_irqrestore(&ucq->trans.mru_lock, irqflags);
-#endif
 	{
 		int i;
 		struct tofu_stag_range *tsr, *next;
+		struct process_vm *vm = cpu_local_var(current)->vm;

 		ihk_mc_spinlock_lock_noirq(&vm->tofu_stag_lock);
 		for (i = 0; i < TOFU_STAG_HASH_SIZE; ++i) {
@ -1610,6 +1697,17 @@ void tof_utofu_release_cq(void *pde_data)
 		ihk_mc_spinlock_unlock_noirq(&vm->tofu_stag_lock);
 	}

+	/* Loop through as well just to make sure everything is cleaned up */
+	if (do_free) {
+		int stag;
+
+		for (stag = 0; stag < TOF_UTOFU_NUM_STAG(ucq->num_stag); stag++) {
+			linux_spin_lock_irqsave(&ucq->trans.mru_lock, irqflags);
+			tof_utofu_free_stag(ucq, stag);
+			linux_spin_unlock_irqrestore(&ucq->trans.mru_lock, irqflags);
+		}
+	}
+
 	dkprintf("%s: UCQ (pde: %p) TNI %d, CQ %d\n",
 		__func__, pde_data, ucq->tni, ucq->cqid);
 }
@ -2356,9 +2454,10 @@ void tof_utofu_finalize(void)
 			list_for_each_entry_safe(tsr, next,
 					&vm->tofu_stag_hash[i], hash) {

-				dkprintf("%s: WARNING: stray stag %d for TNI %d CQ %d?\n",
-						__func__, tsr->stag, tsr->ucq->tni, tsr->ucq->cqid);
-
+				dkprintf("%s: WARNING: stray stag %d (%p:%lu) for TNI %d CQ %d?\n",
+						__func__, tsr->stag,
+						tsr->start, tsr->end - tsr->start,
+						tsr->ucq->tni, tsr->ucq->cqid);
 			}
 		}
 		kprintf("%s: STAG processing done\n", __func__);
--- a/kernel/xpmem.c
+++ b/kernel/xpmem.c
@ -2056,6 +2056,7 @@ static int xpmem_pin_page(

 	XPMEM_DEBUG("call: tgid=%d, vaddr=0x%lx", tg->tgid, vaddr);

+retry:
 	ihk_rwspinlock_read_lock_noirq(&src_vm->memory_range_lock);

 	range = lookup_process_memory_range(src_vm, vaddr, vaddr + 1);
@ -2063,6 +2064,20 @@ static int xpmem_pin_page(
 	ihk_rwspinlock_read_unlock_noirq(&src_vm->memory_range_lock);

 	if (!range || range->start > vaddr) {
+		/*
+		 * Grow the stack if address falls into stack region
+		 * so that we can lookup range successfully.
+		 */
+		if (src_vm->region.stack_start <= vaddr &&
+				src_vm->region.stack_end > vaddr) {
+			if (page_fault_process_vm(src_vm, (void *)vaddr,
+						PF_POPULATE | PF_WRITE | PF_USER) < 0) {
+				return -ENOENT;
+			}
+
+			goto retry;
+		}
+
 		return -ENOENT;
 	}

--- a/lib/include/ihk/cpu.h
+++ b/lib/include/ihk/cpu.h
@ -173,4 +173,7 @@ struct cpu_mapping;
 int arch_get_cpu_mapping(struct cpu_mapping **buf, int *nelemsp);
 int ihk_mc_ikc_arch_issue_host_ipi(int cpu, int vector);

+void smp_func_call_handler(void);
+int ihk_mc_get_smp_handler_irq(void);
+
 #endif
--- a/lib/include/memory.h
+++ b/lib/include/memory.h
@ -20,6 +20,8 @@ struct process_vm;

 unsigned long virt_to_phys(void *v);
 void *phys_to_virt(unsigned long p);
+int phys_to_nid(unsigned long p);
+int lookup_node(struct process_vm *vm, void *addr);
 int copy_from_user(void *dst, const void *src, size_t siz);
 int strlen_user(const char *s);
 int strcpy_from_user(char *dst, const char *src);
--- a/scripts/mckernel.spec.in
+++ b/scripts/mckernel.spec.in
@ -25,9 +25,17 @@ Source0: mckernel-%{version}.tar.gz

 Requires: systemd-libs numactl-libs libdwarf

-# kernel_module_package macro does not handle cross build...
+# don't use kernel_module_package so that one rpm including .ko and binaries are created
 %if "%{?_host_cpu}" == "x86_64" && "%{?_target_cpu}" == "aarch64"
 %define cross_compile 1
+%else
+BuildRequires: systemd-devel numactl-devel binutils-devel kernel-devel libdwarf-devel
+# Friendly reminder of the fact that kernel-rpm-macros is no longer included in kernel-devel
+%if 0%{?rhel} >= 8
+BuildRequires: redhat-rpm-config kernel-rpm-macros elfutils-libelf-devel
+%endif
+%endif
+
 %if 0%{?rhel} >= 8
 Requires: kernel >= %{krequires}
 %else
@ -35,17 +43,6 @@ Requires: kernel = %{krequires}
 %endif
 Requires(post):   /usr/sbin/depmod
 Requires(postun): /usr/sbin/depmod
-%else
-BuildRequires: systemd-devel numactl-devel binutils-devel kernel-devel libdwarf-devel
-# Friendly reminder of the fact that kernel-rpm-macros is no longer included in kernel-devel
-%if 0%{?rhel} >= 8
-BuildRequires: redhat-rpm-config kernel-rpm-macros elfutils-libelf-devel kmod
-%endif
-%if %{defined kernel_module_package_buildreqs}
-BuildRequires: %kernel_module_package_buildreqs
-%kernel_module_package %{?kmod_flavors}
-%endif
-%endif

 %description
 Interface for Heterogeneous Kernels and McKernel.
@ -78,6 +75,9 @@ This package contains headers and libraries required for build apps using IHK/Mc
 	%{?cmake_libdir:-DCMAKE_INSTALL_LIBDIR=%{cmake_libdir}} \
 	%{?build_target:-DBUILD_TARGET=%{build_target}} \
 	%{?toolchain_file:-DCMAKE_TOOLCHAIN_FILE=%{toolchain_file}} \
+	-DENABLE_TOFU=ON -DENABLE_FUGAKU_HACKS=ON \
+	-DENABLE_KRM_WORKAROUND=OFF -DWITH_KRM=ON \
+	-DENABLE_FUGAKU_DEBUG=OFF \
 	.
 %make_build

@ -113,7 +113,6 @@ This package contains headers and libraries required for build apps using IHK/Mc
 %{_mandir}/man1/ihkosctl.1.gz
 %{_mandir}/man1/mcexec.1.gz

-%if 0%{?cross_compile}
 /lib/modules/%{kernel_version}/extra/mckernel/ihk.ko
 /lib/modules/%{kernel_version}/extra/mckernel/mcctrl.ko
 %ifarch x86_64
@ -122,7 +121,6 @@ This package contains headers and libraries required for build apps using IHK/Mc
 %ifarch aarch64
 /lib/modules/%{kernel_version}/extra/mckernel/ihk-smp-arm64.ko
 %endif
-%endif

 %files	devel
 %{_includedir}/ihklib.h
@ -135,8 +133,7 @@ This package contains headers and libraries required for build apps using IHK/Mc
 %{_includedir}/ihk/ihk_host_driver.h
 /lib/modules/%{kernel_version}/extra/mckernel/ihk/linux/core/Module.symvers

-%if 0%{?cross_compile}
-# scripts from /usr/lib/rpm/redhat/kmodtool (kernel_module_package) as well
+# taken from /usr/lib/rpm/redhat/kmodtool (kernel_module_package)
 %post
 if [ -e "/boot/System.map-%{kernel_version}" ]; then
    /usr/sbin/depmod -aeF "/boot/System.map-%{kernel_version}" "%{kernel_version}" > /dev/null || :
@ -162,7 +159,6 @@ if [ -x "/sbin/weak-modules" ]; then
    printf '%s\n' "${modules[@]}" \
    | /sbin/weak-modules --remove-modules
 fi
-%endif

 %changelog
 * Tue Feb 12 2019 Dominique Martinet <dominique.martinet@cea.fr> - 1.6.0-0
--- a/test/issues/1523/C1523.sh
+++ b/test/issues/1523/C1523.sh
@ -0,0 +1,30 @@
+#/bin/sh
+
+USELTP=1
+USEOSTEST=0
+
+MCREBOOT=0
+. ../../common.sh
+
+BOOTPARAM="${BOOTPARAM} -e anon_on_demand"
+mcreboot
+
+issue="1523"
+tid=01
+
+for tp in move_pages01 move_pages02 move_pages04 move_pages06 move_pages09 move_pages10
+do
+	tname=`printf "C${issue}T%02d" ${tid}`
+	echo "*** ${tname} start *******************************"
+	sudo $MCEXEC $LTPBIN/$tp 2>&1 | tee $tp.txt
+	ok=`grep PASS $tp.txt | wc -l`
+	ng=`grep FAIL $tp.txt | wc -l`
+	if [ $ng = 0 ]; then
+		echo "*** ${tname} PASSED ($ok)"
+	else
+		echo "*** ${tname} FAILED (ok=$ok ng=$ng)"
+	fi
+	let tid++
+	echo ""
+done
+
--- a/test/issues/1523/Makefile
+++ b/test/issues/1523/Makefile
@ -0,0 +1,11 @@
+CFLAGS=-g
+LDFLAGS=
+
+TARGET=
+
+all: $(TARGET)
+
+test: all
+	./C1523.sh
+clean:
+	rm -f $(TARGET) *.o *.txt
--- a/test/issues/1523/README
+++ b/test/issues/1523/README
@ -0,0 +1,21 @@
+【Issue#1523 動作確認】
+□ テスト内容
+1. 以下のLTPがPASSすることを確認する
+  - move_pages01
+  - move_pages02
+  - move_pages04
+  - move_pages06
+  - move_pages09
+  - move_pages10
+
+□ 実行手順
+$ make test
+
+McKernelのインストール先や、OSTEST, LTPの配置場所は、
+$HOME/.mck_test_config を参照している
+.mck_test_config は、McKernelをビルドした際に生成されるmck_test_config.sample ファイルを
+$HOMEにコピーし、適宜編集する
+
+□ 実行結果
+x86_64_result.log aarch64_result.log 参照。
+すべての項目をPASSしていることを確認。
--- a/test/issues/1523/aarch64_result.log
+++ b/test/issues/1523/aarch64_result.log
@ -0,0 +1,25 @@
+mcstop+release.sh ... done
+mcreboot.sh -c 37-43,49-55 -m 2G@2,2G@3 -r 37-43:36+49-55:48 -O -e anon_on_demand ... done
+*** C1523T01 start *******************************
+move_pages01    1  TPASS  :  pages are present in expected nodes
+*** C1523T01 PASSED (1)
+
+*** C1523T02 start *******************************
+move_pages02    1  TPASS  :  pages are present in expected nodes
+*** C1523T02 PASSED (1)
+
+*** C1523T03 start *******************************
+move_pages04    1  TPASS  :  status[1] has expected value
+*** C1523T03 PASSED (1)
+
+*** C1523T04 start *******************************
+move_pages06    1  TPASS  :  move_pages failed with ENODEV as expected
+*** C1523T04 PASSED (1)
+
+*** C1523T05 start *******************************
+move_pages09    1  TPASS  :  move_pages succeeded
+*** C1523T05 PASSED (1)
+
+*** C1523T06 start *******************************
+move_pages10    1  TPASS  :  move_pages failed with EINVAL as expected
+*** C1523T06 PASSED (1)
--- a/test/issues/1523/x86_64_result.log
+++ b/test/issues/1523/x86_64_result.log
@ -0,0 +1,25 @@
+mcstop+release.sh ... done
+mcreboot.sh -c 1-7,9-15,17-23,25-31 -m 10G@0,10G@1 -r 1-7:0+9-15:8+17-23:16+25-31:24 -O -e anon_on_demand ... done
+*** C1523T01 start *******************************
+move_pages01    1  TPASS  :  pages are present in expected nodes
+*** C1523T01 PASSED (1)
+
+*** C1523T02 start *******************************
+move_pages02    1  TPASS  :  pages are present in expected nodes
+*** C1523T02 PASSED (1)
+
+*** C1523T03 start *******************************
+move_pages04    1  TPASS  :  status[1] has expected value
+*** C1523T03 PASSED (1)
+
+*** C1523T04 start *******************************
+move_pages06    1  TPASS  :  move_pages failed with ENODEV as expected
+*** C1523T04 PASSED (1)
+
+*** C1523T05 start *******************************
+move_pages09    1  TPASS  :  move_pages succeeded
+*** C1523T05 PASSED (1)
+
+*** C1523T06 start *******************************
+move_pages10    1  TPASS  :  move_pages failed with EINVAL as expected
+*** C1523T06 PASSED (1)
--- a/test/issues/959/C959.sh
+++ b/test/issues/959/C959.sh
@ -0,0 +1,125 @@
+#/bin/sh
+
+USELTP=1
+USEOSTEST=1
+
+LTP_LIST="mbind01 get_mempolicy01"
+OSTEST_MBIND_LIST="1 3 5 9 12 14 15 16 20 24 26 28 30"
+
+BOOTPARAM="-c 1-7 -m 10G@0,10G@1 -O -e anon_on_demand"
+. ../../common.sh
+
+issue="959"
+tid=01
+arch=`uname -p`
+
+tname=`printf "C${issue}T%02d" ${tid}`
+echo "*** ${tname} start *******************************"
+sudo ${MCEXEC} ./check_mempol_il 1 30 6 3 3 3
+
+if [ $? -eq 0 ]; then
+	echo "*** ${tname} PASSED ******************************"
+else
+	echo "*** ${tname} FAILED ******************************"
+fi
+let tid++
+echo ""
+
+tname=`printf "C${issue}T%02d" ${tid}`
+echo "*** ${tname} start *******************************"
+sudo ${MCEXEC} ./check_mempol_il 2 30 6 3 3 3
+
+if [ $? -eq 0 ]; then
+	echo "*** ${tname} PASSED ******************************"
+else
+	echo "*** ${tname} FAILED ******************************"
+fi
+let tid++
+echo ""
+
+tname=`printf "C${issue}T%02d" ${tid}`
+echo "*** ${tname} start *******************************"
+sudo ${MCEXEC} ./check_mempol_il 1 30 6 2 0 6
+
+if [ $? -eq 0 ]; then
+	echo "*** ${tname} PASSED ******************************"
+else
+	echo "*** ${tname} FAILED ******************************"
+fi
+let tid++
+echo ""
+
+tname=`printf "C${issue}T%02d" ${tid}`
+echo "*** ${tname} start *******************************"
+sudo ${MCEXEC} ./check_mempol_il 2 30 6 2 0 6
+
+if [ $? -eq 0 ]; then
+	echo "*** ${tname} PASSED ******************************"
+else
+	echo "*** ${tname} FAILED ******************************"
+fi
+let tid++
+echo ""
+
+BOOTPARAM="-c 1-7 -m 10G@0,2G@1 -O -e anon_on_demand"
+mcstop
+mcreboot
+
+tname=`printf "C${issue}T%02d" ${tid}`
+echo "*** ${tname} start *******************************"
+${IHKOSCTL} 0 clear_kmsg
+sudo ${MCEXEC} ./check_mempol_il 1 30 6 2 4 2
+ret=$?
+dbg_prints=`${IHKOSCTL} 0 kmsg | grep "TEST_959" | wc -l`
+
+if [ ${ret} -eq 0 -a ${dbg_prints} -gt 0 ]; then
+	echo "*** ${tname} PASSED ******************************"
+else
+	echo "*** ${tname} FAILED ******************************"
+fi
+let tid++
+echo ""
+
+tname=`printf "C${issue}T%02d" ${tid}`
+echo "*** ${tname} start *******************************"
+sudo ${MCEXEC} ./check_mempol_il 2 30 6 2 4 2
+ret=$?
+dbg_prints=`${IHKOSCTL} 0 kmsg | grep "TEST_959" | wc -l`
+
+if [ ${ret} -eq 0 -a ${dbg_prints} -gt 0 ]; then
+	echo "*** ${tname} PASSED ******************************"
+else
+	echo "*** ${tname} FAILED ******************************"
+fi
+let tid++
+echo ""
+
+for tp in ${LTP_LIST}
+do
+	tname=`printf "C${issue}T%02d" ${tid}`
+	echo "*** ${tname} start *******************************"
+	sudo $MCEXEC $LTPBIN/$tp 2>&1 | tee $tp.txt
+	ok=`grep PASS $tp.txt | wc -l`
+	ng=`grep FAIL $tp.txt | wc -l`
+	if [ $ng = 0 ]; then
+		echo "*** ${tname} PASSED ($ok)"
+	else
+		echo "*** ${tname} FAILED (ok=$ok ng=$ng)"
+	fi
+	let tid++
+	echo ""
+done
+
+for tno in ${OSTEST_MBIND_LIST}
+do
+	tname=`printf "C${issue}T%02d" ${tid}`
+	echo "*** ${tname} start *******************************"
+	${MCEXEC} ${TESTMCK} -s mbind -n ${tno} -- -n 2 2>&1 | tee test_mck-mbind${tno}.txt
+	if [ $? = 0 ]; then
+		echo "*** ${tname} PASSED"
+	else
+		echo "*** ${tname} FAILED"
+	fi
+	let tid++
+	echo ""
+done
--- a/test/issues/959/Makefile
+++ b/test/issues/959/Makefile
@ -0,0 +1,14 @@
+include $(HOME)/.mck_test_config.mk
+
+CFLAGS=-g -O0 -Wall -I$(MCK_DIR)/include
+LDFLAGS=-L$(MCK_DIR)/lib64 -lihk -lnuma -Wl,-rpath=$(MCK_DIR)/lib64
+
+TARGET=check_mempol_il
+
+all: $(TARGET)
+
+test: all
+	./C959.sh
+clean:
+	rm -f $(TARGET) *.o *.txt
+
--- a/test/issues/959/README
+++ b/test/issues/959/README
@ -0,0 +1,87 @@
+【Issue#959 動作確認】
+□ テスト内容
+本テストは2つのNUMAノード(node0, node1)を使用してMPOL_INTERLEAVEの動作を確認するテストである。
+2つ以上のNUMAノードを持つ環境で実行すること。
+
+1. INTERLEAVEするノードセットに十分なメモリ容量がある場合の動作確認
+C959T01: set_mempolicyによるmempolicy設定時の動作 (2ノード)
+	node0, node1 からそれぞれ10GBのメモリをMcKernelに割り当てた状態で
+	下記の処理を確認する
+	 (1) set_mempolicy() でプロセスのmempolicyを、node0, node1 でのINTERLEAVEに設定する
+	 (2) 6GBのメモリを確保し、書き込みを行う
+	 (3) McKernelの2つのNUMAノードから均等にメモリが使用されていることを確認する
+
+C959T02: mbindによるmempolicy設定時の動作 (2ノード)
+	node0, node1 からそれぞれ10GBのメモリをMcKernelに割り当てた状態で
+	下記の処理を確認する
+	 (1) set_mempolicy() でプロセスのmempolicyを、node0 でのBINDに設定する
+	 (2) 6GBのメモリを確保する
+	 (3) mbind() で(2)で確保した領域のmempolicyを、node0, node1 でのINTERLEAVEに設定する
+	 (4) McKernelの2つのNUMAノードから均等にメモリが使用されていることを確認する
+
+C959T03: set_mempolicyによるmempolicy設定時の動作 (1ノード)
+	node0, node1 からそれぞれ10GBのメモリをMcKernelに割り当てた状態で
+	下記の処理を確認する
+	 (1) set_mempolicy() でプロセスのmempolicyを、 node1 でのINTERLEAVEに設定する
+	 (2) 6GBのメモリを確保し、書き込みを行う
+	 (3) McKernelのnode1から 6GBが使用されていることを確認する
+
+C959T04: mbindによるmempolicy設定時の動作 (2ノード)
+	node0, node1 からそれぞれ10GBのメモリをMcKernelに割り当てた状態で
+	下記の処理を確認する
+	 (1) set_mempolicy() でプロセスのmempolicyを、node0 でのBINDに設定する
+	 (2) 6GBのメモリを確保する
+	 (3) mbind() で(2)で確保した領域のmempolicyを、node1 でのINTERLEAVEに設定する
+	 (4) McKernelのnode1から 6GBが使用されていることを確認する
+
+2. INTERLEAVEするノードセットにメモリ容量が不足している場合の動作確認
+C959T05: set_mempolicyによるmempolicy設定時の動作
+	node0 に10GB、 node1 に2GBのメモリをそれぞれMcKernelに割り当てた状態で
+	下記の処理を確認する
+	 (1) set_mempolicy() でプロセスのmempolicyを、node1 でのINTERLEAVEに設定する
+	 (2) 6GBのメモリを確保し、書き込みを行う
+	 (3) McKernelのnode0から4GB, node1から2GBがそれぞれ使用されていることを確認する
+
+C959T06: mbindによるmempolicy設定時の動作
+	node0 に10GB、 node1 に2GBのメモリをそれぞれMcKernelに割り当てた状態で
+	下記の処理を確認する
+	 (1) set_mempolicy() でプロセスのmempolicyを、node0 でのBINDに設定する
+	 (2) 6GBのメモリを確保する
+	 (3) mbind() で(2)で確保した領域のmempolicyを、node1 でのINTERLEAVEに設定する
+	 (4) McKernelのnode0から4GB, node1から2GBがそれぞれ使用されていることを確認する
+
+3. 以下のLTPを用いて既存のmbind機能に影響がないことを確認する
+	- mbind01
+ 	- get_mempolicy01
+
+4. 以下のOSTESTを用いて既存のmbind機能に影響がないことを確認する
+	- ostest-mbind.000
+	- ostest-mbind.001
+	- ostest-mbind.002
+	- ostest-mbind.003
+	- ostest-mbind.004
+	- ostest-mbind.005
+	- ostest-mbind.006
+	- ostest-mbind.007
+	- ostest-mbind.008
+	- ostest-mbind.009
+	- ostest-mbind.010
+	- ostest-mbind.011
+	- ostest-mbind.012
+
+□ 実行手順
+・下記の手順でテストを実行する
+$ cd <mckernel>
+$ patch -p0 < test/issues/959/test_print.patch
+(build mckernel)
+$ cd test/issues/959
+$ make test
+
+McKernelのインストール先や、OSTEST, LTPの配置場所は、
+$HOME/.mck_test_config を参照している
+.mck_test_config は、McKernelをビルドした際に生成されるmck_test_config.sample ファイルを
+$HOMEにコピーし、適宜編集する
+
+□ 実行結果
+x86_64result.log, aarch64_result.log 参照。
+すべての項目をPASSしていることを確認。
--- a/test/issues/959/aarch64_result.log
+++ b/test/issues/959/aarch64_result.log
@ -0,0 +1,314 @@
+mcstop+release.sh ... done
+mcreboot.sh -c 1-7 -m 10G@0,10G@1 -O -e anon_on_demand ... done
+*** C959T01 start *******************************
+INTERLEAVE BIT_MASK: 0x3
+set_mempolicy: INTERLEAVE  mask 0x3
+** Difference of numa_stat **
+[OK]  NUMA[0] 0xc0000000
+[OK]  NUMA[1] 0xc0000000
+*** C959T01 PASSED ******************************
+
+*** C959T02 start *******************************
+INTERLEAVE BIT_MASK: 0x3
+set_mempolicy: BIND  mask 0x1
+mbind        : INTERLEAVE  mask 0x3
+** Difference of numa_stat **
+[OK]  NUMA[0] 0xc0000000
+[OK]  NUMA[1] 0xc0000000
+*** C959T02 PASSED ******************************
+
+*** C959T03 start *******************************
+INTERLEAVE BIT_MASK: 0x2
+set_mempolicy: INTERLEAVE  mask 0x2
+** Difference of numa_stat **
+[OK]  NUMA[0] 0x0
+[OK]  NUMA[1] 0x180000000
+*** C959T03 PASSED ******************************
+
+*** C959T04 start *******************************
+INTERLEAVE BIT_MASK: 0x2
+set_mempolicy: BIND  mask 0x1
+mbind        : INTERLEAVE  mask 0x2
+** Difference of numa_stat **
+[OK]  NUMA[0] 0x0
+[OK]  NUMA[1] 0x180000000
+*** C959T04 PASSED ******************************
+
+mcstop+release.sh ... done
+mcreboot.sh -c 1-7 -m 10G@0,2G@1 -O -e anon_on_demand ... done
+*** C959T05 start *******************************
+INTERLEAVE BIT_MASK: 0x2
+set_mempolicy: INTERLEAVE  mask 0x2
+** Difference of numa_stat **
+[OK]  NUMA[0] 0x100000000
+[OK]  NUMA[1] 0x80000000
+*** C959T05 PASSED ******************************
+
+*** C959T06 start *******************************
+INTERLEAVE BIT_MASK: 0x2
+set_mempolicy: BIND  mask 0x1
+mbind        : INTERLEAVE  mask 0x2
+** Difference of numa_stat **
+[OK]  NUMA[0] 0x100000000
+[OK]  NUMA[1] 0x80000000
+*** C959T06 PASSED ******************************
+
+*** C959T07 start *******************************
+tst_test.c:1096: INFO: Timeout per run is 0h 05m 00s
+mbind01.c:181: INFO: case MPOL_DEFAULT
+mbind01.c:230: PASS: Test passed
+mbind01.c:181: INFO: case MPOL_DEFAULT (target exists)
+mbind01.c:230: PASS: Test passed
+mbind01.c:181: INFO: case MPOL_BIND (no target)
+mbind01.c:230: PASS: Test passed
+mbind01.c:181: INFO: case MPOL_BIND
+mbind01.c:230: PASS: Test passed
+mbind01.c:181: INFO: case MPOL_INTERLEAVE (no target)
+mbind01.c:230: PASS: Test passed
+mbind01.c:181: INFO: case MPOL_INTERLEAVE
+mbind01.c:230: PASS: Test passed
+mbind01.c:181: INFO: case MPOL_PREFERRED (no target)
+mbind01.c:230: PASS: Test passed
+mbind01.c:181: INFO: case MPOL_PREFERRED
+mbind01.c:230: PASS: Test passed
+mbind01.c:181: INFO: case UNKNOWN_POLICY
+mbind01.c:230: PASS: Test passed
+mbind01.c:181: INFO: case MPOL_DEFAULT (invalid flags)
+mbind01.c:230: PASS: Test passed
+mbind01.c:181: INFO: case MPOL_PREFERRED (invalid nodemask)
+mbind01.c:230: PASS: Test passed
+
+Summary:
+passed   11
+failed   0
+skipped  0
+warnings 0
+*** C959T07 PASSED (11)
+
+*** C959T08 start *******************************
+EXPECT: return value(ret)=0 errno=0 (Success)
+RESULT: return value(ret)=0 errno=0 (Success)
+EXPECT: return value(ret)=0 errno=0 (Success)
+RESULT: return value(ret)=0 errno=0 (Success)
+EXPECT: return value(ret)=0 errno=0 (Success)
+RESULT: return value(ret)=0 errno=0 (Success)
+EXPECT: return value(ret)=0 errno=0 (Success)
+RESULT: return value(ret)=0 errno=0 (Success)
+EXPECT: return value(ret)=0 errno=0 (Success)
+RESULT: return value(ret)=0 errno=0 (Success)
+EXPECT: return value(ret)=0 errno=0 (Success)
+RESULT: return value(ret)=0 errno=0 (Success)
+EXPECT: return value(ret)=0 errno=0 (Success)
+RESULT: return value(ret)=0 errno=0 (Success)
+EXPECT: return value(ret)=0 errno=0 (Success)
+RESULT: return value(ret)=0 errno=0 (Success)
+EXPECT: return value(ret)=0 errno=0 (Success)
+RESULT: return value(ret)=0 errno=0 (Success)
+EXPECT: return value(ret)=0 errno=0 (Success)
+RESULT: return value(ret)=0 errno=0 (Success)
+EXPECT: return value(ret)=-1 errno=14 (Bad address)
+RESULT: return value(ret)=-1 errno=14 (Bad address)
+EXPECT: return value(ret)=-1 errno=22 (Invalid argument)
+RESULT: return value(ret)=-1 errno=22 (Invalid argument)
+get_mempolicy01    0  TINFO  :  (case00) START
+get_mempolicy01    1  TPASS  :  (case00) END
+get_mempolicy01    0  TINFO  :  (case01) START
+get_mempolicy01    2  TPASS  :  (case01) END
+get_mempolicy01    0  TINFO  :  (case02) START
+get_mempolicy01    3  TPASS  :  (case02) END
+get_mempolicy01    0  TINFO  :  (case03) START
+get_mempolicy01    4  TPASS  :  (case03) END
+get_mempolicy01    0  TINFO  :  (case04) START
+get_mempolicy01    5  TPASS  :  (case04) END
+get_mempolicy01    0  TINFO  :  (case05) START
+get_mempolicy01    6  TPASS  :  (case05) END
+get_mempolicy01    0  TINFO  :  (case06) START
+get_mempolicy01    7  TPASS  :  (case06) END
+get_mempolicy01    0  TINFO  :  (case07) START
+get_mempolicy01    8  TPASS  :  (case07) END
+get_mempolicy01    0  TINFO  :  (case08) START
+get_mempolicy01    9  TPASS  :  (case08) END
+get_mempolicy01    0  TINFO  :  (case09) START
+get_mempolicy01   10  TPASS  :  (case09) END
+get_mempolicy01    0  TINFO  :  (case10) START
+get_mempolicy01   11  TPASS  :  (case10) END
+get_mempolicy01    0  TINFO  :  (case11) START
+get_mempolicy01   12  TPASS  :  (case11) END
+*** C959T08 PASSED (12)
+
+*** C959T09 start *******************************
+TEST_SUITE: mbind
+TEST_NUMBER: 1
+ARGS: -n 2
+RESULT: ok
+*** C959T09 PASSED
+
+*** C959T10 start *******************************
+TEST_SUITE: mbind
+TEST_NUMBER: 3
+ARGS: -n 2
+RESULT: ok
+*** C959T10 PASSED
+
+*** C959T11 start *******************************
+TEST_SUITE: mbind
+TEST_NUMBER: 5
+ARGS: -n 2
+RESULT: ok
+*** C959T11 PASSED
+
+*** C959T12 start *******************************
+TEST_SUITE: mbind
+TEST_NUMBER: 9
+ARGS: -n 2
+RESULT: ok
+*** C959T12 PASSED
+
+*** C959T13 start *******************************
+TEST_SUITE: mbind
+TEST_NUMBER: 12
+ARGS: -n 2
+RESULT: ok
+*** C959T13 PASSED
+
+*** C959T14 start *******************************
+TEST_SUITE: mbind
+TEST_NUMBER: 14
+ARGS: -n 2
+RESULT: ok
+*** C959T14 PASSED
+
+*** C959T15 start *******************************
+TEST_SUITE: mbind
+TEST_NUMBER: 15
+ARGS: -n 2
+region 0
+get      : mode = 2, node_mask = 1
+m_expect : mode = 2, node_mask = 1
+
+region 1
+get      : mode = 0, node_mask = 0
+m_expect : mode = 0, node_mask = 0
+
+region 2
+get      : mode = 3, node_mask = 3
+m_expect : mode = 3, node_mask = 3
+
+region 3
+get      : mode = 3, node_mask = 3
+m_expect : mode = 3, node_mask = 3
+
+region 4
+get      : mode = 3, node_mask = 3
+m_expect : mode = 3, node_mask = 3
+
+region 5
+get      : mode = 0, node_mask = 0
+m_expect : mode = 0, node_mask = 0
+
+region 6
+get      : mode = 0, node_mask = 0
+m_expect : mode = 0, node_mask = 0
+
+RESULT: ok
+*** C959T15 PASSED
+
+*** C959T16 start *******************************
+TEST_SUITE: mbind
+TEST_NUMBER: 16
+ARGS: -n 2
+region 0
+get      : mode = 0, node_mask = 0
+m_expect : mode = 0, node_mask = 0
+
+region 1
+get      : mode = 2, node_mask = 1
+m_expect : mode = 2, node_mask = 1
+
+region 2
+get      : mode = 2, node_mask = 1
+m_expect : mode = 2, node_mask = 1
+
+region 3
+get      : mode = 2, node_mask = 1
+m_expect : mode = 2, node_mask = 1
+
+region 4
+get      : mode = 0, node_mask = 0
+m_expect : mode = 0, node_mask = 0
+
+region 5
+get      : mode = 0, node_mask = 0
+m_expect : mode = 0, node_mask = 0
+
+region 6
+get      : mode = 0, node_mask = 0
+m_expect : mode = 0, node_mask = 0
+
+RESULT: ok
+*** C959T16 PASSED
+
+*** C959T17 start *******************************
+TEST_SUITE: mbind
+TEST_NUMBER: 20
+ARGS: -n 2
+region 0
+get      : mode = 0, node_mask = 0
+m_expect : mode = 0, node_mask = 0
+
+region 1
+get      : mode = 3, node_mask = 3
+m_expect : mode = 3, node_mask = 3
+
+region 2
+get      : mode = 3, node_mask = 3
+m_expect : mode = 3, node_mask = 3
+
+region 3
+get      : mode = 2, node_mask = 1
+m_expect : mode = 2, node_mask = 1
+
+region 4
+get      : mode = 2, node_mask = 1
+m_expect : mode = 2, node_mask = 1
+
+region 5
+get      : mode = 0, node_mask = 0
+m_expect : mode = 0, node_mask = 0
+
+region 6
+get      : mode = 0, node_mask = 0
+m_expect : mode = 0, node_mask = 0
+
+RESULT: ok
+*** C959T17 PASSED
+
+*** C959T18 start *******************************
+TEST_SUITE: mbind
+TEST_NUMBER: 24
+ARGS: -n 2
+RESULT: ok
+*** C959T18 PASSED
+
+*** C959T19 start *******************************
+TEST_SUITE: mbind
+TEST_NUMBER: 26
+ARGS: -n 2
+nodemask = 0
+RESULT: ok
+*** C959T19 PASSED
+
+*** C959T20 start *******************************
+TEST_SUITE: mbind
+TEST_NUMBER: 28
+ARGS: -n 2
+RESULT: ok
+*** C959T20 PASSED
+
+*** C959T21 start *******************************
+TEST_SUITE: mbind
+TEST_NUMBER: 30
+ARGS: -n 2
+RESULT: ok
+*** C959T21 PASSED
+
--- a/test/issues/959/check_mempol_il.c
+++ b/test/issues/959/check_mempol_il.c
@ -0,0 +1,139 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <numaif.h>
+#include <sys/mman.h>
+#include <errno.h>
+#include <ihklib.h>
+#include <ihk/ihk_rusage.h>
+
+#define NUMA_NUM 2
+
+long long numa_stat_bfr[NUMA_NUM], numa_stat_aft[NUMA_NUM];
+long long exp_diff[NUMA_NUM];
+
+int
+get_current_numa_stat(long long *stat, int numa_cnt)
+{
+	int i, ret = 0;
+	struct ihk_os_rusage mck_rusage;
+
+	memset(&mck_rusage, 0, sizeof(mck_rusage));
+	ret = ihk_os_getrusage(0, &mck_rusage, sizeof(mck_rusage));
+	if (ret) {
+		perror("ihk_os_getrusage()");
+		goto out;
+	}
+
+	for (i = 0; i < numa_cnt; i++) {
+		if (mck_rusage.memory_numa_stat[i] != 0) {
+			stat[i] = mck_rusage.memory_numa_stat[i];
+		}
+	}
+out:
+	return ret;
+}
+
+int
+main(int argc, char **argv)
+{
+	void *p;
+	unsigned long mask, bind_mask = 1;
+	unsigned long ps;
+	int i, mode, pgshift, pgnum, exp_0, exp_1, ret = 0;
+
+	if (argc < 7) {
+		printf("error: too few arguments\n");
+		ret = -1;
+		goto out;
+	}
+
+	mode = atoi(argv[1]); /* 1: set_mempolicy, 2: mbind */
+	pgshift = atoi(argv[2]);
+	pgnum = atoi(argv[3]);
+	mask = atoi(argv[4]);
+	exp_0 = atoi(argv[5]);
+	exp_1 = atoi(argv[6]);
+
+	ps = 1UL << pgshift;
+	exp_diff[0] = exp_0 * ps;
+	exp_diff[1] = exp_1 * ps;
+
+	if (mode != 1 && mode != 2) {
+		printf("error: invalid mode\n");
+		ret = -1;
+		goto out;
+	}
+
+	printf("INTERLEAVE BIT_MASK: 0x%lx\n", mask);
+
+	get_current_numa_stat(numa_stat_bfr, NUMA_NUM);
+	switch (mode) {
+	case 1: /* set_mempolicy */
+		printf("set_mempolicy: INTERLEAVE  mask 0x%lx\n", mask);
+		if (set_mempolicy(MPOL_INTERLEAVE, &mask, NUMA_NUM)) {
+			perror("set_mempolicy");
+			ret = -1;
+			goto out;
+		}
+
+		p = mmap(NULL, ps * pgnum, PROT_READ|PROT_WRITE,
+				MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
+		if (p == ((void *)-1)) {
+			perror("mmap");
+			ret = -1;
+			goto out;
+		}
+		break;
+	case 2: /* mbind */
+		printf("set_mempolicy: BIND  mask 0x%lx\n", bind_mask);
+		if (set_mempolicy(MPOL_BIND, &bind_mask, NUMA_NUM)) {
+			perror("set_mempolicy");
+			ret = -1;
+			goto out;
+		}
+
+		p = mmap(NULL, ps * pgnum, PROT_READ|PROT_WRITE,
+				MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
+		if (p == ((void *)-1)) {
+			perror("mmap");
+			ret = -1;
+			goto out;
+		}
+
+		printf("mbind        : INTERLEAVE  mask 0x%lx\n", mask);
+		if (mbind(p, ps * pgnum, MPOL_INTERLEAVE, &mask,
+				NUMA_NUM, 0) == -1) {
+			perror("mbind");
+			ret = -1;
+			goto out;
+		}
+		break;
+	default:
+		printf("error: invalid mode\n");
+		ret = -1;
+		goto out;
+	}
+
+	memset(p, '0', ps * pgnum);
+
+	get_current_numa_stat(numa_stat_aft, NUMA_NUM);
+
+	printf("** Difference of numa_stat **\n");
+	for (i = 0; i < NUMA_NUM; i++) {
+		long long diff = numa_stat_aft[i] - numa_stat_bfr[i];
+
+		if (diff == exp_diff[i]) {
+			printf("[OK] ");
+		} else {
+			printf("[NG] ");
+			ret = -1;
+		}
+		printf(" NUMA[%d] 0x%llx\n", i, diff);
+	}
+
+	munmap(p, ps * pgnum);
+out:
+	return ret;
+}
--- a/test/issues/959/test_print.patch
+++ b/test/issues/959/test_print.patch
@ -0,0 +1,14 @@
+diff --git kernel/mem.c kernel/mem.c
+index e464eb2..7086c6a 100644
+--- kernel/mem.c
+++ kernel/mem.c
+@@ -749,6 +749,9 @@ retry_interleave:
+ #endif
+ 		dkprintf("%s: couldn't fulfill user policy for %d pages\n",
+ 			__FUNCTION__, npages);
+		if (numa_mem_policy == MPOL_INTERLEAVE) {
+			kprintf("TEST_959: reach HERE\n");
+		}
+ 	}
+ 
+ distance_based:
--- a/test/issues/959/x86_64_result.log
+++ b/test/issues/959/x86_64_result.log
@ -0,0 +1,313 @@
+mcstop+release.sh ... done
+mcreboot.sh -c 1-7 -m 10G@0,10G@1 -O -e anon_on_demand ... done
+*** C959T01 start *******************************
+INTERLEAVE BIT_MASK: 0x3
+set_mempolicy: INTERLEAVE  mask 0x3
+** Difference of numa_stat **
+[OK]  NUMA[0] 0xc0000000
+[OK]  NUMA[1] 0xc0000000
+*** C959T01 PASSED ******************************
+
+*** C959T02 start *******************************
+INTERLEAVE BIT_MASK: 0x3
+set_mempolicy: BIND  mask 0x1
+mbind        : INTERLEAVE  mask 0x3
+** Difference of numa_stat **
+[OK]  NUMA[0] 0xc0000000
+[OK]  NUMA[1] 0xc0000000
+*** C959T02 PASSED ******************************
+
+*** C959T03 start *******************************
+INTERLEAVE BIT_MASK: 0x2
+set_mempolicy: INTERLEAVE  mask 0x2
+** Difference of numa_stat **
+[OK]  NUMA[0] 0x0
+[OK]  NUMA[1] 0x180000000
+*** C959T03 PASSED ******************************
+
+*** C959T04 start *******************************
+INTERLEAVE BIT_MASK: 0x2
+set_mempolicy: BIND  mask 0x1
+mbind        : INTERLEAVE  mask 0x2
+** Difference of numa_stat **
+[OK]  NUMA[0] 0x0
+[OK]  NUMA[1] 0x180000000
+*** C959T04 PASSED ******************************
+
+mcstop+release.sh ... done
+mcreboot.sh -c 1-7 -m 10G@0,2G@1 -O -e anon_on_demand ... done
+*** C959T05 start *******************************
+INTERLEAVE BIT_MASK: 0x2
+set_mempolicy: INTERLEAVE  mask 0x2
+** Difference of numa_stat **
+[OK]  NUMA[0] 0x100000000
+[OK]  NUMA[1] 0x80000000
+*** C959T05 PASSED ******************************
+
+*** C959T06 start *******************************
+INTERLEAVE BIT_MASK: 0x2
+set_mempolicy: BIND  mask 0x1
+mbind        : INTERLEAVE  mask 0x2
+** Difference of numa_stat **
+[OK]  NUMA[0] 0x100000000
+[OK]  NUMA[1] 0x80000000
+*** C959T06 PASSED ******************************
+
+*** C959T07 start *******************************
+tst_test.c:1096: INFO: Timeout per run is 0h 05m 00s
+mbind01.c:181: INFO: case MPOL_DEFAULT
+mbind01.c:230: PASS: Test passed
+mbind01.c:181: INFO: case MPOL_DEFAULT (target exists)
+mbind01.c:230: PASS: Test passed
+mbind01.c:181: INFO: case MPOL_BIND (no target)
+mbind01.c:230: PASS: Test passed
+mbind01.c:181: INFO: case MPOL_BIND
+mbind01.c:230: PASS: Test passed
+mbind01.c:181: INFO: case MPOL_INTERLEAVE (no target)
+mbind01.c:230: PASS: Test passed
+mbind01.c:181: INFO: case MPOL_INTERLEAVE
+mbind01.c:230: PASS: Test passed
+mbind01.c:181: INFO: case MPOL_PREFERRED (no target)
+mbind01.c:230: PASS: Test passed
+mbind01.c:181: INFO: case MPOL_PREFERRED
+mbind01.c:230: PASS: Test passed
+mbind01.c:181: INFO: case UNKNOWN_POLICY
+mbind01.c:230: PASS: Test passed
+mbind01.c:181: INFO: case MPOL_DEFAULT (invalid flags)
+mbind01.c:230: PASS: Test passed
+mbind01.c:181: INFO: case MPOL_PREFERRED (invalid nodemask)
+mbind01.c:230: PASS: Test passed
+
+Summary:
+passed   11
+failed   0
+skipped  0
+warnings 0
+*** C959T07 PASSED (11)
+
+*** C959T08 start *******************************
+EXPECT: return value(ret)=0 errno=0 (Success)
+RESULT: return value(ret)=0 errno=0 (Success)
+EXPECT: return value(ret)=0 errno=0 (Success)
+RESULT: return value(ret)=0 errno=0 (Success)
+EXPECT: return value(ret)=0 errno=0 (Success)
+RESULT: return value(ret)=0 errno=0 (Success)
+EXPECT: return value(ret)=0 errno=0 (Success)
+RESULT: return value(ret)=0 errno=0 (Success)
+EXPECT: return value(ret)=0 errno=0 (Success)
+RESULT: return value(ret)=0 errno=0 (Success)
+EXPECT: return value(ret)=0 errno=0 (Success)
+RESULT: return value(ret)=0 errno=0 (Success)
+EXPECT: return value(ret)=0 errno=0 (Success)
+RESULT: return value(ret)=0 errno=0 (Success)
+EXPECT: return value(ret)=0 errno=0 (Success)
+RESULT: return value(ret)=0 errno=0 (Success)
+EXPECT: return value(ret)=0 errno=0 (Success)
+RESULT: return value(ret)=0 errno=0 (Success)
+EXPECT: return value(ret)=0 errno=0 (Success)
+RESULT: return value(ret)=0 errno=0 (Success)
+EXPECT: return value(ret)=-1 errno=14 (Bad address)
+RESULT: return value(ret)=-1 errno=14 (Bad address)
+EXPECT: return value(ret)=-1 errno=22 (Invalid argument)
+RESULT: return value(ret)=-1 errno=22 (Invalid argument)
+get_mempolicy01    0  TINFO  :  (case00) START
+get_mempolicy01    1  TPASS  :  (case00) END
+get_mempolicy01    0  TINFO  :  (case01) START
+get_mempolicy01    2  TPASS  :  (case01) END
+get_mempolicy01    0  TINFO  :  (case02) START
+get_mempolicy01    3  TPASS  :  (case02) END
+get_mempolicy01    0  TINFO  :  (case03) START
+get_mempolicy01    4  TPASS  :  (case03) END
+get_mempolicy01    0  TINFO  :  (case04) START
+get_mempolicy01    5  TPASS  :  (case04) END
+get_mempolicy01    0  TINFO  :  (case05) START
+get_mempolicy01    6  TPASS  :  (case05) END
+get_mempolicy01    0  TINFO  :  (case06) START
+get_mempolicy01    7  TPASS  :  (case06) END
+get_mempolicy01    0  TINFO  :  (case07) START
+get_mempolicy01    8  TPASS  :  (case07) END
+get_mempolicy01    0  TINFO  :  (case08) START
+get_mempolicy01    9  TPASS  :  (case08) END
+get_mempolicy01    0  TINFO  :  (case09) START
+get_mempolicy01   10  TPASS  :  (case09) END
+get_mempolicy01    0  TINFO  :  (case10) START
+get_mempolicy01   11  TPASS  :  (case10) END
+get_mempolicy01    0  TINFO  :  (case11) START
+get_mempolicy01   12  TPASS  :  (case11) END
+*** C959T08 PASSED (12)
+
+*** C959T09 start *******************************
+TEST_SUITE: mbind
+TEST_NUMBER: 1
+ARGS: -n 2
+RESULT: ok
+*** C959T09 PASSED
+
+*** C959T10 start *******************************
+TEST_SUITE: mbind
+TEST_NUMBER: 3
+ARGS: -n 2
+RESULT: ok
+*** C959T10 PASSED
+
+*** C959T11 start *******************************
+TEST_SUITE: mbind
+TEST_NUMBER: 5
+ARGS: -n 2
+RESULT: ok
+*** C959T11 PASSED
+
+*** C959T12 start *******************************
+TEST_SUITE: mbind
+TEST_NUMBER: 9
+ARGS: -n 2
+RESULT: ok
+*** C959T12 PASSED
+
+*** C959T13 start *******************************
+TEST_SUITE: mbind
+TEST_NUMBER: 12
+ARGS: -n 2
+RESULT: ok
+*** C959T13 PASSED
+
+*** C959T14 start *******************************
+TEST_SUITE: mbind
+TEST_NUMBER: 14
+ARGS: -n 2
+RESULT: ok
+*** C959T14 PASSED
+
+*** C959T15 start *******************************
+TEST_SUITE: mbind
+TEST_NUMBER: 15
+ARGS: -n 2
+region 0
+get      : mode = 2, node_mask = 1
+m_expect : mode = 2, node_mask = 1
+
+region 1
+get      : mode = 0, node_mask = 0
+m_expect : mode = 0, node_mask = 0
+
+region 2
+get      : mode = 3, node_mask = 3
+m_expect : mode = 3, node_mask = 3
+
+region 3
+get      : mode = 3, node_mask = 3
+m_expect : mode = 3, node_mask = 3
+
+region 4
+get      : mode = 3, node_mask = 3
+m_expect : mode = 3, node_mask = 3
+
+region 5
+get      : mode = 0, node_mask = 0
+m_expect : mode = 0, node_mask = 0
+
+region 6
+get      : mode = 0, node_mask = 0
+m_expect : mode = 0, node_mask = 0
+
+RESULT: ok
+*** C959T15 PASSED
+
+*** C959T16 start *******************************
+TEST_SUITE: mbind
+TEST_NUMBER: 16
+ARGS: -n 2
+region 0
+get      : mode = 0, node_mask = 0
+m_expect : mode = 0, node_mask = 0
+
+region 1
+get      : mode = 2, node_mask = 1
+m_expect : mode = 2, node_mask = 1
+
+region 2
+get      : mode = 2, node_mask = 1
+m_expect : mode = 2, node_mask = 1
+
+region 3
+get      : mode = 2, node_mask = 1
+m_expect : mode = 2, node_mask = 1
+
+region 4
+get      : mode = 0, node_mask = 0
+m_expect : mode = 0, node_mask = 0
+
+region 5
+get      : mode = 0, node_mask = 0
+m_expect : mode = 0, node_mask = 0
+
+region 6
+get      : mode = 0, node_mask = 0
+m_expect : mode = 0, node_mask = 0
+
+RESULT: ok
+*** C959T16 PASSED
+
+*** C959T17 start *******************************
+TEST_SUITE: mbind
+TEST_NUMBER: 20
+ARGS: -n 2
+region 0
+get      : mode = 0, node_mask = 0
+m_expect : mode = 0, node_mask = 0
+
+region 1
+get      : mode = 3, node_mask = 3
+m_expect : mode = 3, node_mask = 3
+
+region 2
+get      : mode = 3, node_mask = 3
+m_expect : mode = 3, node_mask = 3
+
+region 3
+get      : mode = 2, node_mask = 1
+m_expect : mode = 2, node_mask = 1
+
+region 4
+get      : mode = 2, node_mask = 1
+m_expect : mode = 2, node_mask = 1
+
+region 5
+get      : mode = 0, node_mask = 0
+m_expect : mode = 0, node_mask = 0
+
+region 6
+get      : mode = 0, node_mask = 0
+m_expect : mode = 0, node_mask = 0
+
+RESULT: ok
+*** C959T17 PASSED
+
+*** C959T18 start *******************************
+TEST_SUITE: mbind
+TEST_NUMBER: 24
+ARGS: -n 2
+RESULT: ok
+*** C959T18 PASSED
+
+*** C959T19 start *******************************
+TEST_SUITE: mbind
+TEST_NUMBER: 26
+ARGS: -n 2
+nodemask = 0
+RESULT: ok
+*** C959T19 PASSED
+
+*** C959T20 start *******************************
+TEST_SUITE: mbind
+TEST_NUMBER: 28
+ARGS: -n 2
+RESULT: ok
+*** C959T20 PASSED
+
+*** C959T21 start *******************************
+TEST_SUITE: mbind
+TEST_NUMBER: 30
+ARGS: -n 2
+RESULT: ok
+*** C959T21 PASSED
Author	SHA1	Message	Date
Masamichi Takagi	583319125a	prerelease: 0.94: fix __mcctrl_os_read_write_cpu_register Change-Id: Ibcfbe7796347cc9c2148cdea2519fe6c7ca9e97e	2021-02-18 15:23:01 +09:00
Ken Sato	9f39d1cd88	move_pages: Fix and support some specs for LTP. 1. When nodes array is NULL, move_pages doesn't move any pages, instead will return the node where each page currently resides by status array. 2. Check whether all specified node is online or not. Change-Id: Ie3534997833d797e2a9f595d1107b07d46e1c6cf Refs: #1523	2021-02-18 06:16:17 +00:00
Ken Sato	a0d446b27f	smp: make smp_call_func() arch independent Change-Id: Ib60604ceb3274b173bd7f96cf57c8c35c1889e44	2021-02-18 06:16:17 +00:00
Ken Sato	f3c875b8e6	mbind: Use range_policy's numamask as priority on MPOL_BIND Change-Id: Iaaa7998945c6e2b42d91d34a2f7b05db1f4d696d	2021-02-18 06:16:17 +00:00
Ken Sato	9f1e6d707c	get_mempolicy: Support (MPOL_F_NODE \| MPOL_F_ADDR) specified If flags specifies both MPOL_F_NODE and MPOL_F_ADDR, get_mempolicy() will return the node ID of the node on which the address addr is allocated into the location pointed to by mode. Change-Id: Id485e3f4838e3679d877a95e53b21e3421cac88a	2021-02-18 06:16:17 +00:00
Ken Sato	aef50d710c	mempolicy: Support MPOL_INTERLEAVE Change-Id: I6357892d792b2de8ea859a0a6799250f05066713 Refs: #959	2021-02-18 06:16:17 +00:00
Ken Sato	7f0594d784	TO RESET: mbind: do nothing Fixes: `00007daf` ("mbind: do nothing (workaround for Fugaku)") Change-Id: Id41940bebd2cbcc3e8637eadd4847984627b1c72	2021-02-18 06:16:17 +00:00
Ken Sato	866f5c51a0	docs: add limitation of system calls that call copy_to_user() Change-Id: If449c73f8d5949ab5526ea598b0f713ed4431157 Refs: #1514	2021-02-18 13:04:53 +09:00
Masamichi Takagi	48b1d548f2	__mcctrl_os_read_write_cpu_register: fix timeout Change-Id: Id5a7d316d793bd535f24fd353b214aa12af1dab4	2021-02-15 08:56:04 +00:00
Masamichi Takagi	822b64b03c	docs: add limitation related to Fujitsu TCS xos_hwb Change-Id: I83a1ecd7a0b6d3bcde2b902cd526dfd4feb9e23a	2021-02-15 16:03:52 +09:00
Balazs Gerofi	aca83bcd3d	Tofu: fault stack area if VM range doesn't exist in STAG registration Change-Id: I407a8954ccaf22019b3082fd6eee68e772d1cb26	2021-02-15 14:46:58 +09:00
Balazs Gerofi	c7145c4b38	xpmem: fault stack area of remote process if VM range doesn't yet exist Change-Id: I2bbb745cc9b79ab4f9ea81b242f35f1b88ad531e	2021-02-15 14:46:58 +09:00
Masamichi Takagi	a82d161be8	prerelease: 0.93: investigate smp_ihk_os_panic_notifier Change-Id: I997b41f80038603261de2e8232b6b8ca200cd8cd	2021-02-09 21:39:49 -05:00
Masamichi Takagi	7152269a59	spec: create one rpm including .ko and binaries Don't use kernel_module_package not to create a separate kmod-mckernel-*.rpm containing .ko files. Change-Id: I25b7ff662476bfc735d319b57cdf2da82f2c6aa7	2021-02-09 20:55:38 -05:00
Masamichi Takagi	31c08bcb7d	spec, docs: update cmake options Change-Id: Ib8277413a413b5ce956a48f7e3d9922311937ea8	2021-02-09 20:55:38 -05:00
Masamichi Takagi	dffb0918a2	docs: add capstone installation options Change-Id: I96aa9a6405c17f8d9653f3d3894f0e71a57ab460	2021-02-09 06:10:32 +00:00
Masamichi Takagi	23cd14af7d	__mcctrl_os_read_write_cpu_register: timeout in 1 sec for when McKernel can't respond Change-Id: Ia2d5f64e107697dda1f3bae499eb3afb8a7aedba	2021-02-09 06:09:11 +00:00
Masamichi Takagi	a5cf2019bc	cmake: fix detection of Fugaku native compilation Change-Id: I4210e9b57223c3869464caea10c2d414e9484e14	2021-02-09 06:06:13 +00:00
Masamichi Takagi	11b9fe0377	page_fault_handler: fix missing increment of in_page_fault on SEGV This integrates some of the changes of the following commit: `1cf0bd5a` ("TO RESET: add debug instruments, map Linux areas for tofu") Change-Id: Iffd8432d5a7b35f20bd45829a125583a0363dbf0	2021-02-09 00:56:15 -05:00
Balazs Gerofi	4905c8e638	mcexec: propagate error in __NR_gettid handler Change-Id: I0e0f06199970fe839065567dcd5418d017b6ec00	2021-02-03 18:53:33 -05:00
Balazs Gerofi	3d71c6a8eb	mcexec_transfer_image(): map exact size of remote memory (instead of forcing PAGE_SIZE) Change-Id: Ic66770af6cdb15b7a2e18a08cbcd1736e5558bdf	2021-02-03 18:53:33 -05:00
Masamichi Takagi	1cea75dd51	mcexec: fix strncat missing NULL and pclose of uninitialized Change-Id: I9ce4004580845a983949caa5668b2f950880cd24	2021-02-02 01:51:57 +00:00
Masamichi Takagi	661ba0ce4a	docs: add editing spec file when building rpm Change-Id: Ic8dc9d8c6aef6d2180844891d743a09f4a3bdd9d	2021-01-29 01:23:35 +00:00
Masamichi Takagi	7e82adc761	prerelease: 0.92: fix uninitialized usrdata->cpu_topology_list Change-Id: Ia12970bda1225898823a67c2d0461144fc62ebb9	2021-01-29 09:50:53 +09:00
Masamichi Takagi	1f9fbe82db	mcctrl: fix access to uninitialized usrdata->cpu_topology_list Change-Id: I25a9182b9b470bb069f4f755a67fb50b88817cd2	2021-01-29 09:34:24 +09:00
Masamichi Takagi	aa3d4ba7bd	spec: prerelease 0.91 for 4.18.0-240.8.1.el8_3.aarch64 support Change-Id: I8b33714157b1c68c1fc1eadf0b9d072a3ee59608	2021-01-26 02:34:35 -05:00
Masamichi Takagi	c89ac042f9	spec: prerelease 0.9 for testing hidos and cgroup check Change-Id: I3b04fbf3a1ffa10df9c76da7b2730b9a2521bf98	2021-01-20 13:03:16 +09:00
Masamichi Takagi	0f1fc88ce9	spec: prerelease 0.8 for testing hidos and cgroup check Change-Id: I6261380ab8e99d39191cbd8aac851038cdeb5ce2	2021-01-19 17:34:45 +09:00
Masamichi Takagi	bbc6565e7e	docs: users: add how to specify boot parameters with Fujitsu TCS Change-Id: I0216603388780d0e5497373598c3151812238932	2021-01-19 04:03:05 +00:00
Masamichi Takagi	1a29f8213f	spec: prerelease 0.7 for testing hidos and cgroup check Change-Id: I17f1608051a8f8ca33d2ba7385b75b8b492d1886	2021-01-19 12:25:06 +09:00
Masamichi Takagi	fd21fe7411	copy_user_ranges: copy straight_start of struct vm_range This fixes the panic in ihk_os_set_ikc_map01 of the ihklib test suite. Change-Id: Ic03efc81c5ca2c4deaeb06673afef8cef7a1cf92	2021-01-19 00:59:46 +00:00
Balazs Gerofi	2460228052	mcctrl: abort on invalid addr in mcexec_transfer_image() Change-Id: Ic064b6ffc30368ff1d3dfb14403e524cbb837ce5	2021-01-19 00:55:20 +00:00
Balazs Gerofi	bf926f234a	Tofu: manage stag ranges in VM range split and misc cleanup Conflicts: kernel/process.c Change-Id: I480850fe93a7963a5bd4d1687fb1e5c43f58057f	2021-01-19 00:55:20 +00:00
Balazs Gerofi	507b937509	Tofu: mcctrl side MMU notifier and CQ/BCH cleanup Conflicts: executer/kernel/mcctrl/arch/arm64/archdeps.c executer/kernel/mcctrl/syscall.c Change-Id: Ided8172331a5469c6ced68fa98a42302812efe71	2021-01-19 00:55:20 +00:00
Masamichi Takagi	a99cf99396	cmake: add switch to turn on/off krm workaround Change-Id: I2dfd3d7f3373cce714247f9fc36bf5040a2a8fad	2021-01-19 00:52:53 +00:00
Masamichi Takagi	6f373186bf	docs: add specifications of IHK and McKernel Change-Id: I523ad68c5627ca1081c0c8684606a08101982ec9	2021-01-18 08:24:37 +00:00