source: trunk/kernel/kern/scheduler.h @ 408

Last change on this file since 408 was 408, checked in by alain, 4 years ago

Fix several bugs in the fork() syscall.

File size: 7.2 KB
Line 
1/*
2 * scheduler.h - Core scheduler definition.
3 *
4 * Author    Alain Greiner (2016)
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 _SCHEDULER_H_
25#define _SCHEDULER_H_
26
27#include <hal_types.h>
28#include <list.h>
29#include <spinlock.h>
30
31/****  Forward declarations  ****/
32
33struct core_s;
34struct thread_s;
35
36/*********************************************************************************************
37 * This structure define the scheduler associated to a given core.
38 ********************************************************************************************/
39
40typedef struct scheduler_s
41{
42    spinlock_t        lock;         /*! readlock protecting lists of threads                */
43    uint16_t          u_threads_nr; /*! total numbre of attached user threads               */
44    uint16_t          k_threads_nr; /*! total number of attached kernel threads             */
45    list_entry_t      u_root;       /*! root of list of user threads for this scheduler     */
46    list_entry_t      k_root;       /*! root of list of kernel threads for this scheduler   */
47    list_entry_t    * u_last;       /*! pointer on list_entry for last executed k_thread    */
48    list_entry_t    * k_last;       /*! pointer on list entry for last executed u_thread    */
49    struct thread_s * idle;         /*! pointer on idle thread                              */
50    struct thread_s * current;      /*! pointer on current running thread                   */
51}
52scheduler_t;
53
54/*********************************************************************************************
55 *  This function initialises the scheduler for a given core.
56 ********************************************************************************************/ 
57void sched_init( struct core_s * core );
58
59/*********************************************************************************************
60 * This function register a new thread in a given core scheduler.
61 *********************************************************************************************
62 * @ core    : local pointer on the core descriptor.
63 * @ thread  : local pointer on the thread descriptor.
64 ********************************************************************************************/ 
65void sched_register_thread( struct core_s   * core,
66                            struct thread_s * thread );
67
68/*********************************************************************************************
69 *  This function removes a thread from the set of threads attached to a given core.
70 *********************************************************************************************
71 * @ thread  : local pointer on the thread descriptor.
72 ********************************************************************************************/ 
73void sched_remove_thread( struct thread_s * thread );
74
75/*********************************************************************************************
76 * This function is the only method to make a context switch. It is called in cas of TICK,
77 * or when when a thread explicitely requires a scheduling.
78 * It handles the pending signals for all threads attached to the core running the calling
79 * thread, and calls the sched_select() function to select a new thread.
80 * The cause argument is only used for debug by the sched_display() function, and
81 * indicates the scheduling cause.
82 *********************************************************************************************
83 * @ cause    : character string defining the scheduling cause.
84 ********************************************************************************************/
85void sched_yield( char * cause );
86
87/*********************************************************************************************
88 * This function scan all threads attached to a given core scheduler, and executes
89 * the relevant actions for pending signals, such as the THREAD_SIG_KILL signal.
90 *********************************************************************************************
91 * @ core    : local pointer on the core descriptor.
92 ********************************************************************************************/
93void sched_handle_signals( struct core_s * core );
94
95/*********************************************************************************************
96 * This function is used by the scheduler of a given core to actually kill a thread that has
97 * the SIG_KILL / SIG_SUICIDE signal set (following a thread_exit() or a thread_kill() event).
98 * - It checks that the thread has released all locks => panic otherwise...
99 * - It removes the thread from the scheduler.
100 * - It reset the SIG_KILL signal to acknoledge the killer.
101 * - In case of SIG_SUCIDE, it removes the detached thread from its process, and destroys it.
102 *********************************************************************************************
103 * @ thread  : local pointer on the thread descriptor.
104 ********************************************************************************************/
105void sched_kill_thread( struct thread_s * thread );
106
107/*********************************************************************************************
108 * This function does NOT modify the scheduler state.
109 * It just select a thread in the list of attached threads, implementing the following
110 * three steps policy:
111 * 1) It scan the list of kernel threads, from the next thread after the last executed one,
112 *    and returns the first runnable found : not IDLE, not blocked, client queue not empty.
113 *    It can be the current thread.
114 * 2) If no kernel thread found, it scan the list of user thread, from the next thread after
115 *    the last executed one, and returns the first runable found : not blocked.
116 *    It can be the current thread.
117 * 3) If no runable thread found, it returns the idle thread.
118 *********************************************************************************************
119 * @ core    : local pointer on scheduler.
120 * @ returns pointer on selected thread descriptor
121 ********************************************************************************************/
122struct thread_s * sched_select( struct scheduler_s * sched );
123
124/*********************************************************************************************
125 * This function display the internal state of the local core identified by its <lid>.
126 *********************************************************************************************
127 * @ lid      : local index of target core.
128 ********************************************************************************************/
129void sched_display( lid_t lid );
130
131
132#endif  /* _SCHEDULER_H_ */
Note: See TracBrowser for help on using the repository browser.