Index: trunk/kernel/kern/rpc.c
===================================================================
--- trunk/kernel/kern/rpc.c	(revision 591)
+++ trunk/kernel/kern/rpc.c	(revision 601)
@@ -49,72 +49,72 @@
 rpc_server_t * rpc_server[RPC_MAX_INDEX] =
 {
-    &rpc_pmem_get_pages_server,         // 0
-    &rpc_pmem_release_pages_server,     // 1
-    &rpc_undefined,                     // 2    unused slot
-    &rpc_process_make_fork_server,      // 3
-    &rpc_undefined,                     // 4    unused slot
-    &rpc_undefined,                     // 5    unused slot
-    &rpc_thread_user_create_server,     // 6
-    &rpc_thread_kernel_create_server,   // 7
-    &rpc_undefined,                     // 8    unused slot        
-    &rpc_process_sigaction_server,      // 9
-
-    &rpc_vfs_inode_create_server,       // 10  
-    &rpc_vfs_inode_destroy_server,      // 11  
-    &rpc_vfs_dentry_create_server,      // 12  
-    &rpc_vfs_dentry_destroy_server,     // 13  
-    &rpc_vfs_file_create_server,        // 14
-    &rpc_vfs_file_destroy_server,       // 15
-    &rpc_vfs_inode_load_server,         // 16
-    &rpc_vfs_mapper_load_all_server,    // 17
-    &rpc_fatfs_get_cluster_server,      // 18
-    &rpc_undefined,                     // 19   unused slot
-
-    &rpc_vmm_get_vseg_server,           // 20
-    &rpc_vmm_global_update_pte_server,  // 21
-    &rpc_kcm_alloc_server,              // 22
-    &rpc_kcm_free_server,               // 23
-    &rpc_mapper_move_buffer_server,     // 24
-    &rpc_mapper_get_page_server,        // 25
-    &rpc_vmm_create_vseg_server,        // 26
-    &rpc_undefined,                     // 27   unused slot
-    &rpc_vmm_set_cow_server,            // 28
-    &rpc_vmm_display_server,            // 29
+    &rpc_pmem_get_pages_server,            // 0
+    &rpc_pmem_release_pages_server,        // 1
+    &rpc_undefined,                        // 2    unused slot
+    &rpc_process_make_fork_server,         // 3
+    &rpc_undefined,                        // 4    unused slot
+    &rpc_undefined,                        // 5    unused slot
+    &rpc_thread_user_create_server,        // 6
+    &rpc_thread_kernel_create_server,      // 7
+    &rpc_undefined,                        // 8    unused slot        
+    &rpc_process_sigaction_server,         // 9
+
+    &rpc_vfs_inode_create_server,          // 10  
+    &rpc_vfs_inode_destroy_server,         // 11  
+    &rpc_vfs_dentry_create_server,         // 12  
+    &rpc_vfs_dentry_destroy_server,        // 13  
+    &rpc_vfs_file_create_server,           // 14
+    &rpc_vfs_file_destroy_server,          // 15
+    &rpc_vfs_fs_child_init_server,         // 16
+    &rpc_vfs_fs_add_dentry_server,         // 17
+    &rpc_vfs_fs_remove_dentry_server,      // 18
+    &rpc_vfs_inode_load_all_pages_server,  // 19 
+
+    &rpc_vmm_get_vseg_server,              // 20
+    &rpc_vmm_global_update_pte_server,     // 21
+    &rpc_kcm_alloc_server,                 // 22
+    &rpc_kcm_free_server,                  // 23
+    &rpc_mapper_move_user_server,          // 24
+    &rpc_mapper_handle_miss_server,        // 25
+    &rpc_undefined,                        // 26   unused slot
+    &rpc_vmm_create_vseg_server,           // 27
+    &rpc_vmm_set_cow_server,               // 28
+    &rpc_vmm_display_server,               // 29
 };
 
 char * rpc_str[RPC_MAX_INDEX] =
 {
-    "PMEM_GET_PAGES",         // 0
-    "PMEM_RELEASE_PAGES",     // 1
-    "undefined",              // 2
-    "PROCESS_MAKE_FORK",      // 3
-    "undefined",              // 4
-    "undefined",              // 5
-    "THREAD_USER_CREATE",     // 6
-    "THREAD_KERNEL_CREATE",   // 7
-    "undefined",              // 8
-    "PROCESS_SIGACTION",      // 9
-
-    "VFS_INODE_CREATE",       // 10
-    "VFS_INODE_DESTROY",      // 11
-    "VFS_DENTRY_CREATE",      // 12
-    "VFS_DENTRY_DESTROY",     // 13
-    "VFS_FILE_CREATE",        // 14
-    "VFS_FILE_DESTROY",       // 15
-    "VFS_INODE_LOAD",         // 16
-    "VFS_MAPPER_LOAD_ALL",    // 17
-    "FATFS_GET_CLUSTER",      // 18
-    "undefined",              // 19
-
-    "GET_VSEG",               // 20
-    "GLOBAL_UPDATE_PTE",                // 21
-    "KCM_ALLOC",              // 22
-    "KCM_FREE",               // 23
-    "MAPPER_MOVE_BUFFER",     // 24
-    "MAPPER_GET_PAGE",        // 25
-    "VMM_CREATE_VSEG",        // 26
-    "undefined",              // 27
-    "VMM_SET_COW",            // 28
-    "VMM_DISPLAY",            // 29
+    "PMEM_GET_PAGES",            // 0
+    "PMEM_RELEASE_PAGES",        // 1
+    "undefined",                 // 2
+    "PROCESS_MAKE_FORK",         // 3
+    "undefined",                 // 4
+    "undefined",                 // 5
+    "THREAD_USER_CREATE",        // 6
+    "THREAD_KERNEL_CREATE",      // 7
+    "undefined",                 // 8
+    "PROCESS_SIGACTION",         // 9
+
+    "VFS_INODE_CREATE",          // 10
+    "VFS_INODE_DESTROY",         // 11
+    "VFS_DENTRY_CREATE",         // 12
+    "VFS_DENTRY_DESTROY",        // 13
+    "VFS_FILE_CREATE",           // 14
+    "VFS_FILE_DESTROY",          // 15
+    "VFS_FS_CHILD_INIT",         // 16
+    "VFS_FS_ADD_DENTRY",         // 17
+    "VFS_FS_REMOVE_DENTRY",      // 18
+    "VFS_INODE_LOAD_ALL_PAGES",  // 19
+
+    "GET_VSEG",                  // 20
+    "GLOBAL_UPDATE_PTE",         // 21
+    "KCM_ALLOC",                 // 22
+    "KCM_FREE",                  // 23
+    "MAPPER_MOVE_USER",          // 24
+    "MAPPER_HANDLE_MISS",        // 25
+    "undefined",                 // 26
+    "VMM_CREATE_VSEG",           // 27
+    "VMM_SET_COW",               // 28
+    "VMM_DISPLAY",               // 29
 };
 
