Debian Codegraph @

Platforms/emscripten/streams.mjs

raw
1 /**
2 * This is a pared down version of
3 * https://github.com/pyodide/pyodide/blob/main/src/js/streams.ts
4 *
5 * It replaces the standard streams devices that Emscripten provides with our
6 * own better ones. It fixes the following deficiencies:
7 *
8 * 1. The emscripten std streams always have isatty set to true. These set
9 * isatty to match the value for the stdin/stdout/stderr that node sees.
10 * 2. The emscripten std streams don't support the ttygetwinsize ioctl. If
11 * isatty() returns true, then these do, and it returns the actual window
12 * size as the OS reports it to Node.
13 * 3. The emscripten std streams introduce an extra layer of buffering which has
14 * to be flushed with fsync().
15 * 4. The emscripten std streams are slow and complex because they go through a
16 * character-based handler layer. This is particularly awkward because both
17 * sides of this character based layer deal with buffers and so we need
18 * complex adaptors, buffering, etc on both sides. Removing this
19 * character-based middle layer makes everything better.
20 * https://github.com/emscripten-core/emscripten/blob/1aa7fb531f11e11e7ae49b75a24e1a8fe6fa4a7d/src/lib/libtty.js?plain=1#L104-L114
21 *
22 * Ideally some version of this should go upstream to Emscripten since it is not
23 * in any way specific to Python. But I (Hood) haven't gotten around to it yet.
24 */
25
26 import * as tty from "node:tty";
27 import * as fs from "node:fs";
28
29 let FS;
30 const DEVOPS = {};
31 const DEVS = {};
32
33 function isErrnoError(e) {
34 return e && typeof e === "object" && "errno" in e;
35 }
36
37 const waitBuffer = new Int32Array(
38 new WebAssembly.Memory({ shared: true, initial: 1, maximum: 1 }).buffer,
39 );
40 function syncSleep(timeout) {
41 try {
42 Atomics.wait(waitBuffer, 0, 0, timeout);
43 return true;
44 } catch (_) {
45 return false;
46 }
47 }
48
49 /**
50 * Calls the callback and handle node EAGAIN errors.
51 */
52 function handleEAGAIN(cb) {
53 while (true) {
54 try {
55 return cb();
56 } catch (e) {
57 if (e && e.code === "EAGAIN") {
58 // Presumably this means we're in node and tried to read from/write to
59 // an O_NONBLOCK file descriptor. Synchronously sleep for 10ms then try
60 // again. In case for some reason we fail to sleep, propagate the error
61 // (it will turn into an EOFError).
62 if (syncSleep(10)) {
63 continue;
64 }
65 }
66 throw e;
67 }
68 }
69 }
70
71 function readWriteHelper(stream, cb, method) {
72 let nbytes;
73 try {
74 nbytes = handleEAGAIN(cb);
75 } catch (e) {
76 if (e && e.code && Module.ERRNO_CODES[e.code]) {
77 throw new FS.ErrnoError(Module.ERRNO_CODES[e.code]);
78 }
79 if (isErrnoError(e)) {
80 // the handler set an errno, propagate it
81 throw e;
82 }
83 console.error("Error thrown in read:");
84 console.error(e);
85 throw new FS.ErrnoError(Module.ERRNO_CODES.EIO);
86 }
87 if (nbytes === undefined) {
88 // Prevent an infinite loop caused by incorrect code that doesn't return a
89 // value.
90 // Maybe we should set nbytes = buffer.length here instead?
91 console.warn(
92 `${method} returned undefined; a correct implementation must return a number`,
93 );
94 throw new FS.ErrnoError(Module.ERRNO_CODES.EIO);
95 }
96 if (nbytes !== 0) {
97 stream.node.timestamp = Date.now();
98 }
99 return nbytes;
100 }
101
102 function asUint8Array(arg) {
103 if (ArrayBuffer.isView(arg)) {
104 return new Uint8Array(arg.buffer, arg.byteOffset, arg.byteLength);
105 } else {
106 return new Uint8Array(arg);
107 }
108 }
109
110 const prepareBuffer = (buffer, offset, length) =>
111 asUint8Array(buffer).subarray(offset, offset + length);
112
113 const TTY_OPS = {
114 ioctl_tiocgwinsz(tty) {
115 return tty.devops.ioctl_tiocgwinsz?.();
116 },
117 };
118
119 const stream_ops = {
120 open: function (stream) {
121 const devops = DEVOPS[stream.node.rdev];
122 if (!devops) {
123 throw new FS.ErrnoError(Module.ERRNO_CODES.ENODEV);
124 }
125 stream.devops = devops;
126 stream.tty = stream.devops.isatty ? { ops: TTY_OPS, devops } : undefined;
127 stream.seekable = false;
128 },
129 close: function (stream) {
130 // flush any pending line data
131 stream.stream_ops.fsync(stream);
132 },
133 fsync: function (stream) {
134 const ops = stream.devops;
135 if (ops.fsync) {
136 ops.fsync();
137 }
138 },
139 read: function (stream, buffer, offset, length, pos /* ignored */) {
140 buffer = prepareBuffer(buffer, offset, length);
141 return readWriteHelper(stream, () => stream.devops.read(buffer), "read");
142 },
143 write: function (stream, buffer, offset, length, pos /* ignored */) {
144 buffer = prepareBuffer(buffer, offset, length);
145 return readWriteHelper(stream, () => stream.devops.write(buffer), "write");
146 },
147 };
148
149 function nodeFsync(fd) {
150 try {
151 fs.fsyncSync(fd);
152 } catch (e) {
153 if (e?.code === "EINVAL") {
154 return;
155 }
156 // On Mac, calling fsync when not isatty returns ENOTSUP
157 // On Windows, stdin/stdout/stderr may be closed, returning EBADF or EPERM
158 if (
159 e?.code === "ENOTSUP" || e?.code === "EBADF" || e?.code === "EPERM"
160 ) {
161 return;
162 }
163
164 throw e;
165 }
166 }
167
168 class NodeReader {
169 constructor(nodeStream) {
170 this.nodeStream = nodeStream;
171 this.isatty = tty.isatty(nodeStream.fd);
172 }
173
174 read(buffer) {
175 try {
176 return fs.readSync(this.nodeStream.fd, buffer);
177 } catch (e) {
178 // Platform differences: on Windows, reading EOF throws an exception,
179 // but on other OSes, reading EOF returns 0. Uniformize behavior by
180 // catching the EOF exception and returning 0.
181 if (e.toString().includes("EOF")) {
182 return 0;
183 }
184 throw e;
185 }
186 }
187
188 fsync() {
189 nodeFsync(this.nodeStream.fd);
190 }
191 }
192
193 class NodeWriter {
194 constructor(nodeStream) {
195 this.nodeStream = nodeStream;
196 this.isatty = tty.isatty(nodeStream.fd);
197 }
198
199 write(buffer) {
200 return fs.writeSync(this.nodeStream.fd, buffer);
201 }
202
203 fsync() {
204 nodeFsync(this.nodeStream.fd);
205 }
206
207 ioctl_tiocgwinsz() {
208 return [this.nodeStream.rows ?? 24, this.nodeStream.columns ?? 80];
209 }
210 }
211
212 export function initializeStreams(fsarg) {
213 FS = fsarg;
214 const major = FS.createDevice.major++;
215 DEVS.stdin = FS.makedev(major, 0);
216 DEVS.stdout = FS.makedev(major, 1);
217 DEVS.stderr = FS.makedev(major, 2);
218
219 FS.registerDevice(DEVS.stdin, stream_ops);
220 FS.registerDevice(DEVS.stdout, stream_ops);
221 FS.registerDevice(DEVS.stderr, stream_ops);
222
223 FS.unlink("/dev/stdin");
224 FS.unlink("/dev/stdout");
225 FS.unlink("/dev/stderr");
226
227 FS.mkdev("/dev/stdin", DEVS.stdin);
228 FS.mkdev("/dev/stdout", DEVS.stdout);
229 FS.mkdev("/dev/stderr", DEVS.stderr);
230
231 DEVOPS[DEVS.stdin] = new NodeReader(process.stdin);
232 DEVOPS[DEVS.stdout] = new NodeWriter(process.stdout);
233 DEVOPS[DEVS.stderr] = new NodeWriter(process.stderr);
234
235 FS.closeStream(0 /* stdin */);
236 FS.closeStream(1 /* stdout */);
237 FS.closeStream(2 /* stderr */);
238 FS.open("/dev/stdin", 0 /* O_RDONLY */);
239 FS.open("/dev/stdout", 1 /* O_WRONLY */);
240 FS.open("/dev/stderr", 1 /* O_WRONLY */);
241 }