Upload Kmake

lib/internal/bootstrap/switches/does_not_own_process_state.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const credentials = internalBinding('credentials');
+const rawMethods = internalBinding('process_methods');
+// TODO: this should be detached from ERR_WORKER_UNSUPPORTED_OPERATION
+const { unavailable } = require('internal/process/worker_thread_only');
+
+process.abort = unavailable('process.abort()');
+process.chdir = unavailable('process.chdir()');
+process.umask = wrappedUmask;
+process.cwd = rawMethods.cwd;
+
+if (credentials.implementsPosixCredentials) {
+  process.initgroups = unavailable('process.initgroups()');
+  process.setgroups = unavailable('process.setgroups()');
+  process.setegid = unavailable('process.setegid()');
+  process.seteuid = unavailable('process.seteuid()');
+  process.setgid = unavailable('process.setgid()');
+  process.setuid = unavailable('process.setuid()');
+}
+
+// ---- keep the attachment of the wrappers above so that it's easier to ----
+// ----              compare the setups side-by-side                    -----
+
+const {
+  codes: {
+    ERR_WORKER_UNSUPPORTED_OPERATION,
+  },
+} = require('internal/errors');
+
+function wrappedUmask(mask) {
+  // process.umask() is a read-only operation in workers.
+  if (mask !== undefined) {
+    throw new ERR_WORKER_UNSUPPORTED_OPERATION('Setting process.umask()');
+  }
+
+  return rawMethods.umask(mask);
+}

lib/internal/bootstrap/switches/does_own_process_state.js

@@ -0,0 +1,144 @@
+'use strict';
+
+const credentials = internalBinding('credentials');
+const rawMethods = internalBinding('process_methods');
+const {
+  namespace: {
+    addDeserializeCallback,
+    addSerializeCallback,
+    isBuildingSnapshot,
+  },
+} = require('internal/v8/startup_snapshot');
+
+process.abort = rawMethods.abort;
+process.umask = wrappedUmask;
+process.chdir = wrappedChdir;
+process.cwd = wrappedCwd;
+
+if (credentials.implementsPosixCredentials) {
+  const wrapped = wrapPosixCredentialSetters(credentials);
+
+  process.initgroups = wrapped.initgroups;
+  process.setgroups = wrapped.setgroups;
+  process.setegid = wrapped.setegid;
+  process.seteuid = wrapped.seteuid;
+  process.setgid = wrapped.setgid;
+  process.setuid = wrapped.setuid;
+}
+
+// ---- keep the attachment of the wrappers above so that it's easier to ----
+// ----              compare the setups side-by-side                    -----
+
+const {
+  parseFileMode,
+  validateArray,
+  validateString,
+  validateUint32,
+} = require('internal/validators');
+
+function wrapPosixCredentialSetters(credentials) {
+  const {
+    codes: {
+      ERR_INVALID_ARG_TYPE,
+      ERR_UNKNOWN_CREDENTIAL,
+    },
+  } = require('internal/errors');
+
+  const {
+    initgroups: _initgroups,
+    setgroups: _setgroups,
+    setegid: _setegid,
+    seteuid: _seteuid,
+    setgid: _setgid,
+    setuid: _setuid,
+  } = credentials;
+
+  function initgroups(user, extraGroup) {
+    validateId(user, 'user');
+    validateId(extraGroup, 'extraGroup');
+    // Result is 0 on success, 1 if user is unknown, 2 if group is unknown.
+    const result = _initgroups(user, extraGroup);
+    if (result === 1) {
+      throw new ERR_UNKNOWN_CREDENTIAL('User', user);
+    } else if (result === 2) {
+      throw new ERR_UNKNOWN_CREDENTIAL('Group', extraGroup);
+    }
+  }
+
+  function setgroups(groups) {
+    validateArray(groups, 'groups');
+    for (let i = 0; i < groups.length; i++) {
+      validateId(groups[i], `groups[${i}]`);
+    }
+    // Result is 0 on success. A positive integer indicates that the
+    // corresponding group was not found.
+    const result = _setgroups(groups);
+    if (result > 0) {
+      throw new ERR_UNKNOWN_CREDENTIAL('Group', groups[result - 1]);
+    }
+  }
+
+  function wrapIdSetter(type, method) {
+    return function(id) {
+      validateId(id, 'id');
+      if (typeof id === 'number') id >>>= 0;
+      // Result is 0 on success, 1 if credential is unknown.
+      const result = method(id);
+      if (result === 1) {
+        throw new ERR_UNKNOWN_CREDENTIAL(type, id);
+      }
+    };
+  }
+
+  function validateId(id, name) {
+    if (typeof id === 'number') {
+      validateUint32(id, name);
+    } else if (typeof id !== 'string') {
+      throw new ERR_INVALID_ARG_TYPE(name, ['number', 'string'], id);
+    }
+  }
+
+  return {
+    initgroups,
+    setgroups,
+    setegid: wrapIdSetter('Group', _setegid),
+    seteuid: wrapIdSetter('User', _seteuid),
+    setgid: wrapIdSetter('Group', _setgid),
+    setuid: wrapIdSetter('User', _setuid),
+  };
+}
+
+// Cache the working directory to prevent lots of lookups. If the working
+// directory is changed by `chdir`, it'll be updated.
+let cachedCwd = '';
+
+if (isBuildingSnapshot()) {
+  // Reset the cwd on both serialization and deserialization so it's fine
+  // for process.cwd() to be accessed inside of serialization callbacks.
+  addSerializeCallback(() => {
+    cachedCwd = '';
+    addDeserializeCallback(() => {
+      cachedCwd = '';
+    });
+  });
+}
+
+function wrappedChdir(directory) {
+  validateString(directory, 'directory');
+  rawMethods.chdir(directory);
+  // Mark cache that it requires an update.
+  cachedCwd = '';
+}
+
+function wrappedUmask(mask) {
+  if (mask !== undefined) {
+    mask = parseFileMode(mask, 'mask');
+  }
+  return rawMethods.umask(mask);
+}
+
+function wrappedCwd() {
+  if (cachedCwd === '')
+    cachedCwd = rawMethods.cwd();
+  return cachedCwd;
+}