@@ -189,6 +189,6 @@
 uint32_t items = remote_fifo_items( rpc_fifo_xp );
 if( DEBUG_RPC_CLIENT_GENERIC < cycle ) 
-printk("\n[DBG] %s : thread %x in process %x / rpc %s / server[%x,%d] / items %d / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, rpc_str[rpc->index], 
+printk("\n[%s] thread[%x,%x] / rpc %s / server[%x,%d] / items %d / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, rpc_str[rpc->index], 
 server_cxy, server_core_lid, items, cycle );
 #endif
@@ -208,6 +208,6 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_CLIENT_GENERIC < cycle ) 
-printk("\n[DBG] %s : thread %x in process %x enter waiting loop for rpc %s / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, rpc_str[rpc->index], cycle );
+printk("\n[%s] thread[%x,%x] enter waiting loop for rpc %s / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, rpc_str[rpc->index], cycle );
 #endif
 
@@ -217,6 +217,6 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_CLIENT_GENERIC < cycle ) 
-printk("\n[DBG] %s : thread %x in process %x received response for rpc %s / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, rpc_str[rpc->index], cycle );
+printk("\n[%s] thread[%x,%x] received response for rpc %s / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, rpc_str[rpc->index], cycle );
 #endif
  
@@ -228,6 +228,6 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_CLIENT_GENERIC < cycle ) 
-printk("\n[DBG] %s : thread %x in process %x blocks & deschedules for rpc %s / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, rpc_str[rpc->index], cycle );
+printk("\n[%s] thread[%x,%x] blocks & deschedules for rpc %s / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, rpc_str[rpc->index], cycle );
 #endif
 
@@ -241,6 +241,6 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_CLIENT_GENERIC < cycle ) 
-printk("\n[DBG] %s : thread %x in process %x resumes for rpc %s / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, rpc_str[rpc->index], cycle );
+printk("\n[%s] thread[%x,%x] resumes for rpc %s / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, rpc_str[rpc->index], cycle );
 #endif
         }
@@ -256,6 +256,6 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_CLIENT_GENERIC < cycle ) 
-printk("\n[DBG] %s : thread %x in process %x returns for non blocking rpc %s / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, rpc_str[rpc->index], cycle );
+printk("\n[%s] thread[%x,%x] returns for non blocking rpc %s / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, rpc_str[rpc->index], cycle );
 #endif
 
@@ -417,6 +417,6 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_PMEM_GET_PAGES )
-printk("\n[DBG] %s : thread %x in process %x on core %d enter / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid, cycle );
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
 #endif
 
@@ -441,6 +441,6 @@
 cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_PMEM_GET_PAGES )
-printk("\n[DBG] %s : thread %x in process %x on core %d exit / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid, cycle );
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
 #endif
 }
@@ -453,6 +453,6 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_PMEM_GET_PAGES )
-printk("\n[DBG] %s : thread %x in process %x on core %d enter / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid, cycle );
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
 #endif
 
@@ -473,6 +473,6 @@
 cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_PMEM_GET_PAGES )
-printk("\n[DBG] %s : thread %x in process %x on core %d exit / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid, cycle );
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
 #endif
 }
@@ -490,6 +490,6 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_PMEM_RELEASE_PAGES )
-printk("\n[DBG] %s : thread %x in process %x on core %d enter / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid , cycle );
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
 #endif
 
@@ -511,6 +511,6 @@
 cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_PMEM_RELEASE_PAGES )
-printk("\n[DBG] %s : thread %x in process %x on core %d exit / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid, cycle );
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
 #endif
 }
@@ -523,6 +523,6 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_PMEM_RELEASE_PAGES )
-printk("\n[DBG] %s : thread %x in process %x on core %d enter / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid , cycle );
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
 #endif
 
@@ -543,6 +543,6 @@
 cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_PMEM_RELEASE_PAGES )
-printk("\n[DBG] %s : thread %x in process %x on core %d exit / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid, cycle );
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
 #endif
 }
@@ -568,6 +568,6 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_PROCESS_MAKE_FORK )
-printk("\n[DBG] %s : thread %x in process %x on core %d enter / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid , cycle );
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
 #endif
 
@@ -595,6 +595,6 @@
 cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_PROCESS_MAKE_FORK )
-printk("\n[DBG] %s : thread %x in process %x on core %d exit / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid, cycle );
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
 #endif
 }
@@ -607,6 +607,6 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_PROCESS_MAKE_FORK )
-printk("\n[DBG] %s : thread %x in process %x on core %d enter / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid, cycle );
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
 #endif
 
@@ -639,6 +639,6 @@
 cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_PROCESS_MAKE_FORK )
-printk("\n[DBG] %s : thread %x in process %x on core %d exit / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid, cycle );
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
 #endif
 }
@@ -669,6 +669,6 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_THREAD_USER_CREATE)
-printk("\n[DBG] %s : thread %x in process %x on core %d enter / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid, cycle );
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
 #endif
 
@@ -697,6 +697,6 @@
 cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_THREAD_USER_CREATE)
-printk("\n[DBG] %s : thread %x in process %x on core %d exit / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid, cycle );
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
 #endif
 }
@@ -709,6 +709,6 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_THREAD_USER_CREATE)
-printk("\n[DBG] %s : thread %x in process %x on core %d enter / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid, cycle );
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
 #endif
 
@@ -755,6 +755,6 @@
 cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_THREAD_USER_CREATE)
-printk("\n[DBG] %s : thread %x in process %x on core %d exit / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid, cycle );
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
 #endif
 }
@@ -776,6 +776,6 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_THREAD_KERNEL_CREATE)
-printk("\n[DBG] %s : thread %x in process %x on core %d enter / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid, cycle );
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
 #endif
 
@@ -803,6 +803,6 @@
 cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_THREAD_KERNEL_CREATE)
