source: trunk/kernel/kern/cluster.h @ 211

Last change on this file since 211 was 188, checked in by alain, 7 years ago

Redefine the PIC device API.
File size: 14.6 KB
RevLine 
[1]1/*
2 * cluster.h - Cluster-Manager definition
[19]3 *
[1]4 * authors  Ghassan Almaless (2008,2009,2010,2011,2012)
5 *          Mohamed Lamine Karaoui (2015)
[23]6 *          Alain Greiner (2016,2017)
[1]7 *
8 * Copyright (c) UPMC Sorbonne Universites
9 *
10 * This file is part of ALMOS-MKH.
11 *
12 * ALMOS-MKH is free software; you can redistribute it and/or modify it
13 * under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; version 2.0 of the License.
15 *
16 * ALMOS-MKH is distributed in the hope that it will be useful, but
17 * WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19 * General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with ALMOS-MKH; if not, write to the Free Software Foundation,
23 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
24 */
25
26#ifndef _CLUSTER_H_
27#define _CLUSTER_H_
28
[14]29#include <kernel_config.h>
[1]30#include <hal_types.h>
31#include <bits.h>
32#include <spinlock.h>
33#include <readlock.h>
34#include <remote_barrier.h>
35#include <list.h>
36#include <xlist.h>
37#include <dqdt.h>
38#include <kmem.h>
39#include <hal_atomic.h>
40#include <ppm.h>
41#include <kcm.h>
42#include <khm.h>
43#include <rpc.h>
44#include <core.h>
45#include <process.h>
46
47/**** Forward declarations  ****/
48
49struct core_s;
50struct process_s;
51
52
53/*******************************************************************************************
54 * This structure defines the process manager, that is part of the cluster manager.
55 * For any process P, the process descriptor is replicated in all clusters containing
[19]56 * at least one thread of process P, but only the "reference" cluster descriptor contains
[23]57 * the reference (complete) GPT, VSL, and FDT structures.
58 * The "owner" cluster K is in charge to allocate a lpid (local process index),
59 * to the owned processes, and to register the "reference" cluster for these processes.
[1]60 *
[19]61 * Warning : the "owner" cluster, and the "reference" cluster can be different clusters.
[1]62 *
63 * The process manager of a cluster K maintains three structures:
[23]64 * 1) The pref_tbl[] is an array indexed by lpid. There is one entry per owned process.
[1]65 *    Each entry contains an extended pointer on the reference process descriptor.
[23]66 *
[1]67 * 2) The local_root is the root of the local list of process descriptors in cluster K.
68 *    A process descriptor P is present in K, as soon as P has a thread in cluster K.
[23]69 *
70 * 3) The copies_root[] array is indexed by lpid. There is one entry per owned process,
71 *    and each each entry contains the root of the xlist of copies for this process.
[1]72 ******************************************************************************************/
73
74typedef struct process_manager_s
75{
76        xptr_t            pref_tbl[CONFIG_MAX_PROCESS_PER_CLUSTER];  /*! reference  process   */
77        spinlock_t        pref_lock;              /*! lock protecting lpid allocation/release */
78    uint32_t          pref_nr;                /*! number of processes owned by cluster    */
79
[23]80    xlist_entry_t     local_root;             /*! root of list of process in cluster      */
81    remote_spinlock_t local_lock;             /*! lock protecting access to local list    */
[1]82    uint32_t          local_nr;               /*! number of process in cluster            */
83
[19]84    xlist_entry_t     copies_root[CONFIG_MAX_PROCESS_PER_CLUSTER];  /*! roots of lists    */
[1]85    remote_spinlock_t copies_lock[CONFIG_MAX_PROCESS_PER_CLUSTER];  /*! one lock per list */
86    uint32_t          copies_nr[CONFIG_MAX_PROCESS_PER_CLUSTER];    /*! number of copies  */
87}
88pmgr_t;
89
90/*******************************************************************************************
91 * This structure defines a cluster manager.
[19]92 * It contains both global platform information, and cluster specific resources
[1]93 * managed by the local kernel instance.
94 ******************************************************************************************/
95
96typedef struct cluster_s
97{
[23]98        spinlock_t        kcm_lock;        /*! local, protect creation of KCM allocators      */
[1]99
100    // global parameters
101
[23]102        uint32_t          paddr_width;     /*! numer of bits in physical address              */
103    uint32_t          x_width;         /*! number of bits to code x_size  (can be 0)      */
104    uint32_t          y_width;         /*! number of bits to code y_size  (can be 0)      */
105        uint32_t          x_size;          /*! number of clusters in a row    (can be 1)      */
106        uint32_t          y_size;          /*! number of clusters in a column (can be 1)      */
107        cxy_t             io_cxy;          /*! io cluster identifier                          */
108    uint32_t          dqdt_root_level; /*! index of root node in dqdt_tbl[]               */
[1]109
110    // local parameters
111
[23]112        uint32_t          cores_nr;        /*! number of cores in cluster                     */
113    uint32_t          cores_in_kernel; /*! number of cores currently in kernel mode       */
[1]114
[5]115        core_t            core_tbl[CONFIG_MAX_LOCAL_CORES];         /*! embedded cores        */
[1]116
[23]117        ppm_t             ppm;             /*! embedded kernel page manager                   */
118        khm_t             khm;             /*! embedded kernel heap manager                   */
119        kcm_t             kcm;             /*! embedded kernel cache manager (for KCMs)       */
[1]120
121    kcm_t           * kcm_tbl[KMEM_TYPES_NR];         /*! pointers on allocated KCMs      */
122
[23]123    uint32_t          ram_size;        /*! physical memory size                           */
124    uint32_t          ram_base;        /*! physical memory base (local address)           */
[1]125
[23]126        rpc_fifo_t        rpc_fifo;        /*! cluster RPC fifo (shared)                      */
127        list_entry_t      devlist;         /*! root of list of devices in cluster             */
[1]128
[23]129    int32_t           pages_var;       /*! pages number increment from last DQQT update   */
130    int32_t           threads_var;     /*! threads number increment from last DQDT update */
[1]131
132        dqdt_node_t       dqdt_tbl[CONFIG_MAX_DQDT_DEPTH];     /*! embedded DQDT nodes        */
133
[23]134    pmgr_t            pmgr;            /*! embedded process manager                       */
[188]135
136    void            * pic_extend;      /*! PIC implementation specific extension          */
[19]137}
[1]138cluster_t;
139
140/******************************************************************************************
141 * This global variable is allocated in the kernel_init.c file.
[19]142 * There is one cluster_manager per cluster, with the same local address,
143 * but different content, in all clusters containing a kernel instance.
[1]144 *****************************************************************************************/
145
146extern cluster_t cluster_manager;
147
148/******************************************************************************************
149 * This macro returns a local pointer on the local cluster manager.
150 *****************************************************************************************/
151
152#define LOCAL_CLUSTER    (&cluster_manager)
153
154/******************************************************************************************
[19]155 * This generic function initialises the local cluster manager from information found
[1]156 * in the local boot-info structure. It initializes the following local resources:
157 * - the global platform parameters,
158 * - the specific cluster parameters,
159 * - the lock protecting KCM creation,
160 * - the local DQDT nodes,
161 * - the PPM, KHM, and KCM allocators,
162 * - the local core descriptors,
163 * - the local RPC FIFO,
164 * - the process manager.
165 * It does NOT initialise the local device descriptors.
166 ******************************************************************************************
167 * @ info : pointer on the local boot_info_t structure build by the bootloader.
168 *****************************************************************************************/
[19]169error_t cluster_init( boot_info_t * info );
[1]170
171/******************************************************************************************
[19]172 * This function checks the validity of a cluster identifier. TODO useful ??? [AG]
[1]173 ******************************************************************************************
174 * @ cxy    : cluster identifier to be checked.
175 * @ returns true if the identified cluster does not exist.
176 *****************************************************************************************/
177bool_t cluster_is_undefined( cxy_t cxy );
178
179/******************************************************************************************
180 * This function register sysfs information in cluster TODO ???  [AG]
181 *****************************************************************************************/
182void cluster_sysfs_register();
183
184
185/*****************************************************************************************/
186/***************   Process Management Operations   ***************************************/
187/*****************************************************************************************/
188
189/******************************************************************************************
190 * This function returns an extended pointer on the reference process descriptor
[101]191 * from the process PID. This PID can be be different from the calling process PID.
[23]192 * It can be called by any thread running in any cluster,
[1]193 ******************************************************************************************
194 * @ pid  : process identifier.
[23]195 * @ return extended pointer on reference process if success / return XPTR_NULL if error.
[1]196 *****************************************************************************************/
197xptr_t cluster_get_reference_process_from_pid( pid_t pid );
198
[19]199/******************************************************************************************
[1]200 * This function allocates a new PID in local cluster, that becomes the process owner.
[19]201 * It registers the process descriptor extended pointer in the local processs manager
[1]202 * pref_tbl[] array. This function is called by the rpc_process_alloc_pid() function for
203 * remote registration, or by the process_init_create() function for local registration.
204 ******************************************************************************************
205 * @ process    : [in]  extended pointer on the process descriptor.
206 * @ pid        : [out] allocated PID.
[19]207 * @ return 0 if success / return EAGAIN if no PID slot available
[1]208 *****************************************************************************************/
209error_t cluster_pid_alloc( xptr_t    process_xp,
210                           pid_t   * pid );
211
[19]212/******************************************************************************************
[1]213 * This function removes a PID from the local process manager pref_tbl[] array.
214 * It checks that removed process is owned by the local cluster and the lpid is legal.
215 * No memory is released by this function.
216 ******************************************************************************************
217 * @ pid        : allocated PID.
218 *****************************************************************************************/
219void cluster_pid_release( pid_t  pid );
220
221/******************************************************************************************
222 * This function returns a pointer on the local process descriptor from the PID.
223 * It uses the RPC
224 * to create a local process descriptor copy if it does not exist yet.
225 ******************************************************************************************
226 * @ pid     : searched process identifier.
227 * @ returns process descriptor pointer if found / returns NULL if not found.
228 *****************************************************************************************/
229struct process_s * cluster_get_local_process_from_pid( pid_t pid );
230
231/******************************************************************************************
232 * This function registers a local process descriptor in the process manager local_list.
233 ******************************************************************************************
234 * @ process     : pointer on local process descriptor.
235 *****************************************************************************************/
[19]236void cluster_process_local_link( struct process_s * process );
[1]237
238/******************************************************************************************
239 * This function removes a local process descriptor from the process manager local_list.
240 ******************************************************************************************
241 * @ process     : pointer on local process descriptor.
242 *****************************************************************************************/
[19]243void cluster_process_local_unlink( struct process_s * process );
[1]244
245/******************************************************************************************
246 * This function registers a local process descriptor in the owner process manager
247 * copies_list, that can be in a remote cluster.
248 ******************************************************************************************
249 * @ process     : pointer on local process descriptor.
250 *****************************************************************************************/
[19]251void cluster_process_copies_link( struct process_s * process );
[1]252
253/******************************************************************************************
254 * This function removes a local process descriptor from the owner process manager
255 * copies_list, that can be in a remote cluster.
256 ******************************************************************************************
257 * @ process     : pointer on local process descriptor.
258 *****************************************************************************************/
[19]259void cluster_process_copies_unlink( struct process_s * process );
[1]260
261
262
263/*****************************************************************************************/
264/***************   Cores Management Operations   *****************************************/
265/*****************************************************************************************/
266
267/******************************************************************************************
268 * This function increments the "cores_in_kernel" variable in cluster descriptor.
269 *****************************************************************************************/
270void cluster_core_kernel_enter();
271
272/******************************************************************************************
273 * This function decrements the "cores_in_kernel" variable in cluster descriptor.
274 *****************************************************************************************/
275void cluster_core_kernel_exit();
276
277/******************************************************************************************
278 * This function returns the core local index that has the lowest usage in local cluster.
279 *****************************************************************************************/
280lid_t cluster_select_local_core();
281
282#endif  /* _CLUSTER_H_ */
Note: See TracBrowser for help on using the repository browser.