1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
|
/* -----------------------------------------------------------------------------
*
* (c) The GHC Team 1998-2020
*
* Prototypes for functions in IOManager.c and elsewhere
*
* Hooks for the I/O subsystem(s) that are called from other parts of the RTS.
*
* There are several different I/O subsystem implementations (aka I/O managers),
* for different platforms (notably Windows vs others), and for the threaded vs
* non-threaded RTS. These implementations all need hooks into other parts of
* the RTS, such as startup/shutdown, the scheduler and other special features.
*
* To keep things comprehensible, all the hooks used by all the different I/O
* subsystem implementations are centralised here. Not all implementations use
* all hooks.
*
* -------------------------------------------------------------------------*/
#pragma once
#include "BeginPrivate.h"
/* The per-capability data structures belonging to the I/O manager.
*
* It can be accessed as cap->iomgr.
*
* The content of the structure is defined conditionally so it is different for
* each I/O manager implementation.
*
* TODO: once the content of this struct is genuinely private, and not shared
* with other parts of the RTS, then it can be made opaque, so the content is
* known only to the I/O manager and not the rest of the RTS.
*/
typedef struct {
#if defined(THREADED_RTS)
#if !defined(mingw32_HOST_OS)
/* Control FD for the MIO manager for this capability */
int control_fd;
#endif
#endif
} CapIOManager;
/* Allocate and initialise the per-capability CapIOManager that lives in each
* Capability. It is called from initCapability, via initScheduler,
* via hs_init_ghc.
*/
void initCapabilityIOManager(CapIOManager **iomgr);
/* Init hook: called from hs_init_ghc, very late in the startup after almost
* everything else is done.
*/
void initIOManager(void);
/* Init hook: called from forkProcess in the child process on the surviving
* capability.
*
* Note that this is synchronous and can run Haskell code, so can change the
* given cap.
*/
void initIOManagerAfterFork(/* inout */ Capability **pcap);
/* TODO: rationalise initIOManager and initIOManagerAfterFork into a single
per-capability init function.
*/
/* Shutdown hooks: called from hs_exit_ before and after the scheduler exits.
*
* The stopIOManager is also called many times (once per-capability) within the
* scheduler shutdown (but only in threaded mode). This is despite the fact that
* stopIOManager shuts down the I/O manager for all capabilities.
* FIXME: this is accidentally quadratic and confusing.
*/
void stopIOManager(void);
void exitIOManager(bool wait_threads);
/* Wakeup hook: called from the scheduler's wakeUpRts (currently only in
* threaded mode).
*
* The I/O manager can be blocked waiting on I/O or timers. Sometimes there are
* other external events where we need to wake up the I/O manager and return
* to the schedulr.
*
* At the moment, all the non-threaded I/O managers will do this automagically
* since a signal will interrupt any waiting system calls, so at the moment
* the implementation for the non-threaded I/O managers does nothing.
*
* For the I/O managers in threaded mode, this arranges to unblock the I/O
* manager if it waa blocked waiting.
*/
void wakeupIOManager(void);
/* Pedantic warning cleanliness
*/
#if !defined(THREADED_RTS) && defined(mingw32_HOST_OS)
#define USED_IF_NOT_THREADS_AND_MINGW32
#else
#define USED_IF_NOT_THREADS_AND_MINGW32 STG_UNUSED
#endif
#if defined(THREADED_RTS) && !defined(mingw32_HOST_OS)
#define USED_IF_THREADS_AND_NOT_MINGW32
#else
#define USED_IF_THREADS_AND_NOT_MINGW32 STG_UNUSED
#endif
#include "EndPrivate.h"
|