-printk("\n[DBG] %s : thread %x in process %x on core %d exit / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid, cycle );
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
 #endif
 }
@@ -815,6 +815,6 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_THREAD_KERNEL_CREATE)
-printk("\n[DBG] %s : thread %x in process %x on core %d enter / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid, cycle );
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
 #endif
 
@@ -847,6 +847,6 @@
 cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_THREAD_KERNEL_CREATE)
-printk("\n[DBG] %s : thread %x in process %x on core %d exit / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid, cycle );
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
 #endif
 }
@@ -969,5 +969,4 @@
                                   uint32_t       fs_type,    // in
                                   uint32_t       inode_type, // in
-                                  void         * extend,     // in
                                   uint32_t       attr,       // in
                                   uint32_t       rights,     // in
@@ -981,6 +980,6 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_VFS_INODE_CREATE )
-printk("\n[DBG] %s : thread %x in process %x on core %d enter / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid , cycle );
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
 #endif
 
@@ -997,9 +996,8 @@
     rpc.args[1] = (uint64_t)fs_type;
     rpc.args[2] = (uint64_t)inode_type;
-    rpc.args[3] = (uint64_t)(intptr_t)extend;
-    rpc.args[4] = (uint64_t)attr;
-    rpc.args[5] = (uint64_t)rights;
-    rpc.args[6] = (uint64_t)uid;
-    rpc.args[7] = (uint64_t)gid;
+    rpc.args[3] = (uint64_t)attr;
+    rpc.args[4] = (uint64_t)rights;
+    rpc.args[5] = (uint64_t)uid;
+    rpc.args[6] = (uint64_t)gid;
 
     // register RPC request in remote RPC fifo
@@ -1007,12 +1005,12 @@
 
     // get output values from RPC descriptor
-    *inode_xp = (xptr_t)rpc.args[8];
-    *error    = (error_t)rpc.args[9];
+    *inode_xp = (xptr_t)rpc.args[7];
+    *error    = (error_t)rpc.args[8];
 
 #if DEBUG_RPC_VFS_INODE_CREATE
 cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_VFS_INODE_CREATE )
-printk("\n[DBG] %s : thread %x in process %x on core %d exit / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid, cycle );
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
 #endif
 }
@@ -1025,6 +1023,6 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_VFS_INODE_CREATE )
-printk("\n[DBG] %s : thread %x in process %x on core %d enter / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid, cycle );
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
 #endif
 
@@ -1032,5 +1030,4 @@
     uint32_t         fs_type;
     uint32_t         inode_type;
-    void           * extend;
     uint32_t         attr;
     uint32_t         rights;
@@ -1045,12 +1042,11 @@
 
     // get input arguments from client rpc descriptor
-    dentry_xp  = (xptr_t)          hal_remote_l64( XPTR( client_cxy , &desc->args[0] ) );
-    fs_type    = (uint32_t)        hal_remote_l64( XPTR( client_cxy , &desc->args[1] ) );
-    inode_type = (uint32_t)        hal_remote_l64( XPTR( client_cxy , &desc->args[2] ) );
-    extend     = (void *)(intptr_t)hal_remote_l64( XPTR( client_cxy , &desc->args[3] ) );
-    attr       = (uint32_t)        hal_remote_l64( XPTR( client_cxy , &desc->args[4] ) );
-    rights     = (uint32_t)        hal_remote_l64( XPTR( client_cxy , &desc->args[5] ) );
-    uid        = (uid_t)           hal_remote_l64( XPTR( client_cxy , &desc->args[6] ) );
-    gid        = (gid_t)           hal_remote_l64( XPTR( client_cxy , &desc->args[7] ) );
+    dentry_xp  = (xptr_t)    hal_remote_l64( XPTR( client_cxy , &desc->args[0] ) );
+    fs_type    = (uint32_t)  hal_remote_l64( XPTR( client_cxy , &desc->args[1] ) );
+    inode_type = (uint32_t)  hal_remote_l64( XPTR( client_cxy , &desc->args[2] ) );
+    attr       = (uint32_t)  hal_remote_l64( XPTR( client_cxy , &desc->args[3] ) );
+    rights     = (uint32_t)  hal_remote_l64( XPTR( client_cxy , &desc->args[4] ) );
+    uid        = (uid_t)     hal_remote_l64( XPTR( client_cxy , &desc->args[5] ) );
+    gid        = (gid_t)     hal_remote_l64( XPTR( client_cxy , &desc->args[6] ) );
 
     // call local kernel function
@@ -1058,5 +1054,4 @@
                               fs_type,
                               inode_type,
-                              extend,
                               attr,
                               rights,
@@ -1066,12 +1061,12 @@
 
     // set output arguments
-    hal_remote_s64( XPTR( client_cxy , &desc->args[8] ) , (uint64_t)inode_xp );
-    hal_remote_s64( XPTR( client_cxy , &desc->args[9] ) , (uint64_t)error );
+    hal_remote_s64( XPTR( client_cxy , &desc->args[7] ) , (uint64_t)inode_xp );
+    hal_remote_s64( XPTR( client_cxy , &desc->args[8] ) , (uint64_t)error );
 
 #if DEBUG_RPC_VFS_INODE_CREATE
 cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_VFS_INODE_CREATE )
-printk("\n[DBG] %s : thread %x in process %x on core %d exit / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid, cycle );
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
 #endif
 }
@@ -1083,6 +1078,5 @@
 /////////////////////////////////////////////////////////////
 void rpc_vfs_inode_destroy_client( cxy_t                cxy,
-                                   struct vfs_inode_s * inode,
-                                   error_t            * error )
+                                   struct vfs_inode_s * inode )
 {
 #if DEBUG_RPC_VFS_INODE_DESTROY
@@ -1090,6 +1084,6 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_VFS_INODE_DESTROY )
-printk("\n[DBG] %s : thread %x in process %x on core %d enter / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid, cycle );
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
 #endif
 
@@ -1108,12 +1102,9 @@
     rpc_send( cxy , &rpc );
 
-    // get output argument from RPC descriptor
-    *error = (error_t)rpc.args[1];
-
 #if DEBUG_RPC_VFS_INODE_DESTROY
 cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_VFS_INODE_DESTROY )
-printk("\n[DBG] %s : thread %x in process %x on core %d exit / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid, cycle );
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
 #endif
 }
