source: trunk/kernel/kern/rpc.h @ 625

Last change on this file since 625 was 625, checked in by alain, 2 years ago

Fix a bug in the vmm_remove_vseg() function: the physical pages
associated to an user DATA vseg were released to the kernel when
the target process descriptor was in the reference cluster.
This physical pages release should be done only when the page
forks counter value is zero.
All other modifications are cosmetic.

File size: 36.4 KB
Line 
1/*
2 * rpc.h - RPC (Remote Procedure Call) operations definition.
3 *
4 * Author  Alain Greiner (2016,2017,2018)
5 *
6 * Copyright (c) UPMC Sorbonne Universites
7 *
8 * This file is part of ALMOS-MKH.
9 *
10 * ALMOS-MKH is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; version 2.0 of the License.
13 *
14 * ALMOS-MKH is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17 * General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with ALMOS-MKH; if not, write to the Free Software Foundation,
21 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22 */
23
24#ifndef _RPC_H_
25#define _RPC_H_
26
27#include <kernel_config.h>
28#include <hal_kernel_types.h>
29#include <hal_atomic.h>
30#include <bits.h>
31#include <vseg.h>
32#include <remote_fifo.h>
33
34/**** Forward declarations ****/
35
36struct process_s;
37struct page_s;
38struct vseg_s;
39struct exec_info_s;
40struct pthread_attr_s;
41struct remote_sem_s;
42struct user_dir_s;
43struct fragment_s;
44struct vfs_inode_s;
45struct vfs_dentry_s;
46struct vfs_file_s;
47struct thread_s;
48struct mapper_s;
49
50
51/**********************************************************************************/
52/**************  structures for Remote Procedure Calls ****************************/
53/**********************************************************************************/
54
55/***********************************************************************************
56 * This enum defines all RPC indexes.
57 * It must be consistent with the rpc_server[] arrays defined in in the rpc.c file.
58 **********************************************************************************/
59
60typedef enum
61{
62    RPC_PMEM_GET_PAGES            = 0,
63    RPC_PMEM_RELEASE_PAGES        = 1,
64    RPC_PPM_DISPLAY               = 2,     
65    RPC_PROCESS_MAKE_FORK         = 3,
66    RPC_USER_DIR_CREATE           = 4,
67    RPC_USER_DIR_DESTROY          = 5,
68    RPC_THREAD_USER_CREATE        = 6,
69    RPC_THREAD_KERNEL_CREATE      = 7,
70    RPC_VFS_FS_UPDATE_DENTRY      = 8,
71    RPC_PROCESS_SIGACTION         = 9,
72
73    RPC_VFS_INODE_CREATE          = 10,
74    RPC_VFS_INODE_DESTROY         = 11,
75    RPC_VFS_DENTRY_CREATE         = 12,
76    RPC_VFS_DENTRY_DESTROY        = 13,
77    RPC_VFS_FILE_CREATE           = 14,
78    RPC_VFS_FILE_DESTROY          = 15,
79    RPC_VFS_FS_GET_DENTRY         = 16,
80    RPC_VFS_FS_ADD_DENTRY         = 17,
81    RPC_VFS_FS_REMOVE_DENTRY      = 18,
82    RPC_VFS_INODE_LOAD_ALL_PAGES  = 19,
83
84    RPC_VMM_GET_VSEG              = 20,
85    RPC_VMM_GLOBAL_UPDATE_PTE     = 21,
86    RPC_KCM_ALLOC                 = 22,
87    RPC_KCM_FREE                  = 23,
88    RPC_MAPPER_SYNC               = 24,
89    RPC_MAPPER_HANDLE_MISS        = 25,
90    RPC_VMM_DELETE_VSEG           = 26,
91    RPC_VMM_CREATE_VSEG           = 27,
92    RPC_VMM_SET_COW               = 28,
93    RPC_VMM_DISPLAY               = 29,
94
95    RPC_MAX_INDEX                 = 30,
96}
97rpc_index_t;
98
99/***********************************************************************************
100 * This defines the prototype of the rpc_server functions,
101 * defined by the rpc_server[] array in the rpc.c file.
102 **********************************************************************************/
103
104typedef  void (rpc_server_t) ( xptr_t xp );
105
106/***********************************************************************************
107 *  This structure defines the RPC descriptor (100 bytes on a 32bits core)
108 **********************************************************************************/
109
110typedef struct rpc_desc_s
111{
112        rpc_index_t         index;       /*! index of requested RPC service      ( 4) */
113        uint32_t          * rsp;         /*! local pointer ond responses counter ( 4) */
114    struct thread_s   * thread;      /*! local pointer on client thread      ( 4) */
115    uint32_t            lid;         /*! index of core running client thread ( 4) */ 
116    bool_t              blocking;    /*! simple RPC mode when true           ( 4) */
117    uint64_t            args[10];    /*! input/output arguments buffer       (80) */
118} 
119rpc_desc_t;
120
121/**********************************************************************************/
122/******* Generic functions supporting RPCs : client side **************************/
123/**********************************************************************************/
124
125/***********************************************************************************
126 * This function is executed by the client thread in the client cluster.
127 * It puts one RPC descriptor defined by the <desc> argument in the remote fifo
128 * defined by the <cxy> argument.  It sends an IPI to the server if fifo is empty.
129 * The RPC descriptor must be allocated in the caller's stack, and initialised by
130 * the caller. It exit with a Panic message if remote fifo is still full after
131 * (CONFIG_RPC_PUT_MAX_ITERATIONS) retries.
132 * - When the RPC <blocking> field is true, this function blocks and deschedule.
133 *   It returns only when the server acknowledges the RPC by writing in the RPC
134 *   "response" field, and unblocks the client.
135 * - When the <blocking> field is false, this function returns as soon as the RPC
136 *   has been registered in the FIFO, and the server thread must directly signal
137 *   completion to the client thread.
138 ***********************************************************************************
139 * @ cxy   : server cluster identifier
140 * @ desc  : local pointer on RPC descriptor in client cluster
141 **********************************************************************************/
142void rpc_send( cxy_t        cxy,   
143               rpc_desc_t * desc );
144
145
146
147/**********************************************************************************/
148/******* Generic functions supporting RPCs : server side **************************/
149/**********************************************************************************/
150
151/***********************************************************************************
152 * This function contains the infinite loop executed by a RPC server thread,
153 * to handle pending RPCs registered in the RPC fifo attached to a given core.
154 * In each iteration in this loop, it try to handle one RPC request:
155 * - it tries to take the RPC FIFO ownership,
156 * - it consumes one request when the FIFO is not empty,
157 * - it releases the FIFO ownership,
158 * - it execute the requested service,
159 * - it unblock and send an IPI to the client thread,
160 * - it suicides if the number of RPC threads for this core is to large,
161 * - it block on IDLE and deschedule otherwise. 
162 **********************************************************************************/
163void rpc_server_func( void );
164
165/***********************************************************************************
166 * This function is executed in case of illegal RPC index.
167 **********************************************************************************/
168void __attribute__((noinline)) rpc_undefined( xptr_t xp __attribute__ ((unused)) );
169
170
171
172/**********************************************************************************/
173/******* Marshalling functions attached to the various RPCs ***********************/
174/**********************************************************************************/
175
176/***********************************************************************************
177 * [0] The RPC_PMEM_GET_PAGES allocates one or several pages in a remote cluster,
178 * and returns the local pointer on the page descriptor.
179 ***********************************************************************************
180 * @ cxy     : server cluster identifier
181 * @ order   : [in]  ln2( number of requested pages )
182 * @ page    : [out] local pointer on page descriptor / NULL if failure
183 **********************************************************************************/
184void rpc_pmem_get_pages_client( cxy_t             cxy,
185                                uint32_t          order,
186                                struct page_s  ** page );
187
188void rpc_pmem_get_pages_server( xptr_t xp );
189
190/***********************************************************************************
191 * [1] The RPC_PMEM_RELEASE_PAGES release one or several pages to a remote cluster.
192 ***********************************************************************************
193 * @ cxy     : server cluster identifier
194 * @ page    : [in] local pointer on page descriptor to release.
195 **********************************************************************************/
196void rpc_pmem_release_pages_client( cxy_t            cxy,
197                                    struct page_s  * page );
198
199void rpc_pmem_release_pages_server( xptr_t xp );
200
201/***********************************************************************************
202 * [2] The RPC_PPM_DISPLAY allows any client thread to require any remote cluster
203 * identified by the <cxy> argumentto display the physical memory allocator state.
204 **********************************************************************************/
205void rpc_ppm_display_client( cxy_t  cxy );
206
207void rpc_ppm_display_server( xptr_t xp );
208
209/***********************************************************************************
210 * [3] The RPC_PROCESS_MAKE_FORK creates a "child" process descriptor, and the
211 * associated "child" thread descriptor in a target remote cluster that can be
212 * any cluster.  The child process is initialized from informations found in the
213 * "parent" process descriptor (that must be the parent reference cluster),
214 * and from the "parent" thread descriptor that can be in any cluster.
215 ***********************************************************************************
216 * @ cxy              : server cluster identifier.
217 * @ ref_process_xp   : [in]  extended pointer on reference parent process.
218 * @ parent_thread_xp : [in]  extended pointer on parent thread.
219 * @ child_pid        : [out] child process identifier.
220 * @ child_thread_ptr : [out] local pointer on child thread.
221 * @ error            : [out]  error status (0 if success).
222 **********************************************************************************/
223void rpc_process_make_fork_client( cxy_t              cxy,
224                                   xptr_t             ref_process_xp,
225                                   xptr_t             parent_thread_xp,
226                                   pid_t            * child_pid,
227                                   struct thread_s ** child_thread_ptr,
228                                   error_t          * error );
229
230void rpc_process_make_fork_server( xptr_t xp );
231
232/***********************************************************************************
233 * [4] The RPC_USER_DIR_CREATE allows a client thread to create an user_dir_t
234 * structure and the associated array of dirents in a remote cluster containing
235 * the target directory <inode>. It creates an ANON vseg in the user reference
236 * process VMM identified by the <ref_xp>. This reference cluster cluster can be
237 * different from both the client and server clusters.
238 * It is called by the sys_opendir() function.
239 ***********************************************************************************
240 * @ cxy        : server cluster identifier.
241 * @ inode      : [in]   local pointer on inode in server cluster.
242 * @ ref_xp     : [in]   extended pointer on user reference process descriptor.
243 * @ dir        : [out]  local pointer on created user_dir structure.
244 **********************************************************************************/
245void rpc_user_dir_create_client( cxy_t                 cxy,
246                                 struct vfs_inode_s  * inode,
247                                 xptr_t                ref_xp,
248                                 struct user_dir_s  ** dir );
249
250void rpc_user_dir_create_server( xptr_t xp );
251
252/***********************************************************************************
253 * [5] The RPC_USER_DIR_DESTROY allows a client thread to delete an user_dir_t
254 * structure and the associated array of dirents in a remote cluster containing
255 * the target directory inode. It is called by the sys_closedir() function.
256 ***********************************************************************************
257 * @ cxy        : server cluster identifier.
258 * @ dir        : [in]  local pointer on created user_dir structure.
259 * @ ref_xp     : [in]   extended pointer on user reference process descriptor.
260 **********************************************************************************/
261void rpc_user_dir_destroy_client( cxy_t               cxy,
262                                  struct user_dir_s * dir,
263                                  xptr_t              ref_xp );
264
265void rpc_user_dir_destroy_server( xptr_t xp );
266
267/***********************************************************************************
268 * [6] The RPC_THREAD_USER_CREATE creates an user thread in the server cluster,
269 * as specified by the arguments. It returns an extended pointer on the new
270 * thread descriptor in server cluster, and an error code.
271 * It is called by the sys_thread_create() system call.
272 ***********************************************************************************
273 * @ cxy       : server cluster identifier.
274 * @ attr      : [in]  local pointer on pthread_attr_t in client cluster.
275 * @ thread_xp : [out] buffer for thread extended pointer.
276 * @ error     : [out] error status (0 if success).
277 **********************************************************************************/
278void rpc_thread_user_create_client( cxy_t                   cxy,
279                                    pid_t                   pid,
280                                    void                  * start_func,
281                                    void                  * start_arg,
282                                    pthread_attr_t        * attr,
283                                    xptr_t                * thread_xp,
284                                    error_t               * error );
285
286void rpc_thread_user_create_server( xptr_t xp );
287
288/***********************************************************************************
289 * [7] The RPC_THREAD_KERNEL_CREATE creates a kernel thread in the server cluster,
290 * as specified by the type, func and args arguments. It returns the local pointer
291 * on the thread descriptor in server cluster and an error code.
292 * It is used by the dev_init() function to create the device server thread.
293 ***********************************************************************************
294 * @ cxy       : server cluster identifier.
295 * @ type      : [in]  type of kernel thread.
296 * @ func      : [in]  local pointer on thread function.
297 * @ args      : [in]  local pointer on function arguments.
298 * @ thread_xp : [out] pointer on buffer for thread extended pointer.
299 * @ error     : [out] error status (0 if success).
300 **********************************************************************************/
301void rpc_thread_kernel_create_client( cxy_t     cxy,
302                                      uint32_t  type,
303                                      void    * func,
304                                      void    * args,
305                                      xptr_t  * thread_xp,
306                                      error_t * error );
307
308void rpc_thread_kernel_create_server( xptr_t xp );
309
310/***********************************************************************************
311 * [8] The RPC_VFS_FS_UPDATE_DENTRY allows a client thread to request a remote
312 * cluster to update the <size> field of a directory entry in the mapper of a
313 * remote directory inode, identified by the <inode> local pointer.
314 * The target entry name is identified by the <dentry> local pointer.
315 ***********************************************************************************
316 * @ cxy     : server cluster identifier.
317 * @ inode   : [in] local pointer on remote directory inode.
318 * @ dentry  : [in] local pointer on remote dentry.
319 * @ size    : [in] new size value.
320 * @ error   : [out] error status (0 if success).
321 **********************************************************************************/
322void rpc_vfs_fs_update_dentry_client( cxy_t                 cxy,
323                                      struct vfs_inode_s  * inode,
324                                      struct vfs_dentry_s * dentry,
325                                      uint32_t              size,
326                                      error_t             * error );
327
328void rpc_vfs_fs_update_dentry_server( xptr_t xp );
329
330/***********************************************************************************
331 * [9] The RPC_PROCESS_SIGACTION allows a client thread to request a remote cluster
332 * to execute a given sigaction, defined by the <action_type> for a given process,
333 * identified by the <pid> argument.
334 ***********************************************************************************
335 * @ cxy     : server cluster identifier.
336 * @ pid     : [in] target process identifier.
337 * @ action  : [in] sigaction index.
338 **********************************************************************************/
339void rpc_process_sigaction_client( cxy_t     cxy,
340                                   pid_t     pid,
341                                   uint32_t  action );
342                             
343void rpc_process_sigaction_server( xptr_t xp );
344
345/***********************************************************************************
346 * [10] The RPC_VFS_INODE_CREATE creates an inode and the associated mapper in a
347 * remote cluster. The parent dentry must have been previously created.
348 * It returns an extended pointer on the created inode.
349 ***********************************************************************************
350 * @ cxy        :  server cluster identifier.
351 * @ fs_type    : [in]  file system type.
352 * @ inode_type : [in]  file system type.
353 * @ attr       : [in]  inode attributes.
354 * @ rights     : [in]  access rights
355 * @ uid        : [in]  user ID
356 * @ gid        : [in]  group ID
357 * @ inode_xp   : [out] buffer for extended pointer on created inode.
358 * @ error      : [out] error status (0 if success).
359 **********************************************************************************/
360void rpc_vfs_inode_create_client( cxy_t      cxy,
361                                  uint32_t   fs_type,
362                                  uint32_t   attr,   
363                                  uint32_t   rights, 
364                                  uint32_t   uid,
365                                  uint32_t   gid,
366                                  xptr_t   * inode_xp,
367                                  error_t  * error );
368
369void rpc_vfs_inode_create_server( xptr_t xp );
370
371/***********************************************************************************
372 * [11] The RPC_VFS_INODE_DESTROY releases memory allocated for an inode descriptor
373 * and for the associated mapper in a remote cluster.
374 ***********************************************************************************
375 * @ cxy       :  server cluster identifier
376 * @ inode     : [in]  local pointer on inode.
377 **********************************************************************************/
378void rpc_vfs_inode_destroy_client( cxy_t                cxy,
379                                   struct vfs_inode_s * inode );
380
381void rpc_vfs_inode_destroy_server( xptr_t xp );
382
383/***********************************************************************************
384 * [12] The RPC_VFS_DENTRY_CREATE creates a dentry in a remote cluster.
385 * It returns an extended pointer on the created dentry.
386 ***********************************************************************************
387 * @ cxy        :  server cluster identifier
388 * @ type       : [in]  file system type.
389 * @ name       : [in]  directory entry name.
390 * @ dentry_xp  : [out] buffer for extended pointer on created dentry.
391 * @ error      : [out] error status (0 if success).
392 **********************************************************************************/
393void rpc_vfs_dentry_create_client( cxy_t                  cxy,
394                                   uint32_t               type,
395                                   char                 * name,   
396                                   xptr_t               * dentry_xp,
397                                   error_t              * error );
398
399void rpc_vfs_dentry_create_server( xptr_t xp );
400
401/***********************************************************************************
402 * [13] The RPC_VFS_DENTRY_DESTROY remove a denfry from the parent inode XHTAB,
403 * and releases memory allocated for the dentry descriptor in a remote cluster.
404 ***********************************************************************************
405 * @ cxy       :  server cluster identifier
406 * @ dentry     : [in]  local pointer on dentry.
407 **********************************************************************************/
408void rpc_vfs_dentry_destroy_client( cxy_t                 cxy,
409                                    struct vfs_dentry_s * dentry );
410
411void rpc_vfs_dentry_destroy_server( xptr_t xp );
412
413/***********************************************************************************
414 * [14] The RPC_VFS_FILE_CREATE creates a file descriptor in a remote cluster.
415 * It returns an extended pointer on the created file structure.
416 ***********************************************************************************
417 * @ cxy        :  server cluster identifier
418 * @ inode      : [in]  local pointer on parent inode.
419 * @ file_attr  : [in]  new file attributes.
420 * @ file_xp    : [out] buffer for extended pointer on created file.
421 * @ error      : [out] error status (0 if success).
422 **********************************************************************************/
423void rpc_vfs_file_create_client( cxy_t                  cxy,
424                                 struct vfs_inode_s   * inode,
425                                 uint32_t               file_attr,
426                                 xptr_t               * file_xp,
427                                 error_t              * error );
428
429void rpc_vfs_file_create_server( xptr_t xp );
430
431/***********************************************************************************
432 * [15] The RPC_VFS_FILE_DESTROY releases memory allocated for a file descriptor
433 * in a remote cluster.
434 ***********************************************************************************
435 * @ cxy       :  server cluster identifier
436 * @ file       : [in]  local pointer on file.
437 **********************************************************************************/
438void rpc_vfs_file_destroy_client( cxy_t               cxy,
439                                  struct vfs_file_s * file );
440
441void rpc_vfs_file_destroy_server( xptr_t xp );
442
443/***********************************************************************************
444 * [16] The RPC_VFS_FS_GET_DENTRY calls the vfs_fs_new_dentry()
445 * function in a remote cluster containing a parent inode directory to scan the
446 * associated mapper, find a directory entry identified by its name, and update
447 * both the - existing - child inode and dentry.
448 ***********************************************************************************
449 * @ cxy            : server cluster identifier
450 * @ parent_inode   : [in]  local pointer on parent inode.
451 * @ name           : [in]  local pointer on child name (in client cluster).
452 * @ child_inode_xp : [in]  extended pointer on child inode (in another cluster).
453 * @ error          : [out] error status (0 if success).
454 **********************************************************************************/
455void rpc_vfs_fs_new_dentry_client( cxy_t                cxy,
456                                   struct vfs_inode_s * parent_inode,
457                                   char               * name,
458                                   xptr_t               child_inode_xp,
459                                   error_t            * error );
460
461void rpc_vfs_fs_new_dentry_server( xptr_t xp );
462
463/***********************************************************************************
464 * [17] The RPC_VFS_FS_ADD_DENTRY calls the vfs_fs_add_dentry() function in a
465 * remote cluster containing a directory inode and mapper, to add a new dentry
466 * in the mapper of this directory.
467 ***********************************************************************************
468 * @ cxy            : server cluster identifier
469 * @ parent         : [in]  local pointer on directory inode.
470 * @ dentry         : [in]  local pointer on dentry.
471 * @ error          : [out] error status (0 if success).
472 **********************************************************************************/
473void rpc_vfs_fs_add_dentry_client( cxy_t,
474                                   struct vfs_inode_s  * parent,
475                                   struct vfs_dentry_s * dentry,
476                                   error_t             * error );
477
478void rpc_vfs_fs_add_dentry_server( xptr_t xp );
479
480/***********************************************************************************
481 * [18] The RPC_VFS_FS_REMOVE_DENTRY calls the vfs_fs_remove_dentry() function in a
482 * remote cluster containing a directory inode and mapper, to remove a dentry from
483 * the mapper of this directory.
484 ***********************************************************************************
485 * @ cxy            : server cluster identifier
486 * @ parent         : [in]  local pointer on directory inode.
487 * @ dentry         : [in]  local pointer on dentry.
488 * @ error          : [out] error status (0 if success).
489 **********************************************************************************/
490void rpc_vfs_fs_remove_dentry_client( cxy_t,
491                                      struct vfs_inode_s  * parent,
492                                      struct vfs_dentry_s * dentry,
493                                      error_t             * error );
494
495void rpc_vfs_fs_remove_dentry_server( xptr_t xp );
496
497/***********************************************************************************
498 * [19] The RPC_VFS_INODE_LOAD_ALL_PAGES calls the vfs_inode_load_all_pages()
499 * function a remote cluster containing an inode to load all pages in the
500 * associated mapper. 
501 ***********************************************************************************
502 * @ cxy     : server cluster identifier
503 * @ inode   : [in]  local pointer on inode in server cluster.
504 * @ error   : [out] error status (0 if success).
505 **********************************************************************************/
506void rpc_vfs_inode_load_all_pages_client( cxy_t                cxy,
507                                          struct vfs_inode_s * inode,
508                                          error_t            * error );
509
510void rpc_vfs_inode_load_all_pages_server( xptr_t xp );
511
512/***********************************************************************************
513 * [20] The RPC_VMM_GET_VSEG returns an extended pointer
514 * on the vseg containing a given virtual address in a given process.
515 * The server cluster is supposed to be the reference cluster.
516 * It returns a non zero error value if no vseg has been founded.
517 ***********************************************************************************
518 * @ cxy     : server cluster identifier.
519 * @ process : [in]   pointer on process descriptor in server cluster.
520 * @ vaddr   : [in]   virtual address to be searched.
521 * @ vseg_xp : [out]  buffer for extended pointer on vseg in client cluster.
522 * @ error   : [out] local pointer on buffer for error code (in client cluster).
523 **********************************************************************************/
524void rpc_vmm_get_vseg_client( cxy_t              cxy,
525                              struct process_s * process,
526                              intptr_t           vaddr,
527                              xptr_t           * vseg_xp,
528                              error_t          * error );
529
530void rpc_vmm_get_vseg_server( xptr_t xp );
531
532/***********************************************************************************
533 * [21] The RPC_VMM_GLOBAL_UPDATE_PTE can be used by a thread that is not running
534 * in reference cluster, to ask the reference cluster to update a specific entry,
535 * identified by the <vpn> argument in all GPT copies of a process identified by
536 * the <process> argument, using the values defined by <attr> and <ppn> arguments.
537 * The server cluster is supposed to be the reference cluster.
538 * It does not return any error code as the called function vmm_global_update_pte()
539 * cannot fail.
540 ***********************************************************************************
541 * @ cxy     : server cluster identifier.
542 * @ process : [in]  pointer on process descriptor in server cluster.
543 * @ vpn     : [in]  virtual address to be searched.
544 * @ attr    : [in]  PTE attributes.
545 * @ ppn     : [it]  PTE PPN.
546 **********************************************************************************/
547void rpc_vmm_global_update_pte_client( cxy_t              cxy,
548                                       struct process_s * process,
549                                       vpn_t              vpn,
550                                       uint32_t           attr,
551                                       ppn_t              ppn );
552
553void rpc_vmm_global_update_pte_server( xptr_t xp );
554
555/***********************************************************************************
556 * [22] The RPC_KCM_ALLOC allocates memory from a given KCM in a remote cluster,
557 * and returns an extended pointer on the allocated object.
558  It returns XPTR_NULL if physical memory cannot be allocated.
559 ***********************************************************************************
560 * @ cxy       : server cluster identifier.
561 * @ kmem_type : [in]  KCM object type (as defined in kmem.h).
562 * @ buf_xp    : [out] buffer for extended pointer on allocated buffer.
563 **********************************************************************************/
564void rpc_kcm_alloc_client( cxy_t      cxy,
565                           uint32_t   kmem_type,
566                           xptr_t   * buf_xp ); 
567
568void rpc_kcm_alloc_server( xptr_t xp );
569
570/***********************************************************************************
571 * [23] The RPC_KCM_FREE releases memory allocated for a KCM object of a given type,
572 * in a remote cluster.
573 ***********************************************************************************
574 * @ cxy       : server cluster identifier.
575 * @ buf       : [in] local pointer on allocated buffer.
576 * @ kmem_type : [in]  KCM object type (as defined in kmem.h).
577 **********************************************************************************/
578void rpc_kcm_free_client( cxy_t     cxy,
579                          void    * buf,
580                          uint32_t  kmem_type );
581
582void rpc_kcm_free_server( xptr_t xp );
583
584/***********************************************************************************
585 * [24] The RPC_MAPPER_SYNC allows a client thread to synchronize on disk
586 * all dirty pages of a remote mapper.
587 ***********************************************************************************
588 * @ cxy       : server cluster identifier.
589 * @ mapper    : [in] local pointer on mapper in server cluster.
590 * @ error       : [out] error status (0 if success).
591 **********************************************************************************/
592void rpc_mapper_sync_client( cxy_t             cxy,
593                             struct mapper_s * mapper,
594                             error_t         * error );
595
596void rpc_mapper_sync_server( xptr_t xp );
597
598/***********************************************************************************
599 * [25] The RPC__MAPPER_HANDLE_MISS allows a client thread to request a remote
600 * mapper to load a missing page from the IOC device.
601 * On the server side, this RPC call the mapper_handle_miss() function and return
602 * an extended pointer on the allocated page descriptor and an error status.
603 ***********************************************************************************
604 * @ cxy         : server cluster identifier.
605 * @ mapper      : [in]  local pointer on mapper.
606 * @ page_id     : [in]  missing page index in mapper
607 * @ buffer      : [in]  user space pointer / kernel extended pointer
608 * @ page_xp     : [out] pointer on buffer for extended pointer on page descriptor.
609 * @ error       : [out] error status (0 if success).
610 **********************************************************************************/
611void rpc_mapper_handle_miss_client( cxy_t             cxy,
612                                    struct mapper_s * mapper,
613                                    uint32_t          page_id,
614                                    xptr_t          * page_xp,
615                                    error_t         * error );
616 
617void rpc_mapper_handle_miss_server( xptr_t xp );
618
619/***********************************************************************************
620 * [26] The RPC_VMM_DELETE_VSEG allows any client thread  to request a remote
621 * cluster to delete from a given VMM, identified by the <pid> argument
622 * a given vseg, identified by the <vaddr> argument.
623 ***********************************************************************************
624 * @ cxy         : server cluster identifier.
625 * @ pid         : [in] target process identifier.
626 * @ vaddr       : [in] vseg base address.
627 **********************************************************************************/
628void rpc_vmm_delete_vseg_client( cxy_t       cxy,
629                                 pid_t       pid,
630                                 intptr_t    vaddr );
631 
632void rpc_vmm_delete_vseg_server( xptr_t xp );
633
634/***********************************************************************************
635 * [27] The RPC_VMM_CREATE_VSEG allows a client thread to request the remote
636 * reference cluster of a given process to allocate and register in the reference
637 * process VMM a new vseg descriptor.
638 * On the server side, this RPC uses the vmm_create_vseg() function, and returns
639 * to the client the local pointer on the created vseg descriptor.
640 ***********************************************************************************
641 * @ cxy         : server cluster identifier.
642 * @ process     : [in]  local pointer on process descriptor in server.
643 * @ type        : [in]  vseg type.
644 * @ base        : [in]  base address (unused for dynamically allocated vsegs).
645 * @ size        : [in]  number of bytes.
646 * @ file_offset : [in]  offset in file (for CODE, DATA, FILE types).
647 * @ file_size   : [in]  can be smaller than size for DATA type.
648 * @ mapper_xp   : [in]  extended pointer on mapper (for CODE, DATA, FILE types).
649 * @ vseg_cxy    : [in]  target cluster for mapping (if not data type).
650 * @ vseg        : [out] local pointer on vseg descriptor / NULL if failure.
651 **********************************************************************************/
652void rpc_vmm_create_vseg_client( cxy_t              cxy,
653                                 struct process_s * process,
654                                 vseg_type_t        type,
655                                 intptr_t           base,
656                                 uint32_t           size,
657                                 uint32_t           file_offset,
658                                 uint32_t           file_size,
659                                 xptr_t             mapper_xp,
660                                 cxy_t              vseg_cxy,
661                                 struct vseg_s   ** vseg );
662
663void rpc_vmm_create_vseg_server( xptr_t xp );
664
665/***********************************************************************************
666 * [28] The RPC_VMM_SET_COW allows a client thread to request the remote reference
667 * cluster to set the COW flag and reset the WRITABLE flag of all GPT entries for
668 * the DATA, MMAP and REMOTE vsegs of process identified by the <process> argument.
669
670 * of a remote scheduler, identified by the <lid> argument.
671 ***********************************************************************************
672 * @ cxy         : server cluster identifier.
673 * @ process     : [in]  local pointer on reference process descriptor.
674 **********************************************************************************/
675void rpc_vmm_set_cow_client( cxy_t              cxy,
676                             struct process_s * process );
677
678void rpc_vmm_set_cow_server( xptr_t xp );
679
680/***********************************************************************************
681 * [29] The RPC_VMM_DISPLAY allows any client thread to display the VMM state
682 * of a remote reference process identified by the <cxy> and <process> arguments.
683 * The type of display is defined by the <detailed> boolean argument.
684 ***********************************************************************************
685 * @ cxy         : server cluster identifier.
686 * @ process     : [in]  local pointer on reference process descriptor.
687 * @ detailed    : [in]  detailed display if true.
688 **********************************************************************************/
689void rpc_hal_vmm_display_client( cxy_t              cxy,
690                             struct process_s * process,
691                             bool_t             detailed );
692
693void rpc_hal_vmm_display_server( xptr_t xp );
694
695
696#endif
Note: See TracBrowser for help on using the repository browser.