lib/internal/bootstrap/switches/is_main_thread.js

@@ -0,0 +1,318 @@
+'use strict';
+
+const {
+  ObjectDefineProperty,
+} = primordials;
+
+const rawMethods = internalBinding('process_methods');
+const {
+  namespace: {
+    addSerializeCallback,
+    isBuildingSnapshot,
+  },
+} = require('internal/v8/startup_snapshot');
+// TODO(joyeecheung): deprecate and remove these underscore methods
+process._debugProcess = rawMethods._debugProcess;
+process._debugEnd = rawMethods._debugEnd;
+
+// See the discussion in https://github.com/nodejs/node/issues/19009 and
+// https://github.com/nodejs/node/pull/34010 for why these are no-ops.
+// Five word summary: they were broken beyond repair.
+process._startProfilerIdleNotifier = () => {};
+process._stopProfilerIdleNotifier = () => {};
+
+function defineStream(name, getter) {
+  ObjectDefineProperty(process, name, {
+    __proto__: null,
+    configurable: true,
+    enumerable: true,
+    get: getter,
+  });
+}
+
+defineStream('stdout', getStdout);
+defineStream('stdin', getStdin);
+defineStream('stderr', getStderr);
+
+// Worker threads don't receive signals.
+const {
+  startListeningIfSignal,
+  stopListeningIfSignal,
+} = require('internal/process/signal');
+process.on('newListener', startListeningIfSignal);
+process.on('removeListener', stopListeningIfSignal);
+
+// ---- keep the attachment of the wrappers above so that it's easier to ----
+// ----              compare the setups side-by-side                    -----
+
+const { guessHandleType } = require('internal/util');
+
+function createWritableStdioStream(fd) {
+  let stream;
+  // Note stream._type is used for test-module-load-list.js
+  switch (guessHandleType(fd)) {
+    case 'TTY': {
+      const tty = require('tty');
+      stream = new tty.WriteStream(fd);
+      stream._type = 'tty';
+      break;
+    }
+
+    case 'FILE': {
+      const SyncWriteStream = require('internal/fs/sync_write_stream');
+      stream = new SyncWriteStream(fd, { autoClose: false });
+      stream._type = 'fs';
+      break;
+    }
+
+    case 'PIPE':
+    case 'TCP': {
+      const net = require('net');
+
+      // If fd is already being used for the IPC channel, libuv will return
+      // an error when trying to use it again. In that case, create the socket
+      // using the existing handle instead of the fd.
+      if (process.channel && process.channel.fd === fd) {
+        const { kChannelHandle } = require('internal/child_process');
+        stream = new net.Socket({
+          handle: process[kChannelHandle],
+          readable: false,
+          writable: true,
+        });
+      } else {
+        stream = new net.Socket({
+          fd,
+          readable: false,
+          writable: true,
+        });
+      }
+
+      stream._type = 'pipe';
+      break;
+    }
+
+    default: {
+      // Provide a dummy black-hole output for e.g. non-console
+      // Windows applications.
+      const { Writable } = require('stream');
+      stream = new Writable({
+        write(buf, enc, cb) {
+          cb();
+        },
+      });
+    }
+  }
+
+  // For supporting legacy API we put the FD here.
+  stream.fd = fd;
+
+  stream._isStdio = true;
+
+  return stream;
+}
+
+function dummyDestroy(err, cb) {
+  cb(err);
+  this._undestroy();
+
+  // We need to emit 'close' anyway so that the closing
+  // of the stream is observable. We just make sure we
+  // are not going to do it twice.
+  // The 'close' event is needed so that finished and
+  // pipeline work correctly.
+  if (!this._writableState.emitClose) {
+    process.nextTick(() => {
+      this.emit('close');
+    });
+  }
+}
+
+let stdin;
+let stdout;
+let stderr;
+
+let stdoutDestroy;
+let stderrDestroy;
+
+function refreshStdoutOnSigWinch() {
+  stdout._refreshSize();
+}
+
+function refreshStderrOnSigWinch() {
+  stderr._refreshSize();
+}
+
+function addCleanup(fn) {
+  if (isBuildingSnapshot()) {
+    addSerializeCallback(fn);
+  }
+}
+
+function getStdout() {
+  if (stdout) return stdout;
+  stdout = createWritableStdioStream(1);
+  stdout.destroySoon = stdout.destroy;
+  // Override _destroy so that the fd is never actually closed.
+  stdoutDestroy = stdout._destroy;
+  stdout._destroy = dummyDestroy;
+  if (stdout.isTTY) {
+    process.on('SIGWINCH', refreshStdoutOnSigWinch);
+  }
+
+  addCleanup(function cleanupStdout() {
+    stdout._destroy = stdoutDestroy;
+    stdout.destroy();
+    process.removeListener('SIGWINCH', refreshStdoutOnSigWinch);
+    stdout = undefined;
+  });
+  // No need to add deserialize callback because stdout = undefined above
+  // causes the stream to be lazily initialized again later.
+  return stdout;
+}
+
+function getStderr() {
+  if (stderr) return stderr;
+  stderr = createWritableStdioStream(2);
+  stderr.destroySoon = stderr.destroy;
+  stderrDestroy = stderr._destroy;
+  // Override _destroy so that the fd is never actually closed.
+  stderr._destroy = dummyDestroy;
+  if (stderr.isTTY) {
+    process.on('SIGWINCH', refreshStderrOnSigWinch);
+  }
+  addCleanup(function cleanupStderr() {
+    stderr._destroy = stderrDestroy;
+    stderr.destroy();
+    process.removeListener('SIGWINCH', refreshStderrOnSigWinch);
+    stderr = undefined;
+  });
+  // No need to add deserialize callback because stderr = undefined above
+  // causes the stream to be lazily initialized again later.
+  return stderr;
+}
+
+function getStdin() {
+  if (stdin) return stdin;
+  const fd = 0;
+
+  switch (guessHandleType(fd)) {
+    case 'TTY': {
+      const tty = require('tty');
+      stdin = new tty.ReadStream(fd);
+      break;
+    }
+
+    case 'FILE': {
+      const fs = require('fs');
+      stdin = new fs.ReadStream(null, { fd: fd, autoClose: false });
+      break;
+    }
+
+    case 'PIPE':
+    case 'TCP': {
+      const net = require('net');
+
+      // It could be that process has been started with an IPC channel
+      // sitting on fd=0, in such case the pipe for this fd is already
+      // present and creating a new one will lead to the assertion failure
+      // in libuv.
+      if (process.channel && process.channel.fd === fd) {
+        stdin = new net.Socket({
+          handle: process.channel,
+          readable: true,
+          writable: false,
+          manualStart: true,
+        });
+      } else {
+        stdin = new net.Socket({
+          fd: fd,
+          readable: true,
+          writable: false,
+          manualStart: true,
+        });
+      }
+      // Make sure the stdin can't be `.end()`-ed
+      stdin._writableState.ended = true;
+      break;
+    }
+
+    default: {
+      // Provide a dummy contentless input for e.g. non-console
+      // Windows applications.
+      const { Readable } = require('stream');
+      stdin = new Readable({ read() {} });
+      stdin.push(null);
+    }
+  }
+
+  // For supporting legacy API we put the FD here.
+  stdin.fd = fd;
+
+  // `stdin` starts out life in a paused state, but node doesn't
+  // know yet. Explicitly to readStop() it to put it in the
+  // not-reading state.
+  if (stdin._handle?.readStop) {
+    stdin._handle.reading = false;
+    stdin._readableState.reading = false;
+    stdin._handle.readStop();
+  }
+
+  // If the user calls stdin.pause(), then we need to stop reading
+  // once the stream implementation does so (one nextTick later),
+  // so that the process can close down.
+  stdin.on('pause', () => {
+    process.nextTick(onpause);
+  });
+
+  function onpause() {
+    if (!stdin._handle)
+      return;
+    if (stdin._handle.reading && !stdin.readableFlowing) {
+      stdin._readableState.reading = false;
+      stdin._handle.reading = false;
+      stdin._handle.readStop();
+    }
+  }
+
+  addCleanup(function cleanupStdin() {
+    stdin.destroy();
+    stdin = undefined;
+  });
+  // No need to add deserialize callback because stdin = undefined above
+  // causes the stream to be lazily initialized again later.
+  return stdin;
+}
+
+// Used by internal tests.
+rawMethods.resetStdioForTesting = function() {
+  stdin = undefined;
+  stdout = undefined;
+  stderr = undefined;
+};
+
+// Needed by the module loader and generally needed everywhere.
+require('fs');
+require('util');
+require('url'); // eslint-disable-line no-restricted-modules
+internalBinding('module_wrap');
+require('internal/modules/cjs/loader');
+require('internal/modules/esm/utils');
+
+// Needed to refresh the time origin.
+require('internal/perf/utils');
+// Needed to register the async hooks.
+if (internalBinding('config').hasInspector) {
+  require('internal/inspector_async_hook');
+}
+// Needed to set the wasm web API callbacks.
+internalBinding('wasm_web_api');
+// Needed to detect whether it's on main thread.
+internalBinding('worker');
+// Needed by most execution modes.
+require('internal/modules/run_main');
+// Needed to refresh DNS configurations.
+require('internal/dns/utils');
+// Needed by almost all execution modes. It's fine to
+// load them into the snapshot as long as we don't run
+// any of the initialization.
+require('internal/process/pre_execution');