@@ -1126,10 +1117,9 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_VFS_INODE_DESTROY )
-printk("\n[DBG] %s : thread %x in process %x on core %d enter / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid, cycle );
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
 #endif
 
     vfs_inode_t * inode;
-    error_t       error;
 
     // get client cluster identifier and pointer on RPC descriptor
@@ -1137,18 +1127,15 @@
     rpc_desc_t * desc        = GET_PTR( xp );
 
-    // get arguments "inode" from client RPC descriptor
+    // get argument "inode" from client RPC descriptor
     inode = (vfs_inode_t *)(intptr_t)hal_remote_l64( XPTR( client_cxy , &desc->args[0] ) );
                        
     // call local kernel function
-    error = vfs_inode_destroy( inode );
-
-    // set output argument
-    hal_remote_s64( XPTR( client_cxy , &desc->args[1] ) , (uint64_t)error );
+    vfs_inode_destroy( inode );
 
 #if DEBUG_RPC_VFS_INODE_DESTROY
 cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_VFS_INODE_DESTROY )
-printk("\n[DBG] %s : thread %x in process %x on core %d exit / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid, cycle );
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
 #endif
 }
@@ -1170,6 +1157,6 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_VFS_DENTRY_CREATE )
-printk("\n[DBG] %s : thread %x in process %x on core %d enter / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid, cycle );
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
 #endif
 
@@ -1197,6 +1184,6 @@
 cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_VFS_DENTRY_CREATE )
-printk("\n[DBG] %s : thread %x in process %x on core %d exit / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid, cycle );
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
 #endif
 }
@@ -1209,6 +1196,6 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_VFS_DENTRY_CREATE )
-printk("\n[DBG] %s : thread %x in process %x on core %d enter / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid , cycle );
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
 #endif
 
@@ -1245,6 +1232,6 @@
 cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_VFS_DENTRY_CREATE )
-printk("\n[DBG] %s : thread %x in process %x on core %d exit / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid, cycle );
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
 #endif
 }
@@ -1256,6 +1243,5 @@
 ///////////////////////////////////////////////////////
 void rpc_vfs_dentry_destroy_client( cxy_t          cxy,
-                                    vfs_dentry_t * dentry,
-                                    error_t      * error )
+                                    vfs_dentry_t * dentry )
 {
 #if DEBUG_RPC_VFS_DENTRY_DESTROY
@@ -1263,6 +1249,6 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_VFS_DENTRY_DESTROY )
-printk("\n[DBG] %s : thread %x in process %x on core %d enter / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid , cycle );
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
 #endif
 
@@ -1281,12 +1267,9 @@
     rpc_send( cxy , &rpc );
 
-    // get output argument from RPC descriptor
-    *error = (error_t)rpc.args[1];
-
 #if DEBUG_RPC_VFS_DENTRY_DESTROY
 cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_VFS_DENTRY_DESTROY )
-printk("\n[DBG] %s : thread %x in process %x on core %d exit / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid, cycle );
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
 #endif
 }
@@ -1299,10 +1282,9 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_VFS_DENTRY_DESTROY )
-printk("\n[DBG] %s : thread %x in process %x on core %d enter / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid , cycle );
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
 #endif
 
     vfs_dentry_t * dentry;
-    error_t        error;
 
     // get client cluster identifier and pointer on RPC descriptor
@@ -1314,14 +1296,11 @@
                        
     // call local kernel function
-    error = vfs_dentry_destroy( dentry );
-
-    // set output argument
-    hal_remote_s64( XPTR( client_cxy , &desc->args[1] ) , (uint64_t)error );
+    vfs_dentry_destroy( dentry );
 
 #if DEBUG_RPC_VFS_DENTRY_DESTROY
 cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_VFS_DENTRY_DESTROY )
-printk("\n[DBG] %s : thread %x in process %x on core %d exit / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid, cycle );
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
 #endif
 }
@@ -1343,6 +1322,6 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_VFS_FILE_CREATE )
-printk("\n[DBG] %s : thread %x in process %x on core %d enter / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid , cycle );
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
 #endif
 
@@ -1369,6 +1348,6 @@
 cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_VFS_FILE_CREATE )
-printk("\n[DBG] %s : thread %x in process %x on core %d exit / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid, cycle );
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
 #endif
 }
@@ -1381,6 +1360,6 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_VFS_FILE_CREATE )
-printk("\n[DBG] %s : thread %x in process %x on core %d enter / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid , cycle );
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
 #endif
 
@@ -1410,6 +1389,6 @@
 cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_VFS_FILE_CREATE )
-printk("\n[DBG] %s : thread %x in process %x on core %d exit / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid, cycle );
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
 #endif
 }
@@ -1427,6 +1406,6 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_VFS_FILE_DESTROY )
-printk("\n[DBG] %s : thread %x in process %x on core %d enter / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid , cycle );
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
 #endif
 
@@ -1448,6 +1427,6 @@
 cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_VFS_FILE_DESTROY )
-printk("\n[DBG] %s : thread %x in process %x on core %d exit / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid, cycle );
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
 #endif
 }
@@ -1460,6 +1439,6 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_VFS_FILE_DESTROY )
-printk("\n[DBG] %s : thread %x in process %x on core %d enter / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid , cycle );
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
 #endif
 
@@ -1479,25 +1458,33 @@
 cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_VFS_FILE_DESTROY )
