Method for managing a system call and associated computer program product
The kernel model addresses memory overflow and complexity issues in managing blocking system calls by using an asynchronous task execution engine, enhancing security and performance through automated context management and simplified coding.
Patent Information
- Application Number
- FR2022010701
- Authority / Receiving Office
- FR · FR
- Patent Type
- Patents
- Current Assignee / Owner
- Filing Date
- 2022-10-17
- Publication Date
- 2024-11-01
- Estimated Expiration
- 2042-10-17
AI Technical Summary
Existing kernel models face issues with memory overflow risks and resource consumption due to oversized privileged stacks in managing blocking system calls, while maintaining simplicity and readability of kernel code is challenging, especially in the 'Process Model', and the 'IRQ Model' requires complex manual coding.
Implement a kernel model with a scheduler and an asynchronous task execution engine that manages blocking system calls through asynchronous tasks, using a state machine to handle context switching and event waiting, eliminating the need for a dedicated privileged stack and simplifying manual coding.
This approach reduces memory overhead, enhances security by automating context management, maintains code readability, and improves performance by optimizing CPU usage, while ensuring efficient handling of blocking system calls.
Smart Images

Figure 00000015_0000 
Figure 00000016_0000 
Figure 00000017_0000
Abstract
Description
Title of the invention: Method for managing a system call and associated computer program product
[0001] The invention relates to the field of system programming.
[0002] The operating system of a computer is an abstraction program of the hardware layer, playing the role of interface between the application layer and the hardware layer.
[0003] An application is a program executed "above" the operating system and which therefore accesses the hardware layer indirectly via the operating system.
[0004] The operating system includes a kernel and possibly other associated programs.
[0005] The kernel is a part of the operating system that responds to system calls, interrupts and exceptions.
[0006] A running application is a process.
[0007] A process is subdivided into a plurality of threads. A thread comprises a block of elementary instructions executable only once by the computer's processor.
[0008] A thread can be in different execution states: a "running" state, a "ready" state, or a "waiting" state.
[0009] A thread is associated with an execution context. This is the set of information describing the execution state of the thread and allowing the processor to continue, interrupt, or resume its execution. The context includes, in particular, an execution stack in the computer's memory, the contents of the processor's registers (such as program counter values, a stack pointer, etc.).
[0010] Instructions are executed by the processor in a predefined processor operating mode, depending on the privileges granted to these instructions, in particular access to certain memory spaces. For example, instructions in an application's execution thread are executed in a non-privileged mode, such as "user" mode, while operating system instructions (in particular the kernel) are executed in a privileged mode, such as "kernel" mode.
[0011] In a multitasking operating system, several processes are executed in "parallel". More precisely, a kernel scheduler places the threads Instructions that are in the "ready" state are placed in a queue, which is an ordered list of execution threads. The scheduler uses priority rules to order the execution threads in this queue. The processor executes the thread at the bottom of the queue. This thread then transitions from the "ready" state to the "running" state. The processor executes this thread either until it completes the execution of its instructions or until a maximum execution time for a queue is reached.
[0012] When the processor switches from executing the first thread of a first process to executing the second thread of a second process, it performs a context switch. A context switch occurs even if both threads belong to the same process. At most, certain information common to both threads, such as the address space, memory protection data, etc., may remain unchanged. However, information specific to each thread, such as the program counter, stack pointer, etc., must be modified.
[0013] During a context change, the kernel is responsible for saving the context of the first thread and restoring the context of the second thread.
[0014] To perform certain functions known as system functions, a thread calls upon the corresponding services provided by the kernel. The thread is said to make a system call. The following steps are performed successively:
[0015] - The processor executes the instructions in the thread in non-executable mode privileged on a non-privileged execution stack in the thread.
[0016] - When one of these instructions corresponds to a system call, the processor switches from non-privileged mode to privileged mode, and executes the kernel instructions associated with the called system function on a privileged execution stack.
[0017] - Once the instructions associated with the system function have been executed, the kernel returns the system call indicating the result of the system call.
[0018] - The processor switches from privileged mode to non-privileged mode, and resumes execution of instructions from the calling thread on the non-privileged execution stack, taking into account the result of the system call.
[0019] The execution of the calling thread therefore resumes where it had been suspended following the system call.
[0020] However, there are two types of system calls, non-blocking system calls and blocking system calls.
[0021] In a non-blocking system call, the kernel can perform the task corresponding to the requested service because it has the necessary information. The kernel then immediately returns the system call. This is what was presented above.
[0022] In a blocking system call, the kernel cannot perform the task corresponding to the requested service because it does not have all the necessary information. Therefore, the thread of execution is blocked until the required information is available.
[0023] This is the case, for example, for a system call to read from a data pipe when that pipe is empty. The thread is then blocked in read mode on the pipe. The kernel will return the system call only when data is available in the monitored pipe, that is, when a "write" event occurs in the monitored pipe.
[0024] This is, for example, still the case with a "sleep" system call that waits for a timer to reach a certain predefined duration. The thread of execution is then blocked until the timer reaches the required value. The kernel will return the system call only when the timer has reached the predefined duration, that is, when an "equal" event occurs between the current value of the timer and the predefined duration.
[0025] The handling of such a blockage of the execution thread, as well as the resumption of its execution, are entirely the responsibility of the kernel.
[0026] In particular, a thread blocked by a blocking system call is put on hold by the kernel. More precisely, it is switched from the "running" state to the "waiting" state and removed from the "ready" thread queue of the scheduler so that it cannot be executed. Its execution context is saved (including the non-privileged stack on which it was running) to allow the processor to proceed to the execution of another thread.
[0027] For the resumption of the execution of a thread in the "waiting" state, the kernel maintains a table indicating all the threads in the "waiting" state and, for each thread, the event necessary for its resumption.
[0028] When the expected event for resuming a thread occurs, the kernel resumes and completes the execution of the instructions of the blocking system call. It updates the thread context with the result of the system call. Finally, it switches the thread from the "waiting" state to the "ready" state.
[0029] The execution thread is then placed back in the queue by the scheduler in order to be executed again by the processor.
[0030] Currently, there are two kernel models depending on the precise way in which the kernel handles blocking system calls: the "process model" kernel (or PM kernel) on the one hand and the "IRQ Model" kernel (or IRQ kernel) on the other.
[0031] The PM kernel is based on the presence of two stacks for each thread: a non-privileged stack and a privileged stack. If a thread is blocked, the thread's kernel context The execution is stored in the privileged stack of the execution thread, at the moment the execution thread switches from the "running" state to the "waiting" state.
[0032] When the event necessary to resume this thread occurs, the kernel uses information from the thread's privileged stack to finalize the system call. The completion of this task automatically leads to a resumption of execution of the calling thread by switching it from the "waiting" state to the "ready" state.
[0033] However, in this first model, the sizing of the privileged stack for a thread is problematic. There is a high risk of overflow onto other kernel memory cells. This raises major security and reliability issues. To mitigate this, there is a tendency to oversize the privileged stack for each thread. This leads to significant consumption of computer resources.
[0034] However, the kernel code remains simple for the developer to develop and understand, because its sequential nature is preserved. Saving the kernel context of the thread of execution in the privileged stack is transparent to the developer because it is handled by the compiler.
[0035] The IRQ kernel is based on a non-privileged stack per thread and a privileged stack common to all threads. The common privileged stack is therefore shared between the different threads.
[0036] The common privileged stack is, however, reset at the end of each system call (blocking or non-blocking), that is to say, no information is stored on the common privileged stack.
[0037] It is therefore up to the kernel code developer to code, for blocking system calls, the way to store the kernel context of the thread of execution in ancillary data structures, with the unblocking conditions, to allow the finalization of the system call when the expected event occurs and the resumption of the calling thread put to sleep.
[0038] Thus, the part of the source code of an IRQ kernel managing the saving of the kernel context is left to the developer.
[0039] While such a kernel allows for a secure approach, reading the source code is no longer sequential. The source code is therefore particularly difficult to read and verify.
[0040] The object of the present invention is to propose an alternative kernel model to the kernel models of the prior art, offering a new approach for the management of blocking system calls, while trying to combine the advantages of the two known models and avoiding their respective disadvantages.
[0041] For this purpose, the invention relates to a method for managing a system call, put into work by a kernel of an operating system executed by a computer, the system call having been issued by a thread of execution of an application executed by the computer, characterized in that, said kernel comprising a scheduler and an engine for executing asynchronous tasks, said method comprises the steps of: a)-determination by the kernel whether the system call is a blocking system call; and, if so: b)-putting the thread of execution to sleep by the kernel; c)-creation by the kernel of an asynchronous task to carry out the system call, the asynchronous task being equivalent to a state machine, a transition from a first execution state to a second execution state being initiated by an expected event, and updating by the kernel of a list of asynchronous tasks to be executed by the engine with the information relating to the asynchronous task created;d) - execution by the engine of the asynchronous task on a kernel stack using the memory area information relating to the asynchronous task, until a blocking execution state requiring a corresponding expected event is reached, the execution of the asynchronous task is then blocked and the list of asynchronous tasks is updated with the reached blocking execution state and the corresponding expected event; e) - upon the occurrence of the corresponding expected event, resumption of the execution by the engine of the asynchronous task on the kernel stack in such a way as to perform the transition from the blocking execution state to a subsequent blocking execution state; f) - verification if the subsequent blocking execution state is a final execution state of the task; and if so, g) - finalization of the execution of the asynchronous task and removal of the asynchronous task from the list of asynchronous tasks to be executed by the engine;and, h) - return via the kernel of the system call to the thread of execution and wake-up via the kernel of the thread of execution. ;
[0042] According to particular embodiments, ... comprises one or more of the following characteristics, taken individually or in all technically possible combinations:
[0043] - when the verification step leads to the conclusion that the execution state is blocking If the following is not the final execution state of the asynchronous task, steps d), e) and f) are iterated.
[0044] - the method further comprises, when the kernel determines that the received system call is a non-blocking system call, the steps of: execution by the kernel of the system call on a kernel stack; and, return by the kernel of the system call to the thread of execution.
[0045] - Putting the thread to sleep by the kernel consists of switching a state The execution thread transitions from a "running" state to a "waiting" state, and the kernel wakes up the thread by switching the execution state from "waiting" to "ready to run".
[0046] - between the implementation of steps d) and e), another thread of execution present in a The scheduler queue is executed.
[0047] - during an indicative interruption of the occurrence of a new event, the engine is executed to identify the asynchronous task from the list of asynchronous tasks for which the new event constitutes the expected event.
[0048] The invention also relates to a computer program product comprising instructions which, when executed by a computer processor, provide said computer with a kernel, characterized in that said kernel comprises a scheduler and an asynchronous task execution engine, said asynchronous task engine being associated with a list of asynchronous tasks to be executed and a dedicated memory area in a computer memory, the kernel being adapted, upon receiving a system call issued by an execution thread of an application executed by the computer, to perform a method of managing said system call in accordance with the preceding procedure.
[0049] Preferably, the computer program product is such that the kernel is associated with a single kernel stack.
[0050] Preferably, the computer program product results from the compilation of a source code, said source code being in a sequential form even for blocking system calls.
[0051] The invention and its advantages will be better understood upon reading the following detailed description of a particular embodiment, given solely by way of non-limiting example, this description being made with reference to the accompanying drawings in which:
[0052] [Fig-1] [Fig.1] is a schematic representation in the form of functional modules tionals of a preferred embodiment of a core according to the invention;
[0053] [Fig.2] Fig.2 is a schematic block representation of the steps of a blocking system call executing the kernel of Fig.1; and,
[0054] [Fig.3] The [Fig.3] is a schematic representation of the operating principle of the core of the [Fig.1].
[0055] The present invention relates to a computer program product which, when its instructions are executed by a computer, provides kernel functionality to that computer. In what follows, we will refer more simply to the kernel.
[0056] As an executable computer program, the kernel is an object code resulting from the compilation of a source code, written in a suitable programming language.
[0057] In general, the kernel according to the invention manages a block related to a blocking system call by means of asynchronous programming of blocking system calls.
[0058] Figure 1 represents an operating system 2 forming an interface between a layer hardware 1 (processor 11, memory 12, input / output ports 13, ...) and an application layer 3, comprising one or more application program(s) (or ap-plication(s)), such as application 30.
[0059] Operating system 2 includes, among other things, a kernel 20.
[0060] In a conventional manner, kernel 20 comprises, among other things, a module of input / output control 21, a process management module 22 and a system call management module 23.
[0061] The process management module 22 includes, among other things, a scheduler 24. This is associated with a list of execution threads 25 and a queue 26.
[0062] According to the invention, the process management module 22 of the kernel further comprises an asynchronous task execution engine 34.
[0063] The execution by the motor of an asynchronous task must be viewed as a state machine, where an event causes a transition from an initial state to a final state of the set of possible states of the asynchronous task, the final state being the "task completed" state.
[0064] The engine 34 is associated with a list of asynchronous tasks 35 and dedicated memory areas 36.
[0065] The list of asynchronous tasks 35 indicates the set of asynchronous tasks currently being executed, and, for each task, the current execution state in which this task is located, and the event expected to perform a transition from the current state to a subsequent state.
[0066] The motor 34 does not manage a stack, but a memory area 36 per asynchronous task to be performed. This memory area allows the motor to store the values of the variables of the asynchronous task being executed. The memory area associated with an asynchronous task has a defined size.
[0067] For clarity, in [Fig. 1], list 25, queue 26, list 35 and memory areas 36 are represented in modules 24 and 34, but these are structures in computer memory.
[0068] The method of programming a blocking system call in the kernel according to the invention is given in the following table relating to the part of the kernel source code for the example of the system call "sys_sleep" using the Rust programming language ("registered trademark"):
[0069] [Tables 1] fn sys_sleep<T: ContextTrait> (ctx:&'static mut T){ / / System call inputs. Input parameters are decoded. let now =crate::timer::GTimer::now(); let duration ctx.syscall_in:: <sys::sleep>().duration; let alarm = now. duration; / / Blocking the currently executing thread. let kernel = Sefl::kemel_mut(); let th = kernel.threads.block_running(); let tid = th.read().id(); / / Launch an asynchronous task to handle the blocking system call. The following code will be executed by the engine. crate: :tasks :: spawn(tid,asyncmove{ kernel.delay.deadline(alarm).await; kernel.threads.unblock(th); let res =crate::timer::GTimer::now()- now; ctx::syscall_out:: <sys::sleep>(&res); }); ]
[0070] In this example, the system call "sys_sleep" is intended to put a calling thread on hold for a given time.
[0071] This function contains the blocking of the current thread of execution (instruction "kernel.threads.block_running()").
[0072] This function then contains the function for creating an asynchronous task ("crate::tasks::spawn"). Execution of this function leads to the creation of an asynchronous task ("async move" instruction).
[0073] The asynchronous task is executed by motor 34.
[0074] It is in this asynchronous task that the details of the instructions of the system call itself are found.
[0075] It includes the events expected to advance the execution of these instructions, such as here the waiting for the elapsed time to occur (instruction ".await").
[0076] The asynchronous task also includes the instructions to be executed, such as here the instructions to finalize the asynchronous task when the expected event has arrived ("res = crate::timer::GTimer::now() - now").
[0077] The asynchronous task ultimately includes the return of the system function ("ctx::syscall_out:: <sys::sleep>( &res ) »)
[0078] Thus, in the source code of the table above, which is an extremely synthetic expression of the kernel instructions during a blocking system call, we see that an asynchronous task includes, in addition to the instructions of the system call itself (that is to say the code of the service provided by the kernel), the state machine characterizing the progress of the execution of the asynchronous task, as well as the management of waking up the calling thread.
[0079] As illustrated in [Fig.2], the method 100 of handling a system call by the kernel 20 is carried out in the following manner.
[0080] In a step 110, while a thread of execution, for example of a process of application 30, is being executed by the processor in non-privileged mode on a non-privileged stack dedicated to the thread of execution, the latter makes a system call, this system call being identified by an identifier.
[0081] In step 120, due to this system call, the processor 11 switches from non-privileged mode to privileged mode for the kernel 22 to execute the instructions of the system call. The non-privileged context of the thread is saved in the non-privileged stack of the thread.
[0082] In step 130, the system call management module 23 retrieves the system call identifier and determines, on the basis of this identifier, whether it is a non-blocking or blocking system call.
[0083] In the first case, the non-blocking system call is handled in a classic way, that is to say that the instructions of the system call are executed by the processor on the single privileged stack of the kernel and returns the system call to the calling thread (step 140).
[0084] Due to this return to the system call, the processor switches from privileged mode to non-privileged mode (step 150) to continue the execution of the instructions of the calling thread (step 160), taking into account the result of the system call and the information present in the non-privileged stack of the thread.
[0085] In the second case, in step 170, on request from module 23, scheduler 24 places the calling thread in the "waiting" state in list 25. It removes the calling thread from queue 26.
[0086] In parallel, in step 180, module 23 creates an asynchronous task to manage this waiting of the calling thread. Creating an asynchronous task involves defining the state machine associated with this asynchronous task and registering a new entry in the list of asynchronous tasks 35, defining the current state of the asynchronous task and the event expected to change this state. A memory area 36 is reserved for the asynchronous task.
[0087] Then, in step 190, the engine is executed. It executes the contents of the "async" section of the asynchronous task on the kernel stack using the information generated necessary for the execution of the asynchronous task stored in the area of the computer's memory dedicated to the engine.
[0088] The execution of the task progresses until it reaches a blocking execution state requiring the occurrence of an expected event.
[0089] In the previous example, this corresponds to the execution of the task up to the ".await" instruction (see table below). The ".await" instruction indicates that an event is expected.
[0090] If it has not yet occurred, the execution of the asynchronous task is blocked. The engine updates list 35 by indicating the current state of the task and the expected event in order to resume task execution.
[0091] The processor can then execute the next thread in queue 26 or other kernel tasks (using the privileged stack).
[0092] In particular, in a step 210, following an interruption indicating the occurrence of a new event (step 200), the engine is executed on the kernel's privileged stack to scan the list of tasks 35 in order to check if this new event corresponds to the event expected by one or the other of the asynchronous tasks in the list 35.
[0093] When this event corresponds to the event expected by the asynchronous task associated with the system call in step 110, then in step 220, the execution of this asynchronous task by the kernel is resumed in order to perform the transition from the current execution state to the next execution state. More precisely, the engine continues the execution of the contents of the "async" section of the asynchronous task until it reaches another ".await" instruction.
[0094] In step 230, the new state reached by the asynchronous task is tested to see if it corresponds to the "task completed" state. If not, steps 190 to 230 are iterated.
[0095] Conversely, if at step 230 the state of the asynchronous task is found to be "task completed", then, at step 240, the kernel executes the end of the "async" section of the asynchronous task in order to finalize it. Then, this task is destroyed by removing it from list 35.
[0096] When the task from list 35 is detected by module 23, in step 250, the engine returns the system call by updating the execution context of the calling thread with the result of the asynchronous task execution. The engine changes the state of the calling thread by switching it to the "Ready" state.
[0097] In step 260, with the calling thread in the "Ready" state, the scheduler can place it back in the queue 36 to continue the execution of this thread by the processor in non-privileged mode, taking into account information present in the non-privileged stack of this thread.
[0098] Thus, blocked threads are managed by the asynchronous task execution engine. The kernel scheduler manages the execution of unblocked threads. Blocked threads are not within its control.
[0099] Thus, when called by the kernel, the engine manages the execution of blocked threads until they are unblocked. The engine consults the list of running asynchronous tasks and updates their execution. If an event expected by an asynchronous task (following a ".await" in the code of the table above) has occurred, this allows the engine to continue executing subsequent instructions until the task is completed or until the task is blocked again (i.e., the presence of another ".await" in the task's code).
[0100] Fig. 3 illustrates the principle of asynchronous programming in general. It shows the execution of two asynchronous functions called sequentially in the same thread of execution.
[0101] It is considered that a process needs two data, A and B, the data A being obtained by a first blocking system call to a function fA made by a first thread of execution of the process and the data B being obtained by a second blocking system call to a function fB made by a second thread of execution of the process.
[0102] The first thread of execution of the process makes the system call to the function fA.
[0103] The kernel places the first thread of execution in a waiting state while creating a first asynchronous task for the execution by the motor of the function fA.
[0104] The execution of the process continues, for example by the election of the second thread of execution.
[0105] The second thread of execution of the process makes the system call to the function fB.
[0106] The kernel places the second thread of execution in a waiting state while creating a second asynchronous task for the execution by the motor of the function fB.
[0107] The first calling thread resumes execution once the task corresponding to the call to function fA is completed.
[0108] Similarly, the second calling thread resumes execution once the task corresponding to the call to the function fb is completed.
[0109] It is observed that the process will have data A and B available in a shorter time than in the case, for example, where the two system calls are handled sequentially by the kernel.
[0110] A parallel can be drawn between the execution thread / kernel according to the present invention and the user / web server in the field of internet communications. A web server processes requests from different users asynchronously in order to optimize the number of connections at any given time.
[0111] The advantages of the core according to the invention are numerous:
[0112] - asynchronous programming can be seen as cooperative tasks which share the same execution context, including a common privileged stack.
[0113] - a gain in safety since the management is carried out automatically by the language and The associated compiler, not the programmer, reduces the risk of errors. There is no longer a problem with stack size sizing in privileged mode. The memory area is of a predefined size and adapted to the execution of the corresponding asynchronous task. The kernel according to the invention is therefore synonymous with a high level of reliability.
[0114] - reduced development cost since the kernel source code according to the invention It retains its sequential nature (as illustrated in the table above), allowing the programmer to easily read and update it, thus contributing to a reduction in development costs. Furthermore, the management of the progress of blocked threads is handled not manually by the developer, but by the language and the compiler.
[0115] - a performance gain due to minimal use of memory resources (a single preferred stack) and optimal CPU usage (no sudden context changes).
[0116] - The entire kernel (including the asynchronous task execution engine) uses a single and same privileged stack. But the state of asynchronous tasks is saved, not in a dedicated stack ("Process Model") or in structures manually implemented by the developer ("IRQ model") but in a dedicated memory, which is managed automatically.
[0117] The only constraint on the implementation of the present invention is to have a compiler that supports asynchronous programming in order to compile the source code in such a way as to obtain object code executable by a computer.< / sys::sleep> < / sys::sleep> < / sys::sleep>
Claims
Claims
1. Method (100) for managing a system call, implemented by a kernel (20) of an operating system (2) executed by a computer, the system call having been issued by a thread of execution of an application (30) executed by the computer, characterized in that, said kernel comprising a scheduler (24) and an asynchronous task execution engine (34), said method comprises the steps of: a)- determination (130) by the kernel whether the system call is a blocking system call; and, if so: b)- sleep (170) by the kernel of the execution thread; c)- creation (180) by the kernel of an asynchronous task to carry out the system call, the asynchronous task being equivalent to a state machine, a transition from a first execution state to a second execution state being initiated by an expected event, and updating by the kernel of a list of asynchronous tasks to be executed by the engine with the information relating to the asynchronous task created; d)- execution (190) by the engine of the asynchronous task on a kernel stack using the information of the memory area relating to the asynchronous task, until reaching a blocking execution state requiring a corresponding expected event, the execution of the asynchronous task then being blocked and the list of asynchronous tasks updated with the blocking execution state reached and the corresponding expected event; e)- upon occurrence (200) of the corresponding expected event, resumption of execution (220) by the engine of the asynchronous task on the kernel stack so as to effect the transition from the blocking execution state to a following blocking execution state; f)- checking (230) whether the next blocking execution state is a final execution state of the task; and if so, g)- finalizing (240) the execution of the asynchronous task and removing the asynchronous task from the list of asynchronous tasks to be executed by the engine; and, h)- returning (250) by the kernel of the system call to the thread of execution and waking up by the kernel of the thread of execution.
2. Method according to claim 1, wherein, when the verification step (230) leads to the conclusion that the next blocking execution state is not the final execution state of the asynchronous task, steps d), e) and f) are iterated.
3. A method according to claim 1 or claim 2, comprising, when the kernel determines (130) that the received system call is a non-blocking system call, the steps of: - executing (140) by the kernel the system call on a kernel stack; and, - returning (150) by the kernel the system call to the thread of execution.
4. A method according to any preceding claim, wherein the kernel putting the thread to sleep comprises switching an execution state of the thread from a "running" state to a "waiting" state and the kernel waking the thread comprises switching the execution state of the thread from the "waiting" state to a "ready to execute" state.
5. A method according to any preceding claim, wherein, between the implementation of steps d) and e), another thread present in a queue of the scheduler is executed.
6. A method according to any preceding claim, wherein, upon an interruption indicative of the occurrence of a new event, the engine is executed to identify the asynchronous task from the list of asynchronous tasks for which the new event constitutes the expected event.
7. Computer program product comprising instructions which, when executed by a processor of a computer, provide said computer with a kernel, characterized in that said kernel comprises a scheduler and an asynchronous task execution engine, said asynchronous task engine being associated with a list of asynchronous tasks to be executed and a dedicated memory area in a memory of the computer, the kernel being adapted, upon receipt of a system call issued by a thread of execution of an application executed by the computer, to carry out a method for managing said system call in accordance with any one of claims 1 to 6.
8. A computer program product according to claim 7, wherein the kernel is associated with a single kernel stack.
9. Computer program product according to any one of claims 7 to 8, resulting from the compilation of a source code, said source code being in a sequential form even for blocking system calls.