lib/internal/bootstrap/switches/is_not_main_thread.js

@@ -0,0 +1,58 @@
+'use strict';
+
+const {
+  ObjectDefineProperty,
+} = primordials;
+
+delete process._debugProcess;
+delete process._debugEnd;
+
+function defineStream(name, getter) {
+  ObjectDefineProperty(process, name, {
+    __proto__: null,
+    configurable: true,
+    enumerable: true,
+    get: getter,
+  });
+}
+
+defineStream('stdout', getStdout);
+defineStream('stdin', getStdin);
+defineStream('stderr', getStderr);
+
+// Worker threads don't receive signals.
+const {
+  startListeningIfSignal,
+  stopListeningIfSignal,
+} = require('internal/process/signal');
+process.removeListener('newListener', startListeningIfSignal);
+process.removeListener('removeListener', stopListeningIfSignal);
+
+// ---- keep the attachment of the wrappers above so that it's easier to ----
+// ----              compare the setups side-by-side                    -----
+
+const {
+  createWorkerStdio,
+  kStdioWantsMoreDataCallback,
+} = require('internal/worker/io');
+
+let workerStdio;
+function lazyWorkerStdio() {
+  if (workerStdio === undefined) {
+    workerStdio = createWorkerStdio();
+    process.on('exit', flushSync);
+  }
+
+  return workerStdio;
+}
+
+function flushSync() {
+  workerStdio.stdout[kStdioWantsMoreDataCallback]();
+  workerStdio.stderr[kStdioWantsMoreDataCallback]();
+}
+
+function getStdout() { return lazyWorkerStdio().stdout; }
+
+function getStderr() { return lazyWorkerStdio().stderr; }
+
+function getStdin() { return lazyWorkerStdio().stdin; }