-printk("\n[DBG] %s : thread %x in process %x on core %d exit / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid, cycle );
-#endif
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////
-// [16]          Marshaling functions attached to RPC_VFS_INODE_LOAD   (blocking)
-/////////////////////////////////////////////////////////////////////////////////////////
-
-//////////////////////////////////////////////////
-void rpc_vfs_inode_load_client( cxy_t         cxy,
-                                vfs_inode_t * parent_inode,    // in
-                                char        * name,            // in
-                                xptr_t        child_inode_xp,  // in
-                                error_t     * error )          // out
-{
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
+#endif
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// [16]      Marshaling functions attached to RPC_VFS_FS_CHILD_INIT  (blocking)
+/////////////////////////////////////////////////////////////////////////////////////////
+
+/////////////////////////////////////////////////////////
+void rpc_vfs_fs_child_init_client( cxy_t         cxy,
+                                   vfs_inode_t * parent_inode,    // in
+                                   char        * name,            // in
+                                   xptr_t        child_inode_xp,  // in
+                                   error_t     * error )          // out
+{
+#if DEBUG_RPC_VFS_FS_CHILD_INIT
+thread_t * this = CURRENT_THREAD;
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VFS_FS_CHILD_INIT )
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+
     assert( (cxy != local_cxy) , "target cluster is not remote\n");
 
     // initialise RPC descriptor header 
     rpc_desc_t  rpc;
-    rpc.index    = RPC_VFS_INODE_LOAD;
+    rpc.index    = RPC_VFS_FS_CHILD_INIT;
     rpc.blocking = true;
     rpc.responses = 1;
@@ -1514,9 +1501,23 @@
     *error   = (error_t)rpc.args[3];
 
-}
-
-///////////////////////////////////////////
-void rpc_vfs_inode_load_server( xptr_t xp )
-{
+#if DEBUG_RPC_VFS_FS_CHILD_INIT
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VFS_FS_CHILD_INIT )
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+}
+
+//////////////////////////////////////////////
+void rpc_vfs_fs_child_init_server( xptr_t xp )
+{
+#if DEBUG_RPC_VFS_FS_CHILD_INIT
+thread_t * this = CURRENT_THREAD;
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VFS_FS_CHILD_INIT )
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+
     error_t       error;
     vfs_inode_t * parent;
@@ -1540,30 +1541,45 @@
 
     // call the kernel function
-    error = vfs_inode_load( parent , name_copy , child_xp );
+    error = vfs_fs_child_init( parent , name_copy , child_xp );
 
     // set output argument
     hal_remote_s64( XPTR( client_cxy , &desc->args[3] ) , (uint64_t)error );
 
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////
-// [17]          Marshaling functions attached to RPC_VFS_MAPPER_LOAD_ALL  (blocking)
-/////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////
-void rpc_vfs_mapper_load_all_client( cxy_t         cxy,
-                                     vfs_inode_t * inode,      // in
-                                     error_t     * error )     // out
-{
+#if DEBUG_RPC_VFS_FS_CHILD_INIT
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VFS_FS_CHILD_INIT )
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// [17]      Marshaling function attached to RPC_VFS_FS_ADD_DENTRY  (blocking)
+/////////////////////////////////////////////////////////////////////////////////////////
+
+void rpc_vfs_fs_add_dentry_client( cxy_t          cxy,
+                                   vfs_inode_t  * parent,     // in
+                                   vfs_dentry_t * dentry,     // in
+                                   error_t      * error )     // out
+{
+#if DEBUG_RPC_VFS_FS_ADD_DENTRY
+thread_t * this = CURRENT_THREAD;
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VFS_FS_ADD_DENTRY )
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+
     assert( (cxy != local_cxy) , "target cluster is not remote\n");
 
     // initialise RPC descriptor header 
     rpc_desc_t  rpc;
-    rpc.index    = RPC_VFS_MAPPER_LOAD_ALL;
+    rpc.index    = RPC_VFS_FS_ADD_DENTRY;
     rpc.blocking = true;
     rpc.responses = 1;
 
     // set input arguments in RPC descriptor 
-    rpc.args[0] = (uint64_t)(intptr_t)inode;
+    rpc.args[0] = (uint64_t)(intptr_t)parent;
+    rpc.args[1] = (uint64_t)(intptr_t)dentry;
 
     // register RPC request in remote RPC fifo
@@ -1571,13 +1587,28 @@
 
     // get output values from RPC descriptor
-    *error   = (error_t)rpc.args[1];
-
-}
-
-////////////////////////////////////////////////
-void rpc_vfs_mapper_load_all_server( xptr_t xp )
-{
-    error_t       error;
-    vfs_inode_t * inode;
+    *error   = (error_t)rpc.args[2];
+
+#if DEBUG_RPC_VFS_FS_ADD_DENTRY
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VFS_FS_ADD_DENTRY )
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+}
+
+/////////////////////////////////////////////////
+void rpc_vfs_fs_add_dentry_server( xptr_t xp )
+{
+#if DEBUG_RPC_VFS_FS_ADD_DENTRY
+thread_t * this = CURRENT_THREAD;
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VFS_FS_ADD_DENTRY )
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+
+    error_t        error;
+    vfs_inode_t  * parent;
+    vfs_dentry_t * dentry;
 
     // get client cluster identifier and pointer on RPC descriptor
@@ -1585,57 +1616,79 @@
     rpc_desc_t * desc        = GET_PTR( xp );
 
-    // get arguments "parent", "name", and "child_xp"
-    inode = (vfs_inode_t*)(intptr_t)hal_remote_l64(XPTR(client_cxy , &desc->args[0]));
+    // get input arguments
+    parent = (vfs_inode_t*)(intptr_t) hal_remote_l64(XPTR(client_cxy , &desc->args[0]));
+    dentry = (vfs_dentry_t*)(intptr_t)hal_remote_l64(XPTR(client_cxy , &desc->args[1]));
 
     // call the kernel function
-    error = vfs_mapper_load_all( inode );
+    error = vfs_fs_add_dentry( parent , dentry );
 
     // set output argument
-    hal_remote_s64( XPTR( client_cxy , &desc->args[1] ) , (uint64_t)error );
-
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////
-// [18]          Marshaling functions attached to RPC_FATFS_GET_CLUSTER  (blocking)
-/////////////////////////////////////////////////////////////////////////////////////////
-
-//////////////////////////////////////////////////
-void rpc_fatfs_get_cluster_client( cxy_t      cxy,
-                                   mapper_t * mapper,    // in
-                                   uint32_t   first,     // in
-                                   uint32_t   index,     // in
-                                   uint32_t * cluster,   // out
-                                   error_t  * error )    // out
-{
+    hal_remote_s64( XPTR( client_cxy , &desc->args[2] ) , (uint64_t)error );
+
+#if DEBUG_RPC_VFS_FS_ADD_DENTRY
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VFS_FS_ADD_DENTRY )
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// [18]      Marshaling function attached to RPC_VFS_FS_REMOVE_DENTRY  (blocking)
+/////////////////////////////////////////////////////////////////////////////////////////
+
+void rpc_vfs_fs_remove_dentry_client( cxy_t          cxy,
+                                      vfs_inode_t  * parent,     // in
+                                      vfs_dentry_t * dentry,     // in
+                                      error_t      * error )     // out
+{
+#if DEBUG_RPC_VFS_FS_REMOVE_DENTRY
+thread_t * this = CURRENT_THREAD;
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VFS_FS_REMOVE_DENTRY )
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+
     assert( (cxy != local_cxy) , "target cluster is not remote\n");
 
     // initialise RPC descriptor header 
     rpc_desc_t  rpc;
-    rpc.index    = RPC_FATFS_GET_CLUSTER;
+    rpc.index    = RPC_VFS_FS_REMOVE_DENTRY;
     rpc.blocking = true;
     rpc.responses = 1;
 
     // set input arguments in RPC descriptor 
-    rpc.args[0] = (uint64_t)(intptr_t)mapper;
-    rpc.args[1] = (uint64_t)first;
-    rpc.args[2] = (uint64_t)index;
-
-    // register RPC request in remote RPC fifo 
+    rpc.args[0] = (uint64_t)(intptr_t)parent;
+    rpc.args[1] = (uint64_t)(intptr_t)dentry;
+
+    // register RPC request in remote RPC fifo
     rpc_send( cxy , &rpc );
 
-    // get output argument from rpc descriptor
-    *cluster = (uint32_t)rpc.args[3];
-    *error   = (error_t)rpc.args[4];
-
-}
-
-//////////////////////////////////////////////
-void rpc_fatfs_get_cluster_server( xptr_t xp )
-{
-    mapper_t    * mapper;
-    uint32_t      first;
-    uint32_t      index;
-    uint32_t      cluster;
-    error_t       error;
+    // get output values from RPC descriptor
+    *error   = (error_t)rpc.args[2];
+
+#if DEBUG_RPC_VFS_FS_REMOVE_DENTRY
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VFS_FS_REMOVE_DENTRY )
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+}
+
+/////////////////////////////////////////////////
+void rpc_vfs_fs_remove_dentry_server( xptr_t xp )
+{
+#if DEBUG_RPC_VFS_FS_REMOVE_DENTRY
+thread_t * this = CURRENT_THREAD;
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VFS_FS_REMOVE_DENTRY )
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+
+    error_t        error;
+    vfs_inode_t  * parent;
+    vfs_dentry_t * dentry;
 
     // get client cluster identifier and pointer on RPC descriptor
@@ -1644,15 +1697,96 @@
 
     // get input arguments
-    mapper = (mapper_t *)(intptr_t)hal_remote_lpt( XPTR( client_cxy , &desc->args[0] ) );
-    first  = (uint32_t)            hal_remote_l32 ( XPTR( client_cxy , &desc->args[1] ) );
-    index  = (uint32_t)            hal_remote_l32 ( XPTR( client_cxy , &desc->args[2] ) );
+    parent = (vfs_inode_t*)(intptr_t) hal_remote_l64(XPTR(client_cxy , &desc->args[0]));
+    dentry = (vfs_dentry_t*)(intptr_t)hal_remote_l64(XPTR(client_cxy , &desc->args[1]));
 
     // call the kernel function
-    error = fatfs_get_cluster( mapper , first , index , &cluster );
+    error = vfs_fs_remove_dentry( parent , dentry );
 
     // set output argument
-    hal_remote_s64( XPTR( client_cxy , &desc->args[3] ) , (uint64_t)cluster );
-    hal_remote_s64( XPTR( client_cxy , &desc->args[4] ) , (uint64_t)error );
-
+    hal_remote_s64( XPTR( client_cxy , &desc->args[2] ) , (uint64_t)error );
+
+#if DEBUG_RPC_VFS_FS_REMOVE_DENTRY
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VFS_FS_REMOVE_DENTRY )
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// [19]     Marshaling functions attached to RPC_VFS_INODE_LOAD_ALL_PAGES  (blocking)
+/////////////////////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////
+void rpc_vfs_inode_load_all_pages_client( cxy_t         cxy,
+                                          vfs_inode_t * inode,      // in
+                                          error_t     * error )     // out
+{
+#if DEBUG_RPC_VFS_INODE_LOAD_ALL_PAGES
+thread_t * this = CURRENT_THREAD;
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VFS_INODE_LOAD_ALL_PAGES )
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+
+    assert( (cxy != local_cxy) , "target cluster is not remote\n");
+
+    // initialise RPC descriptor header 
+    rpc_desc_t  rpc;
+    rpc.index    = RPC_VFS_INODE_LOAD_ALL_PAGES;
+    rpc.blocking = true;
+    rpc.responses = 1;
+
+    // set input arguments in RPC descriptor 
+    rpc.args[0] = (uint64_t)(intptr_t)inode;
+
+    // register RPC request in remote RPC fifo
+    rpc_send( cxy , &rpc );
+
+    // get output values from RPC descriptor
+    *error   = (error_t)rpc.args[1];
+
+#if DEBUG_RPC_VFS_INODE_LOAD_ALL_PAGES
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VFS_INODE_LOAD_ALL_PAGES )
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+}
+
+/////////////////////////////////////////////////////
+void rpc_vfs_inode_load_all_pages_server( xptr_t xp )
+{
+#if DEBUG_RPC_VFS_INODE_LOAD_ALL_PAGES
+thread_t * this = CURRENT_THREAD;
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VFS_INODE_LOAD_ALL_PAGES )
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+
+    error_t       error;
+    vfs_inode_t * inode;
+
+    // get client cluster identifier and pointer on RPC descriptor
+    cxy_t        client_cxy  = GET_CXY( xp );
+    rpc_desc_t * desc        = GET_PTR( xp );
+
+    // get input argument
+    inode = (vfs_inode_t*)(intptr_t)hal_remote_l64(XPTR(client_cxy , &desc->args[0]));
+
+    // call the kernel function
+    error = vfs_inode_load_all_pages( inode );
+
+    // set output argument
+    hal_remote_s64( XPTR( client_cxy , &desc->args[1] ) , (uint64_t)error );
+
+#if DEBUG_RPC_VFS_INODE_LOAD_ALL_PAGES
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VFS_INODE_LOAD_ALL_PAGES )
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
 }
 
@@ -1672,6 +1806,6 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_VMM_GET_VSEG )
-printk("\n[DBG] %s : thread %x in process %x on core %d enter / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid , cycle );
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
 #endif
 
@@ -1698,6 +1832,6 @@
 cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_VMM_GET_VSEG )
-printk("\n[DBG] %s : thread %x in process %x on core %d exit / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid , cycle );
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
 #endif
 }
@@ -1710,6 +1844,6 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_VMM_GET_VSEG )
-printk("\n[DBG] %s : thread %x in process %x on core %d enter / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid , cycle );
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
 #endif
 
@@ -1739,6 +1873,6 @@
 cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_VMM_GET_VSEG )
-printk("\n[DBG] %s : thread %x in process %x on core %d exit / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid , cycle );
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
 #endif
 }
@@ -1760,6 +1894,6 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_VMM_GLOBAL_UPDATE_PTE )
-printk("\n[DBG] %s : thread %x in process %x on core %d enter / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid , cycle );
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
 #endif
 
@@ -1784,6 +1918,6 @@
 cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_VMM_GLOBAL_UPDATE_PTE )
-printk("\n[DBG] %s : thread %x in process %x on core %d exit / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid , cycle );
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
 #endif
 }
@@ -1796,6 +1930,6 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_VMM_GLOBAL_UPDATE_PTE )
-printk("\n[DBG] %s : thread %x in process %x on core %d enter / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid , cycle );
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
 #endif
 
@@ -1821,6 +1955,6 @@
 cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_VMM_GLOBAL_UPDATE_PTE )
-printk("\n[DBG] %s : thread %x in process %x on core %d exit / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid , cycle );
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
 #endif
 }
@@ -1839,6 +1973,6 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_KCM_ALLOC )
-printk("\n[DBG] %s : thread %x in process %x on core %d enter / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid , cycle );
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
 #endif
 
@@ -1863,6 +1997,6 @@
 cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_KCM_ALLOC )
-printk("\n[DBG] %s : thread %x in process %x on core %d exit / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid , cycle );
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
 #endif
 }
@@ -1875,6 +2009,6 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_KCM_ALLOC )
-printk("\n[DBG] %s : thread %x in process %x on core %d enter / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid , cycle );
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
 #endif
 
@@ -1899,6 +2033,6 @@
 cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_KCM_ALLOC )
-printk("\n[DBG] %s : thread %x in process %x on core %d exit / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid , cycle );
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
 #endif
 }   
@@ -1917,6 +2051,6 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_KCM_FREE )
-printk("\n[DBG] %s : thread %x in process %x on core %d enter / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid , cycle );
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
 #endif
 
@@ -1939,6 +2073,6 @@
 cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_KCM_FREE )
-printk("\n[DBG] %s : thread %x in process %x on core %d exit / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid , cycle );
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
 #endif
 }
@@ -1951,6 +2085,6 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_KCM_FREE )
-printk("\n[DBG] %s : thread %x in process %x on core %d enter / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid , cycle );
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
 #endif
 
@@ -1972,28 +2106,34 @@
 cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_KCM_FREE )
-printk("\n[DBG] %s : thread %x in process %x on core %d exit / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, this->core->lid , cycle );
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
 #endif
 }   
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [24]          Marshaling functions attached to RPC_MAPPER_MOVE_BUFFER
-/////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////
-void rpc_mapper_move_buffer_client( cxy_t      cxy,
-                                    mapper_t * mapper,        // in
-                                    bool_t     to_buffer,     // in
-                                    bool_t     is_user,       // in
-                                    uint32_t   file_offset,   // in
-                                    uint64_t   buffer,        // in
-                                    uint32_t   size,          // in
-                                    error_t  * error )        // out
-{
+// [24]          Marshaling functions attached to RPC_MAPPER_MOVE_USER  
+/////////////////////////////////////////////////////////////////////////////////////////
+
+/////////////////////////////////////////////////
+void rpc_mapper_move_user_client( cxy_t      cxy,
+                                  mapper_t * mapper,        // in
+                                  bool_t     to_buffer,     // in
+                                  uint32_t   file_offset,   // in
+                                  void     * buffer,        // in
+                                  uint32_t   size,          // in
+                                  error_t  * error )        // out
+{
+#if DEBUG_RPC_MAPPER_MOVE_USER
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_MAPPER_MOVE_USER )
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+
     assert( (cxy != local_cxy) , "target cluster is not remote\n");
 
     // initialise RPC descriptor header 
     rpc_desc_t  rpc;
-    rpc.index    = RPC_MAPPER_MOVE_BUFFER;
+    rpc.index    = RPC_MAPPER_MOVE_USER;
     rpc.blocking = true;
     rpc.responses = 1;
@@ -2002,8 +2142,7 @@
     rpc.args[0] = (uint64_t)(intptr_t)mapper;
     rpc.args[1] = (uint64_t)to_buffer;
-    rpc.args[2] = (uint64_t)is_user;
-    rpc.args[3] = (uint64_t)file_offset;
-    rpc.args[4] = (uint64_t)buffer;
-    rpc.args[5] = (uint64_t)size;
+    rpc.args[2] = (uint64_t)file_offset;
+    rpc.args[3] = (uint64_t)(intptr_t)buffer;
+    rpc.args[4] = (uint64_t)size;
 
     // register RPC request in remote RPC fifo
@@ -2011,17 +2150,28 @@
 
     // get output values from RPC descriptor
-    *error     = (error_t)rpc.args[6];
-
-}
-
-///////////////////////////////////////////////
-void rpc_mapper_move_buffer_server( xptr_t xp )
-{
+    *error     = (error_t)rpc.args[5];
+
+#if DEBUG_RPC_MAPPER_MOVE_USER
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_MAPPER_MOVE_USER )
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+}
+
+/////////////////////////////////////////////
+void rpc_mapper_move_user_server( xptr_t xp )
+{
+#if DEBUG_RPC_MAPPER_MOVE_USER
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_MAPPER_MOVE_USER )
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+
     mapper_t * mapper;
     bool_t     to_buffer;
-    bool_t     is_user;
     uint32_t   file_offset;
-    void     * user_buffer;
-    xptr_t     kern_buffer;
+    void     * buffer;
     uint32_t   size;
     error_t    error;
@@ -2034,50 +2184,49 @@
     mapper      = (mapper_t *)(intptr_t)hal_remote_l64( XPTR( client_cxy , &desc->args[0] ) );
     to_buffer   =                       hal_remote_l64( XPTR( client_cxy , &desc->args[1] ) );
-    is_user     =                       hal_remote_l64( XPTR( client_cxy , &desc->args[2] ) );
-    file_offset =                       hal_remote_l64( XPTR( client_cxy , &desc->args[3] ) );
-    size        =                       hal_remote_l64( XPTR( client_cxy , &desc->args[5] ) );
+    file_offset =                       hal_remote_l64( XPTR( client_cxy , &desc->args[2] ) );
+    buffer      = (void *)(intptr_t)    hal_remote_l64( XPTR( client_cxy , &desc->args[3] ) );
+    size        =                       hal_remote_l64( XPTR( client_cxy , &desc->args[4] ) );
 
     // call local kernel function
-    if( is_user )
-    {
-        user_buffer = (void *)(intptr_t)hal_remote_l64( XPTR( client_cxy , &desc->args[4] ) );
-
-        error = mapper_move_user( mapper,
-                                  to_buffer,
-                                  file_offset,
-                                  user_buffer,
-                                  size );
-    }
-    else
-    {
-        kern_buffer = (xptr_t)hal_remote_l64( XPTR( client_cxy , &desc->args[4] ) );
-
-        error = mapper_move_kernel( mapper,
-                                    to_buffer,
-                                    file_offset,
-                                    kern_buffer,
-                                    size );
-    }
+    error = mapper_move_user( mapper,
+                              to_buffer,
+                              file_offset,
+                              buffer,
+                              size );
 
     // set output argument to client RPC descriptor
     hal_remote_s64( XPTR( client_cxy , &desc->args[6] ) , (uint64_t)error );
 
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////
-// [25]          Marshaling functions attached to RPC_MAPPER_GET_PAGE (blocking)
-/////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////
-void rpc_mapper_get_page_client( cxy_t             cxy,
-                                 struct mapper_s * mapper,     // in
-                                 uint32_t          index,      // in
-                                 page_t         ** page )      // out
-{
+#if DEBUG_RPC_MAPPER_MOVE_USER
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_MAPPER_MOVE_USER )
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// [25]          Marshaling functions attached to RPC_MAPPER_HANDLE_MISS (blocking)
+/////////////////////////////////////////////////////////////////////////////////////////
+
+//////////////////////////////////////////////////////////
+void rpc_mapper_handle_miss_client( cxy_t             cxy,
+                                    struct mapper_s * mapper,
+                                    uint32_t          page_id,
+                                    xptr_t          * page_xp,
+                                    error_t         * error )
+{
+#if DEBUG_RPC_MAPPER_HANDLE_MISS
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_MAPPER_HANDLE_MISS )
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+
     assert( (cxy != local_cxy) , "target cluster is not remote\n");
 
     // initialise RPC descriptor header 
     rpc_desc_t  rpc;
-    rpc.index    = RPC_MAPPER_GET_PAGE;
+    rpc.index    = RPC_MAPPER_HANDLE_MISS;
     rpc.blocking = true;
     rpc.responses = 1;
@@ -2085,5 +2234,5 @@
     // set input arguments in RPC descriptor 
     rpc.args[0] = (uint64_t)(intptr_t)mapper;
-    rpc.args[1] = (uint64_t)index;
+    rpc.args[1] = (uint64_t)page_id;
 
     // register RPC request in remote RPC fifo
@@ -2091,29 +2240,61 @@
 
     // get output values from RPC descriptor
-    *page = (page_t *)(intptr_t)rpc.args[2];
-
-}
-
-////////////////////////////////////////////
-void rpc_mapper_get_page_server( xptr_t xp )
-{
+    *page_xp = (xptr_t)rpc.args[2];
+    *error   = (error_t)rpc.args[3];
+
+#if DEBUG_RPC_MAPPER_HANDLE_MISS
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_MAPPER_HANDLE_MISS )
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+}
+
+///////////////////////////////////////////////
+void rpc_mapper_handle_miss_server( xptr_t xp )
+{
+#if DEBUG_RPC_MAPPER_HANDLE_MISS
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_MAPPER_HANDLE_MISS )
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+
+    mapper_t * mapper;
+    uint32_t   page_id;
+    xptr_t     page_xp;
+    error_t    error;
+
     // get client cluster identifier and pointer on RPC descriptor
-    cxy_t        cxy  = GET_CXY( xp );
-    rpc_desc_t * desc = GET_PTR( xp );
-
-    // get input arguments from client RPC descriptor
-    mapper_t * mapper = (mapper_t *)(intptr_t)hal_remote_l64( XPTR( cxy , &desc->args[0] ) );
-    uint32_t   index  = (uint32_t)            hal_remote_l64( XPTR( cxy , &desc->args[1] ) );
-    
-    // call local pmem allocator
-    page_t * page = mapper_get_page( mapper , index ); 
-
-    // set output arguments into client RPC descriptor
-    hal_remote_s64( XPTR( cxy , &desc->args[1] ) , (uint64_t)(intptr_t)page );
-
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////
-// [26]          Marshaling functions attached to RPC_VMM_CREATE_VSEG (blocking)
+    cxy_t        client_cxy  = GET_CXY( xp );
+    rpc_desc_t * desc        = GET_PTR( xp );
+
+    // get arguments from client RPC descriptor
+    mapper  = (mapper_t *)(intptr_t)hal_remote_l64( XPTR( client_cxy , &desc->args[0] ) );
+    page_id =                       hal_remote_l64( XPTR( client_cxy , &desc->args[1] ) );
+
+    // call local kernel function
+    error = mapper_handle_miss( mapper,
+                                page_id,
+                                &page_xp );
+
+    // set output argument to client RPC descriptor
+    hal_remote_s64( XPTR( client_cxy , &desc->args[2] ) , (uint64_t)error );
+    hal_remote_s64( XPTR( client_cxy , &desc->args[3] ) , (uint64_t)page_xp );
+
+#if DEBUG_RPC_MAPPER_HANDLE_MISS
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_MAPPER_HANDLE_MISS )
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// [26]         undefined slot
+/////////////////////////////////////////////////////////////////////////////////////////
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// [27]          Marshaling functions attached to RPC_VMM_CREATE_VSEG (blocking)
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -2189,8 +2370,4 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [27]         undefined slot
-/////////////////////////////////////////////////////////////////////////////////////////
-
-/////////////////////////////////////////////////////////////////////////////////////////
 // [28]          Marshaling functions attached to RPC_VMM_SET_COW (blocking)
 /////////////////////////////////////////////////////////////////////////////////////////
