From 37c97b1cb7f6aa462b79b33c7fd23472fa2f2148 Mon Sep 17 00:00:00 2001
From: Omar Crisostomo <omarcb@micorreo.upp.edu.mx>
Date: Tue, 26 Dec 2017 22:16:45 -0600
Subject: [PATCH 01/23] test: add test-fs-read-constructor-errors test

test added to extend the code coverage testing of the project
---
 .../test-fs-read-constructor-errors.js        | 107 ++++++++++++++++++
 1 file changed, 107 insertions(+)
 create mode 100644 test/parallel/test-fs-read-constructor-errors.js

diff --git a/test/parallel/test-fs-read-constructor-errors.js b/test/parallel/test-fs-read-constructor-errors.js
new file mode 100644
index 00000000000000..8441aa7e658448
--- /dev/null
+++ b/test/parallel/test-fs-read-constructor-errors.js
@@ -0,0 +1,107 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+const fs = require('fs');
+const filepath = fixtures.path('x.txt');
+const fd = fs.openSync(filepath, 'r');
+
+const expected = Buffer.from('xyz\n');
+
+//fs.read expects incorrect fd parameter
+function testFd(bufferAsync, offset, bufferSync, expected) {
+  common.expectsError(
+    fs.read.bind(fd,
+                 bufferAsync,
+                 offset,
+                 expected.length,
+                 0,
+                 common.mustNotCall()),
+    { code: 'ERR_INVALID_ARG_TYPE', type: TypeError }
+  );
+}
+
+//fs.read expects fd parameter out of range
+function testFdRangeOut(bufferAsync, offset, bufferSync, expected) {
+  common.expectsError(
+    fs.read.bind(undefined,
+                 -1,
+                 bufferAsync,
+                 offset,
+                 expected.length,
+                 0,
+                 common.mustNotCall()),
+    { code: 'ERR_OUT_OF_RANGE', type: RangeError }
+  );
+}
+
+//fs.read expects offset parameter out of range
+function testOffSet(bufferAsync, offset, length, expected) {
+  common.expectsError(
+    fs.read.bind(undefined,
+                 fd,
+                 bufferAsync,
+                 offset,
+                 expected.length,
+                 0,
+                 common.mustNotCall()),
+    { code: 'ERR_OUT_OF_RANGE', type: RangeError }
+  );
+}
+
+//fs.read expects length parameter out of range
+function testLenght(bufferAsync, offset, length) {
+  common.expectsError(
+    fs.read.bind(undefined,
+                 fd,
+                 bufferAsync,
+                 offset,
+                 length,
+                 0,
+                 common.mustNotCall()),
+    { code: 'ERR_OUT_OF_RANGE', type: RangeError }
+  );
+}
+
+//test fd parameter
+testFd(Buffer.allocUnsafe(expected.length),
+       0,
+       Buffer.allocUnsafe(expected.length),
+       expected);
+
+//test fd parameter out of range
+testFdRangeOut(Buffer.allocUnsafe(expected.length),
+               0,
+               Buffer.allocUnsafe(expected.length),
+               expected);
+
+//test offset parameter out of range
+testOffSet(Buffer.allocUnsafe(expected.length),
+           -1,
+           Buffer.allocUnsafe(expected.length),
+           expected);
+
+//test length parameter out of range
+testLenght(Buffer.allocUnsafe(expected.length),
+           0,
+           -1);

From d7326b245437deb004bda8ac673bcaf78df5e2cc Mon Sep 17 00:00:00 2001
From: Omar Crisostomo <omarcb@micorreo.upp.edu.mx>
Date: Tue, 26 Dec 2017 22:17:17 -0600
Subject: [PATCH 02/23] test: add test-fs-readSync-constructor-errors test

test added to extend the code coverage testing of the project
---
 .../test-fs-readSyc-constructor-errors.js     | 103 ++++++++++++++++++
 1 file changed, 103 insertions(+)
 create mode 100644 test/parallel/test-fs-readSyc-constructor-errors.js

diff --git a/test/parallel/test-fs-readSyc-constructor-errors.js b/test/parallel/test-fs-readSyc-constructor-errors.js
new file mode 100644
index 00000000000000..45722ae0ad11bd
--- /dev/null
+++ b/test/parallel/test-fs-readSyc-constructor-errors.js
@@ -0,0 +1,103 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+const fs = require('fs');
+const filepath = fixtures.path('x.txt');
+const fd = fs.openSync(filepath, 'r');
+
+const expected = Buffer.from('xyz\n');
+
+//fs.readSync expects incorrect fd parameter
+function testFd(bufferAsync, offset, bufferSync, expected) {
+  common.expectsError(
+    fs.readSync.bind(fd,
+                     bufferAsync,
+                     offset,
+                     expected.length,
+                     0),
+    { code: 'ERR_INVALID_ARG_TYPE', type: TypeError }
+  );
+}
+
+//fs.readSync expects fd parameter out of range
+function testFdRangeOut(bufferAsync, offset, bufferSync, expected) {
+  common.expectsError(
+    fs.readSync.bind(undefined,
+                     -1,
+                     bufferAsync,
+                     offset,
+                     expected.length,
+                     0),
+    { code: 'ERR_OUT_OF_RANGE', type: RangeError }
+  );
+}
+
+//fs.readSync expects offset parameter out of range
+function testOffSet(bufferAsync, offset, length, expected) {
+  common.expectsError(
+    fs.readSync.bind(undefined,
+                     fd,
+                     bufferAsync,
+                     offset,
+                     expected.length,
+                     0),
+    { code: 'ERR_OUT_OF_RANGE', type: RangeError }
+  );
+}
+
+//fs.readSync expects length parameter out of range
+function testLenght(bufferAsync, offset, length) {
+  common.expectsError(
+    fs.readSync.bind(undefined,
+                     fd,
+                     bufferAsync,
+                     offset,
+                     length,
+                     0),
+    { code: 'ERR_OUT_OF_RANGE', type: RangeError }
+  );
+}
+
+//test fd parameter
+testFd(Buffer.allocUnsafe(expected.length),
+       0,
+       Buffer.allocUnsafe(expected.length),
+       expected);
+
+//test fd parameter out of range
+testFdRangeOut(Buffer.allocUnsafe(expected.length),
+               0,
+               Buffer.allocUnsafe(expected.length),
+               expected);
+
+//test offset parameter out of range
+testOffSet(Buffer.allocUnsafe(expected.length),
+           -1,
+           Buffer.allocUnsafe(expected.length),
+           expected);
+
+//test length parameter out of range
+testLenght(Buffer.allocUnsafe(expected.length),
+           0,
+           -1);

From bd3aa3e0489be72dc3cd3ea945d43900e792bb35 Mon Sep 17 00:00:00 2001
From: Omar Crisostomo <omarcb@micorreo.upp.edu.mx>
Date: Wed, 27 Dec 2017 03:09:07 -0600
Subject: [PATCH 03/23] test: add test-fs-read-constructor-errors test

test added to extend the code coverage testing of the project
---
 .../test-fs-read-constructor-errors.js        | 99 +++++--------------
 1 file changed, 25 insertions(+), 74 deletions(-)

diff --git a/test/parallel/test-fs-read-constructor-errors.js b/test/parallel/test-fs-read-constructor-errors.js
index 8441aa7e658448..5c47063d74c396 100644
--- a/test/parallel/test-fs-read-constructor-errors.js
+++ b/test/parallel/test-fs-read-constructor-errors.js
@@ -28,80 +28,31 @@ const fd = fs.openSync(filepath, 'r');
 
 const expected = Buffer.from('xyz\n');
 
-//fs.read expects incorrect fd parameter
-function testFd(bufferAsync, offset, bufferSync, expected) {
-  common.expectsError(
-    fs.read.bind(fd,
-                 bufferAsync,
-                 offset,
-                 expected.length,
-                 0,
-                 common.mustNotCall()),
-    { code: 'ERR_INVALID_ARG_TYPE', type: TypeError }
-  );
-}
-
-//fs.read expects fd parameter out of range
-function testFdRangeOut(bufferAsync, offset, bufferSync, expected) {
-  common.expectsError(
-    fs.read.bind(undefined,
-                 -1,
-                 bufferAsync,
-                 offset,
-                 expected.length,
-                 0,
-                 common.mustNotCall()),
-    { code: 'ERR_OUT_OF_RANGE', type: RangeError }
-  );
-}
-
-//fs.read expects offset parameter out of range
-function testOffSet(bufferAsync, offset, length, expected) {
-  common.expectsError(
-    fs.read.bind(undefined,
-                 fd,
-                 bufferAsync,
-                 offset,
-                 expected.length,
-                 0,
-                 common.mustNotCall()),
-    { code: 'ERR_OUT_OF_RANGE', type: RangeError }
-  );
-}
-
-//fs.read expects length parameter out of range
-function testLenght(bufferAsync, offset, length) {
-  common.expectsError(
-    fs.read.bind(undefined,
-                 fd,
-                 bufferAsync,
-                 offset,
-                 length,
-                 0,
-                 common.mustNotCall()),
-    { code: 'ERR_OUT_OF_RANGE', type: RangeError }
-  );
-}
-
-//test fd parameter
-testFd(Buffer.allocUnsafe(expected.length),
-       0,
-       Buffer.allocUnsafe(expected.length),
-       expected);
-
-//test fd parameter out of range
-testFdRangeOut(Buffer.allocUnsafe(expected.length),
-               0,
+common.expectsError(
+  fs.read.bind(fd,
                Buffer.allocUnsafe(expected.length),
-               expected);
+               0,
+               expected.length,
+               0,
+               common.mustNotCall()),
+  { code: 'ERR_INVALID_ARG_TYPE', type: TypeError });
 
-//test offset parameter out of range
-testOffSet(Buffer.allocUnsafe(expected.length),
-           -1,
-           Buffer.allocUnsafe(expected.length),
-           expected);
+common.expectsError(
+  fs.read.bind(undefined,
+               fd,
+               Buffer.allocUnsafe(expected.length),
+               -1,
+               expected.length,
+               0,
+               common.mustNotCall()),
+  { code: 'ERR_OUT_OF_RANGE', type: RangeError });
 
-//test length parameter out of range
-testLenght(Buffer.allocUnsafe(expected.length),
-           0,
-           -1);
+common.expectsError(
+  fs.read.bind(undefined,
+               fd,
+               Buffer.allocUnsafe(expected.length),
+               0,
+               -1,
+               0,
+               common.mustNotCall()),
+  { code: 'ERR_OUT_OF_RANGE', type: RangeError });

From 5e59b4fab76ef108acec8e882c5c09fb16d65e6c Mon Sep 17 00:00:00 2001
From: Omar Crisostomo <omarcb@micorreo.upp.edu.mx>
Date: Wed, 27 Dec 2017 03:09:42 -0600
Subject: [PATCH 04/23] test: add test-fs-readSync-constructor-errors test

test added to extend the code coverage testing of the project
---
 .../test-fs-readSyc-constructor-errors.js     | 98 +++++--------------
 1 file changed, 25 insertions(+), 73 deletions(-)

diff --git a/test/parallel/test-fs-readSyc-constructor-errors.js b/test/parallel/test-fs-readSyc-constructor-errors.js
index 45722ae0ad11bd..17ddc5454eb7cc 100644
--- a/test/parallel/test-fs-readSyc-constructor-errors.js
+++ b/test/parallel/test-fs-readSyc-constructor-errors.js
@@ -28,76 +28,28 @@ const fd = fs.openSync(filepath, 'r');
 
 const expected = Buffer.from('xyz\n');
 
-//fs.readSync expects incorrect fd parameter
-function testFd(bufferAsync, offset, bufferSync, expected) {
-  common.expectsError(
-    fs.readSync.bind(fd,
-                     bufferAsync,
-                     offset,
-                     expected.length,
-                     0),
-    { code: 'ERR_INVALID_ARG_TYPE', type: TypeError }
-  );
-}
-
-//fs.readSync expects fd parameter out of range
-function testFdRangeOut(bufferAsync, offset, bufferSync, expected) {
-  common.expectsError(
-    fs.readSync.bind(undefined,
-                     -1,
-                     bufferAsync,
-                     offset,
-                     expected.length,
-                     0),
-    { code: 'ERR_OUT_OF_RANGE', type: RangeError }
-  );
-}
-
-//fs.readSync expects offset parameter out of range
-function testOffSet(bufferAsync, offset, length, expected) {
-  common.expectsError(
-    fs.readSync.bind(undefined,
-                     fd,
-                     bufferAsync,
-                     offset,
-                     expected.length,
-                     0),
-    { code: 'ERR_OUT_OF_RANGE', type: RangeError }
-  );
-}
-
-//fs.readSync expects length parameter out of range
-function testLenght(bufferAsync, offset, length) {
-  common.expectsError(
-    fs.readSync.bind(undefined,
-                     fd,
-                     bufferAsync,
-                     offset,
-                     length,
-                     0),
-    { code: 'ERR_OUT_OF_RANGE', type: RangeError }
-  );
-}
-
-//test fd parameter
-testFd(Buffer.allocUnsafe(expected.length),
-       0,
-       Buffer.allocUnsafe(expected.length),
-       expected);
-
-//test fd parameter out of range
-testFdRangeOut(Buffer.allocUnsafe(expected.length),
-               0,
-               Buffer.allocUnsafe(expected.length),
-               expected);
-
-//test offset parameter out of range
-testOffSet(Buffer.allocUnsafe(expected.length),
-           -1,
-           Buffer.allocUnsafe(expected.length),
-           expected);
-
-//test length parameter out of range
-testLenght(Buffer.allocUnsafe(expected.length),
-           0,
-           -1);
+common.expectsError(
+  fs.readSync.bind(fd,
+                   Buffer.allocUnsafe(expected.length),
+                   0,
+                   expected.length,
+                   0),
+  { code: 'ERR_INVALID_ARG_TYPE', type: TypeError });
+
+common.expectsError(
+  fs.readSync.bind(undefined,
+                   fd,
+                   Buffer.allocUnsafe(expected.length),
+                   -1,
+                   expected.length,
+                   0),
+  { code: 'ERR_OUT_OF_RANGE', type: RangeError });
+
+common.expectsError(
+  fs.readSync.bind(undefined,
+                   1,
+                   Buffer.allocUnsafe(expected.length),
+                   0,
+                   -1,
+                   0),
+  { code: 'ERR_OUT_OF_RANGE', type: RangeError });

From 9ec700b073894ad54432db4c4b540e2b61b45325 Mon Sep 17 00:00:00 2001
From: Joyee Cheung <joyeec9h3@gmail.com>
Date: Mon, 25 Dec 2017 05:00:24 +0800
Subject: [PATCH 05/23] fs: validate path in fs.readFile

PR-URL: https://github.com/nodejs/node/pull/17852
Refs: https://github.com/nodejs/node/pull/17667
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 lib/fs.js                               |  3 +++
 test/parallel/test-fs-readfile-error.js | 10 ++++++++++
 2 files changed, 13 insertions(+)

diff --git a/lib/fs.js b/lib/fs.js
index 7741e5838bd216..e41d0db03390b0 100644
--- a/lib/fs.js
+++ b/lib/fs.js
@@ -389,6 +389,9 @@ fs.readFile = function(path, options, callback) {
       req.oncomplete(null, path);
     });
     return;
+  } else if (typeof path !== 'string' && !(path instanceof Buffer)) {
+    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'path',
+                               ['string', 'Buffer', 'URL']);
   }
 
   binding.open(pathModule.toNamespacedPath(path),
diff --git a/test/parallel/test-fs-readfile-error.js b/test/parallel/test-fs-readfile-error.js
index 616760b06695a1..9b1a06183d7530 100644
--- a/test/parallel/test-fs-readfile-error.js
+++ b/test/parallel/test-fs-readfile-error.js
@@ -21,6 +21,7 @@
 
 'use strict';
 const common = require('../common');
+const fs = require('fs');
 
 // Test that fs.readFile fails correctly on a non-existent file.
 
@@ -54,3 +55,12 @@ test({ NODE_DEBUG: 'fs' }, common.mustCall((data) => {
   assert(/EISDIR/.test(data));
   assert(/test-fs-readfile-error/.test(data));
 }));
+
+common.expectsError(
+  () => { fs.readFile(() => {}); },
+  {
+    code: 'ERR_INVALID_ARG_TYPE',
+    message: 'The "path" argument must be one of type string, Buffer, or URL',
+    type: TypeError
+  }
+);

From 71396a200d75b11a71af7caae18d12f3dc461d07 Mon Sep 17 00:00:00 2001
From: Joyee Cheung <joyeec9h3@gmail.com>
Date: Mon, 25 Dec 2017 05:01:11 +0800
Subject: [PATCH 06/23] fs: validate path in fs.exists{Sync}

PR-URL: https://github.com/nodejs/node/pull/17852
Refs: https://github.com/nodejs/node/pull/17667
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 lib/fs.js                       |  7 +++++++
 test/parallel/test-fs-exists.js | 11 +++++++++++
 2 files changed, 18 insertions(+)

diff --git a/lib/fs.js b/lib/fs.js
index e41d0db03390b0..93be37533405da 100644
--- a/lib/fs.js
+++ b/lib/fs.js
@@ -340,6 +340,10 @@ fs.accessSync = function(path, mode) {
 fs.exists = function(path, callback) {
   if (handleError((path = getPathFromURL(path)), cb))
     return;
+  if (typeof path !== 'string' && !(path instanceof Buffer)) {
+    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'path',
+                               ['string', 'Buffer', 'URL']);
+  }
   if (!nullCheck(path, cb)) return;
   var req = new FSReqWrap();
   req.oncomplete = cb;
@@ -361,6 +365,9 @@ Object.defineProperty(fs.exists, internalUtil.promisify.custom, {
 fs.existsSync = function(path) {
   try {
     handleError((path = getPathFromURL(path)));
+    if (typeof path !== 'string' && !(path instanceof Buffer)) {
+      return false;
+    }
     nullCheck(path);
     binding.stat(pathModule.toNamespacedPath(path));
     return true;
diff --git a/test/parallel/test-fs-exists.js b/test/parallel/test-fs-exists.js
index 331c8c04e38e78..a526373c6a876d 100644
--- a/test/parallel/test-fs-exists.js
+++ b/test/parallel/test-fs-exists.js
@@ -42,3 +42,14 @@ fs.exists(new URL('https://foo'), common.mustCall(function(y) {
 
 assert(fs.existsSync(f));
 assert(!fs.existsSync(`${f}-NO`));
+
+common.expectsError(
+  () => { fs.exists(() => {}); },
+  {
+    code: 'ERR_INVALID_ARG_TYPE',
+    message: 'The "path" argument must be one of type string, Buffer, or URL',
+    type: TypeError
+  }
+);
+
+assert(!fs.existsSync());

From c0e9cded1ec9daeec178d536b39acf944f80809c Mon Sep 17 00:00:00 2001
From: Eugene Ostroukhov <eostroukhov@google.com>
Date: Wed, 13 Dec 2017 09:24:35 -0800
Subject: [PATCH 07/23] inspector: make Coverity happy

PR-URL: https://github.com/nodejs/node/pull/17656
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Timothy Gu <timothygu99@gmail.com>
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
---
 src/inspector_socket.cc | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/inspector_socket.cc b/src/inspector_socket.cc
index 386b4c3af07a2d..ad8b502da307c0 100644
--- a/src/inspector_socket.cc
+++ b/src/inspector_socket.cc
@@ -116,6 +116,7 @@ class WriteRequest {
   WriteRequest(ProtocolHandler* handler, const std::vector<char>& buffer)
       : handler(handler)
       , storage(buffer)
+      , req(uv_write_t())
       , buf(uv_buf_init(storage.data(), storage.size())) {}
 
   static WriteRequest* from_write_req(uv_write_t* req) {

From b0dd43cd6379a77a4e437f6ba1fdda7c0b4b744a Mon Sep 17 00:00:00 2001
From: Dmitriy Kasyanov <korvin1986@gmail.com>
Date: Wed, 13 Dec 2017 23:21:24 +0200
Subject: [PATCH 08/23] tools: fix AttributeError: __exit__ on Python 2.6

Error occurs while dealing with Tar archives

PR-URL: https://github.com/nodejs/node/pull/17663
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Steven R Loomis <srloomis@us.ibm.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 tools/configure.d/nodedownload.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/configure.d/nodedownload.py b/tools/configure.d/nodedownload.py
index 5cf8e0dbd690e1..3f4bc090f71bdd 100644
--- a/tools/configure.d/nodedownload.py
+++ b/tools/configure.d/nodedownload.py
@@ -60,7 +60,7 @@ def unpack(packedfile, parent_path):
             icuzip.extractall(parent_path)
             return parent_path
     elif tarfile.is_tarfile(packedfile):
-        with tarfile.TarFile.open(packedfile, 'r') as icuzip:
+        with contextlib.closing(tarfile.TarFile.open(packedfile, 'r')) as icuzip:
             print ' Extracting tarfile: %s' % packedfile
             icuzip.extractall(parent_path)
             return parent_path

From 6c0da349056578d36254d1aed973ddbaa252ce89 Mon Sep 17 00:00:00 2001
From: XadillaX <i@2333.moe>
Date: Thu, 14 Dec 2017 12:40:32 +0800
Subject: [PATCH 09/23] http: add rawPacket in err of `clientError` event

The `rawPacket` is the current buffer that just parsed. Adding this
buffer to the error object of `clientError` event is to make it possible
that developers can log the broken packet.

PR-URL: https://github.com/nodejs/node/pull/17672
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 doc/api/http.md                                | 11 +++++++++++
 lib/_http_server.js                            |  1 +
 test/parallel/test-http-server-client-error.js |  6 ++++++
 3 files changed, 18 insertions(+)

diff --git a/doc/api/http.md b/doc/api/http.md
index 9f06296e6e2584..928ed0d972b472 100644
--- a/doc/api/http.md
+++ b/doc/api/http.md
@@ -734,6 +734,11 @@ changes:
     description: The default action of calling `.destroy()` on the `socket`
                  will no longer take place if there are listeners attached
                  for `clientError`.
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/17672
+    description: The rawPacket is the current buffer that just parsed. Adding
+                 this buffer to the error object of clientError event is to make
+                 it possible that developers can log the broken packet.
 -->
 
 * `exception` {Error}
@@ -765,6 +770,12 @@ object, so any HTTP response sent, including response headers and payload,
 *must* be written directly to the `socket` object. Care must be taken to
 ensure the response is a properly formatted HTTP response message.
 
+`err` is an instance of `Error` with two extra columns:
+
++ `bytesParsed`: the bytes count of request packet that Node.js may have parsed
+  correctly;
++ `rawPacket`: the raw packet of current request.
+
 ### Event: 'close'
 <!-- YAML
 added: v0.1.4
diff --git a/lib/_http_server.js b/lib/_http_server.js
index cab48245010ae7..5857e43d79c787 100644
--- a/lib/_http_server.js
+++ b/lib/_http_server.js
@@ -476,6 +476,7 @@ function onParserExecuteCommon(server, socket, parser, state, ret, d) {
   resetSocketTimeout(server, socket, state);
 
   if (ret instanceof Error) {
+    ret.rawPacket = d || parser.getCurrentBuffer();
     debug('parse error', ret);
     socketOnError.call(socket, ret);
   } else if (parser.incoming && parser.incoming.upgrade) {
diff --git a/test/parallel/test-http-server-client-error.js b/test/parallel/test-http-server-client-error.js
index 88c224f8374145..ffe78941553367 100644
--- a/test/parallel/test-http-server-client-error.js
+++ b/test/parallel/test-http-server-client-error.js
@@ -10,6 +10,12 @@ const server = http.createServer(common.mustCall(function(req, res) {
 }));
 
 server.on('clientError', common.mustCall(function(err, socket) {
+  assert.strictEqual(err instanceof Error, true);
+  assert.strictEqual(err.code, 'HPE_INVALID_METHOD');
+  assert.strictEqual(err.bytesParsed, 1);
+  assert.strictEqual(err.message, 'Parse Error');
+  assert.strictEqual(err.rawPacket.toString(), 'Oopsie-doopsie\r\n');
+
   socket.end('HTTP/1.1 400 Bad Request\r\n\r\n');
 
   server.close();

From 9e5ccf0313b7167d710e50c511db17ecfcdf416f Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Thu, 21 Dec 2017 14:29:05 -0800
Subject: [PATCH 10/23] perf_hooks: refactor internals

Refactor and simplify the perf_hooks native internals.

PR-URL: https://github.com/nodejs/node/pull/17822
Reviewed-By: Anna Henningsen <anna@addaleax.net>
---
 src/node_perf.cc | 259 ++++++++++++++++++++---------------------------
 src/node_perf.h  | 134 ++++++++----------------
 2 files changed, 150 insertions(+), 243 deletions(-)

diff --git a/src/node_perf.cc b/src/node_perf.cc
index 37256a943cb014..fcf7cd8b5af4e0 100644
--- a/src/node_perf.cc
+++ b/src/node_perf.cc
@@ -17,9 +17,8 @@ using v8::Integer;
 using v8::Isolate;
 using v8::Local;
 using v8::Name;
+using v8::Number;
 using v8::Object;
-using v8::ObjectTemplate;
-using v8::Signature;
 using v8::String;
 using v8::Value;
 
@@ -30,37 +29,78 @@ uint64_t performance_v8_start;
 uint64_t performance_last_gc_start_mark_ = 0;
 v8::GCType performance_last_gc_type_ = v8::GCType::kGCTypeAll;
 
+// Initialize the performance entry object properties
+inline void InitObject(const PerformanceEntry& entry, Local<Object> obj) {
+  Environment* env = entry.env();
+  Isolate* isolate = env->isolate();
+  Local<Context> context = env->context();
+  v8::PropertyAttribute attr =
+      static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontDelete);
+  obj->DefineOwnProperty(context,
+                         env->name_string(),
+                         String::NewFromUtf8(isolate,
+                                             entry.name().c_str(),
+                                             String::kNormalString),
+                         attr).FromJust();
+  obj->DefineOwnProperty(context,
+                         FIXED_ONE_BYTE_STRING(isolate, "entryType"),
+                         String::NewFromUtf8(isolate,
+                                             entry.type().c_str(),
+                                             String::kNormalString),
+                         attr).FromJust();
+  obj->DefineOwnProperty(context,
+                         FIXED_ONE_BYTE_STRING(isolate, "startTime"),
+                         Number::New(isolate, entry.startTime()),
+                         attr).FromJust();
+  obj->DefineOwnProperty(context,
+                         FIXED_ONE_BYTE_STRING(isolate, "duration"),
+                         Number::New(isolate, entry.duration()),
+                         attr).FromJust();
+}
+
+// Create a new PerformanceEntry object
+const Local<Object> PerformanceEntry::ToObject() const {
+  Local<Object> obj =
+      env_->performance_entry_template()
+          ->NewInstance(env_->context()).ToLocalChecked();
+  InitObject(*this, obj);
+  return obj;
+}
+
+// Allow creating a PerformanceEntry object from JavaScript
 void PerformanceEntry::New(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   Isolate* isolate = env->isolate();
   Utf8Value name(isolate, args[0]);
   Utf8Value type(isolate, args[1]);
   uint64_t now = PERFORMANCE_NOW();
-  new PerformanceEntry(env, args.This(), *name, *type, now, now);
+  PerformanceEntry entry(env, *name, *type, now, now);
+  Local<Object> obj = args.This();
+  InitObject(entry, obj);
+  PerformanceEntry::Notify(env, entry.kind(), obj);
 }
 
-void PerformanceEntry::NotifyObservers(Environment* env,
-                                       PerformanceEntry* entry) {
+// Pass the PerformanceEntry object to the PerformanceObservers
+inline void PerformanceEntry::Notify(Environment* env,
+                                     PerformanceEntryType type,
+                                     Local<Value> object) {
+  Context::Scope scope(env->context());
   uint32_t* observers = env->performance_state()->observers;
-  PerformanceEntryType type = ToPerformanceEntryTypeEnum(entry->type().c_str());
-  if (observers == nullptr ||
-      type == NODE_PERFORMANCE_ENTRY_TYPE_INVALID ||
-      !observers[type]) {
-    return;
+  if (observers != nullptr &&
+      type != NODE_PERFORMANCE_ENTRY_TYPE_INVALID &&
+      observers[type]) {
+    node::MakeCallback(env->isolate(),
+                       env->process_object(),
+                       env->performance_entry_callback(),
+                       1, &object);
   }
-  Local<Context> context = env->context();
-  Isolate* isolate = env->isolate();
-  Local<Value> argv = entry->object();
-  env->performance_entry_callback()->Call(context,
-                                          v8::Undefined(isolate),
-                                          1, &argv).ToLocalChecked();
 }
 
+// Create a User Timing Mark
 void Mark(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
-  Local<Context> context = env->context();
-  Isolate* isolate = env->isolate();
-  Utf8Value name(isolate, args[0]);
+  HandleScope scope(env->isolate());
+  Utf8Value name(env->isolate(), args[0]);
   uint64_t now = PERFORMANCE_NOW();
   auto marks = env->performance_marks();
   (*marks)[*name] = now;
@@ -68,25 +108,27 @@ void Mark(const FunctionCallbackInfo<Value>& args) {
   // TODO(jasnell): Once Tracing API is fully implemented, this should
   // record a trace event also.
 
-  Local<Function> fn = env->performance_entry_template();
-  Local<Object> obj = fn->NewInstance(context).ToLocalChecked();
-  new PerformanceEntry(env, obj, *name, "mark", now, now);
+  PerformanceEntry entry(env, *name, "mark", now, now);
+  Local<Object> obj = entry.ToObject();
+  PerformanceEntry::Notify(env, entry.kind(), obj);
   args.GetReturnValue().Set(obj);
 }
 
+
 inline uint64_t GetPerformanceMark(Environment* env, std::string name) {
   auto marks = env->performance_marks();
   auto res = marks->find(name);
   return res != marks->end() ? res->second : 0;
 }
 
+// Create a User Timing Measure. A Measure is a PerformanceEntry that
+// measures the duration between two distinct user timing marks
 void Measure(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
-  Local<Context> context = env->context();
-  Isolate* isolate = env->isolate();
-  Utf8Value name(isolate, args[0]);
-  Utf8Value startMark(isolate, args[1]);
-  Utf8Value endMark(isolate, args[2]);
+  HandleScope scope(env->isolate());
+  Utf8Value name(env->isolate(), args[0]);
+  Utf8Value startMark(env->isolate(), args[1]);
+  Utf8Value endMark(env->isolate(), args[2]);
 
   double* milestones = env->performance_state()->milestones;
 
@@ -113,41 +155,13 @@ void Measure(const FunctionCallbackInfo<Value>& args) {
   // TODO(jasnell): Once Tracing API is fully implemented, this should
   // record a trace event also.
 
-  Local<Function> fn = env->performance_entry_template();
-  Local<Object> obj = fn->NewInstance(context).ToLocalChecked();
-  new PerformanceEntry(env, obj, *name, "measure",
-                       startTimestamp, endTimestamp);
+  PerformanceEntry entry(env, *name, "measure", startTimestamp, endTimestamp);
+  Local<Object> obj = entry.ToObject();
+  PerformanceEntry::Notify(env, entry.kind(), obj);
   args.GetReturnValue().Set(obj);
 }
 
-void GetPerformanceEntryName(const FunctionCallbackInfo<Value>& info) {
-  Isolate* isolate = info.GetIsolate();
-  PerformanceEntry* entry;
-  ASSIGN_OR_RETURN_UNWRAP(&entry, info.Holder());
-  info.GetReturnValue().Set(
-    String::NewFromUtf8(isolate, entry->name().c_str(), String::kNormalString));
-}
-
-void GetPerformanceEntryType(const FunctionCallbackInfo<Value>& info) {
-  Isolate* isolate = info.GetIsolate();
-  PerformanceEntry* entry;
-  ASSIGN_OR_RETURN_UNWRAP(&entry, info.Holder());
-  info.GetReturnValue().Set(
-    String::NewFromUtf8(isolate, entry->type().c_str(), String::kNormalString));
-}
-
-void GetPerformanceEntryStartTime(const FunctionCallbackInfo<Value>& info) {
-  PerformanceEntry* entry;
-  ASSIGN_OR_RETURN_UNWRAP(&entry, info.Holder());
-  info.GetReturnValue().Set(entry->startTime());
-}
-
-void GetPerformanceEntryDuration(const FunctionCallbackInfo<Value>& info) {
-  PerformanceEntry* entry;
-  ASSIGN_OR_RETURN_UNWRAP(&entry, info.Holder());
-  info.GetReturnValue().Set(entry->duration());
-}
-
+// Allows specific Node.js lifecycle milestones to be set from JavaScript
 void MarkMilestone(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   Local<Context> context = env->context();
@@ -160,44 +174,35 @@ void MarkMilestone(const FunctionCallbackInfo<Value>& args) {
   }
 }
 
+
 void SetupPerformanceObservers(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   CHECK(args[0]->IsFunction());
   env->set_performance_entry_callback(args[0].As<Function>());
 }
 
-void PerformanceGCCallback(uv_async_t* handle) {
-  PerformanceEntry::Data* data =
-      static_cast<PerformanceEntry::Data*>(handle->data);
-  Environment* env = data->env();
-  Isolate* isolate = env->isolate();
-  HandleScope scope(isolate);
+// Creates a GC Performance Entry and passes it to observers
+void PerformanceGCCallback(Environment* env, void* ptr) {
+  GCPerformanceEntry* entry = static_cast<GCPerformanceEntry*>(ptr);
+  HandleScope scope(env->isolate());
   Local<Context> context = env->context();
-  Context::Scope context_scope(context);
-  Local<Function> fn;
-  Local<Object> obj;
-  PerformanceGCKind kind = static_cast<PerformanceGCKind>(data->data());
 
   uint32_t* observers = env->performance_state()->observers;
-  if (!observers[NODE_PERFORMANCE_ENTRY_TYPE_GC]) {
-    goto cleanup;
+  if (observers[NODE_PERFORMANCE_ENTRY_TYPE_GC]) {
+    Local<Object> obj = entry->ToObject();
+    v8::PropertyAttribute attr =
+        static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontDelete);
+    obj->DefineOwnProperty(context,
+                           FIXED_ONE_BYTE_STRING(env->isolate(), "kind"),
+                           Integer::New(env->isolate(), entry->gckind()),
+                           attr).FromJust();
+    PerformanceEntry::Notify(env, entry->kind(), obj);
   }
 
-  fn = env->performance_entry_template();
-  obj = fn->NewInstance(context).ToLocalChecked();
-  obj->Set(context,
-           FIXED_ONE_BYTE_STRING(isolate, "kind"),
-           Integer::New(isolate, kind)).FromJust();
-  new PerformanceEntry(env, obj, data);
-
- cleanup:
-  delete data;
-  auto closeCB = [](uv_handle_t* handle) {
-    delete reinterpret_cast<uv_async_t*>(handle);
-  };
-  uv_close(reinterpret_cast<uv_handle_t*>(handle), closeCB);
+  delete entry;
 }
 
+// Marks the start of a GC cycle
 void MarkGarbageCollectionStart(Isolate* isolate,
                                 v8::GCType type,
                                 v8::GCCallbackFlags flags) {
@@ -205,28 +210,27 @@ void MarkGarbageCollectionStart(Isolate* isolate,
   performance_last_gc_type_ = type;
 }
 
+// Marks the end of a GC cycle
 void MarkGarbageCollectionEnd(Isolate* isolate,
                               v8::GCType type,
                               v8::GCCallbackFlags flags,
                               void* data) {
   Environment* env = static_cast<Environment*>(data);
-  uv_async_t* async = new uv_async_t();  // coverity[leaked_storage]
-  if (uv_async_init(env->event_loop(), async, PerformanceGCCallback))
-    return delete async;
-  uv_unref(reinterpret_cast<uv_handle_t*>(async));
-  async->data =
-      new PerformanceEntry::Data(env, "gc", "gc",
-                                 performance_last_gc_start_mark_,
-                                 PERFORMANCE_NOW(), type);
-  CHECK_EQ(0, uv_async_send(async));
+  env->SetImmediate(PerformanceGCCallback,
+                    new GCPerformanceEntry(env,
+                                           static_cast<PerformanceGCKind>(type),
+                                           performance_last_gc_start_mark_,
+                                           PERFORMANCE_NOW()));
 }
 
+
 inline void SetupGarbageCollectionTracking(Environment* env) {
   env->isolate()->AddGCPrologueCallback(MarkGarbageCollectionStart);
   env->isolate()->AddGCEpilogueCallback(MarkGarbageCollectionEnd,
                                         static_cast<void*>(env));
 }
 
+// Gets the name of a function
 inline Local<Value> GetName(Local<Function> fn) {
   Local<Value> val = fn->GetDebugName();
   if (val.IsEmpty() || val->IsUndefined()) {
@@ -238,6 +242,9 @@ inline Local<Value> GetName(Local<Function> fn) {
   return val;
 }
 
+// Executes a wrapped Function and captures timing information, causing a
+// Function PerformanceEntry to be emitted to PerformanceObservers after
+// execution.
 void TimerFunctionCall(const FunctionCallbackInfo<Value>& args) {
   Isolate* isolate = args.GetIsolate();
   HandleScope scope(isolate);
@@ -247,9 +254,8 @@ void TimerFunctionCall(const FunctionCallbackInfo<Value>& args) {
   size_t count = args.Length();
   size_t idx;
   std::vector<Local<Value>> call_args;
-  for (size_t i = 0; i < count; ++i) {
+  for (size_t i = 0; i < count; ++i)
     call_args.push_back(args[i]);
-  }
 
   Utf8Value name(isolate, GetName(fn));
 
@@ -286,15 +292,14 @@ void TimerFunctionCall(const FunctionCallbackInfo<Value>& args) {
   if (!observers[NODE_PERFORMANCE_ENTRY_TYPE_FUNCTION])
     return;
 
-  Local<Function> ctor = env->performance_entry_template();
-  v8::MaybeLocal<Object> instance = ctor->NewInstance(context);
-  Local<Object> obj = instance.ToLocalChecked();
-  for (idx = 0; idx < count; idx++) {
-    obj->Set(context, idx, args[idx]).ToChecked();
-  }
-  new PerformanceEntry(env, obj, *name, "function", start, end);
+  PerformanceEntry entry(env, *name, "function", start, end);
+  Local<Object> obj = entry.ToObject();
+  for (idx = 0; idx < count; idx++)
+    obj->Set(context, idx, args[idx]).FromJust();
+  PerformanceEntry::Notify(env, entry.kind(), obj);
 }
 
+// Wraps a Function in a TimerFunctionCall
 void Timerify(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   Local<Context> context = env->context();
@@ -307,6 +312,7 @@ void Timerify(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(wrap);
 }
 
+
 void Init(Local<Object> target,
           Local<Value> unused,
           Local<Context> context) {
@@ -329,55 +335,10 @@ void Init(Local<Object> target,
   Local<String> performanceEntryString =
       FIXED_ONE_BYTE_STRING(isolate, "PerformanceEntry");
 
-  Local<FunctionTemplate> pe = env->NewFunctionTemplate(PerformanceEntry::New);
-  pe->InstanceTemplate()->SetInternalFieldCount(1);
+  Local<FunctionTemplate> pe = FunctionTemplate::New(isolate);
   pe->SetClassName(performanceEntryString);
-
-  Local<Signature> signature = Signature::New(env->isolate(), pe);
-
-  Local<FunctionTemplate> get_performance_entry_name_templ =
-      FunctionTemplate::New(env->isolate(),
-                            GetPerformanceEntryName,
-                            env->as_external(),
-                            signature);
-
-  Local<FunctionTemplate> get_performance_entry_type_templ =
-      FunctionTemplate::New(env->isolate(),
-                            GetPerformanceEntryType,
-                            env->as_external(),
-                            signature);
-
-  Local<FunctionTemplate> get_performance_entry_start_time_templ =
-      FunctionTemplate::New(env->isolate(),
-                            GetPerformanceEntryStartTime,
-                            env->as_external(),
-                            signature);
-
-  Local<FunctionTemplate> get_performance_entry_duration_templ =
-      FunctionTemplate::New(env->isolate(),
-                            GetPerformanceEntryDuration,
-                            env->as_external(),
-                            signature);
-
-  Local<ObjectTemplate> ot = pe->InstanceTemplate();
-  ot->SetAccessorProperty(env->name_string(),
-                          get_performance_entry_name_templ,
-                          Local<FunctionTemplate>());
-
-  ot->SetAccessorProperty(FIXED_ONE_BYTE_STRING(isolate, "entryType"),
-                          get_performance_entry_type_templ,
-                          Local<FunctionTemplate>());
-
-  ot->SetAccessorProperty(FIXED_ONE_BYTE_STRING(isolate, "startTime"),
-                          get_performance_entry_start_time_templ,
-                          Local<FunctionTemplate>());
-
-  ot->SetAccessorProperty(FIXED_ONE_BYTE_STRING(isolate, "duration"),
-                          get_performance_entry_duration_templ,
-                          Local<FunctionTemplate>());
-
   Local<Function> fn = pe->GetFunction();
-  target->Set(performanceEntryString, fn);
+  target->Set(context, performanceEntryString, fn).FromJust();
   env->set_performance_entry_template(fn);
 
   env->SetMethod(target, "mark", Mark);
diff --git a/src/node_perf.h b/src/node_perf.h
index 690f70830961bb..e5655f54fed07e 100644
--- a/src/node_perf.h
+++ b/src/node_perf.h
@@ -42,120 +42,51 @@ static inline PerformanceEntryType ToPerformanceEntryTypeEnum(
 NODE_EXTERN inline void MarkPerformanceMilestone(
     Environment* env,
     PerformanceMilestone milestone) {
-    env->performance_state()->milestones[milestone] = PERFORMANCE_NOW();
-  }
+  env->performance_state()->milestones[milestone] = PERFORMANCE_NOW();
+}
 
-class PerformanceEntry : public BaseObject {
+class PerformanceEntry {
  public:
-  // Used for temporary storage of performance entry details when the
-  // object cannot be created immediately.
-  class Data {
-   public:
-    Data(
-      Environment* env,
-      const char* name,
-      const char* type,
-      uint64_t startTime,
-      uint64_t endTime,
-      int data = 0) :
-      env_(env),
-      name_(name),
-      type_(type),
-      startTime_(startTime),
-      endTime_(endTime),
-      data_(data) {}
-
-    Environment* env() const {
-      return env_;
-    }
-
-    const std::string& name() const {
-      return name_;
-    }
-
-    const std::string& type() const {
-      return type_;
-    }
-
-    uint64_t startTime() const {
-      return startTime_;
-    }
-
-    uint64_t endTime() const {
-      return endTime_;
-    }
-
-    int data() const {
-      return data_;
-    }
-
-   private:
-    Environment* const env_;
-    const std::string name_;
-    const std::string type_;
-    const uint64_t startTime_;
-    const uint64_t endTime_;
-    const int data_;
-  };
-
-  static void NotifyObservers(Environment* env, PerformanceEntry* entry);
+  static inline void Notify(Environment* env,
+                            PerformanceEntryType type,
+                            Local<Value> object);
 
   static void New(const FunctionCallbackInfo<Value>& args);
 
   PerformanceEntry(Environment* env,
-                   Local<Object> wrap,
                    const char* name,
                    const char* type,
                    uint64_t startTime,
-                   uint64_t endTime) :
-                   BaseObject(env, wrap),
-                   name_(name),
-                   type_(type),
-                   startTime_(startTime),
-                   endTime_(endTime) {
-    MakeWeak<PerformanceEntry>(this);
-    NotifyObservers(env, this);
-  }
+                   uint64_t endTime) : env_(env),
+                                       name_(name),
+                                       type_(type),
+                                       startTime_(startTime),
+                                       endTime_(endTime) { }
 
-  PerformanceEntry(Environment* env,
-                   Local<Object> wrap,
-                   Data* data) :
-                   BaseObject(env, wrap),
-                   name_(data->name()),
-                   type_(data->type()),
-                   startTime_(data->startTime()),
-                   endTime_(data->endTime()) {
-    MakeWeak<PerformanceEntry>(this);
-    NotifyObservers(env, this);
-  }
+  virtual ~PerformanceEntry() { }
 
-  ~PerformanceEntry() {}
+  virtual const Local<Object> ToObject() const;
 
-  const std::string& name() const {
-    return name_;
-  }
+  Environment* env() const { return env_; }
 
-  const std::string& type() const {
-    return type_;
-  }
+  const std::string& name() const { return name_; }
 
-  double startTime() const {
-    return startTime_ / 1e6;
-  }
+  const std::string& type() const { return type_; }
 
-  double duration() const {
-    return durationNano() / 1e6;
+  PerformanceEntryType kind() {
+    return ToPerformanceEntryTypeEnum(type().c_str());
   }
 
-  uint64_t startTimeNano() const {
-    return startTime_;
-  }
+  double startTime() const { return startTime_ / 1e6; }
 
-  uint64_t durationNano() const {
-    return endTime_ - startTime_;
-  }
+  double duration() const { return durationNano() / 1e6; }
+
+  uint64_t startTimeNano() const { return startTime_; }
+
+  uint64_t durationNano() const { return endTime_ - startTime_; }
 
  private:
+  Environment* env_;
   const std::string name_;
   const std::string type_;
   const uint64_t startTime_;
@@ -169,6 +100,21 @@ enum PerformanceGCKind {
   NODE_PERFORMANCE_GC_WEAKCB = GCType::kGCTypeProcessWeakCallbacks
 };
 
+class GCPerformanceEntry : public PerformanceEntry {
+ public:
+  GCPerformanceEntry(Environment* env,
+                     PerformanceGCKind gckind,
+                     uint64_t startTime,
+                     uint64_t endTime) :
+                         PerformanceEntry(env, "gc", "gc", startTime, endTime),
+                         gckind_(gckind) { }
+
+  PerformanceGCKind gckind() const { return gckind_; }
+
+ private:
+  PerformanceGCKind gckind_;
+};
+
 }  // namespace performance
 }  // namespace node
 

From 46510f54bee7cecb565424aeee8beb19b0162079 Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Sat, 23 Dec 2017 09:01:58 +0100
Subject: [PATCH 11/23] tls: fix SNICallback without .server option

`options.server` only needs to be set when its
contents are actually being inspected.

PR-URL: https://github.com/nodejs/node/pull/17835
Reviewed-By: Timothy Gu <timothygu99@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 lib/_tls_wrap.js                              |  3 +--
 ...t-tls-socket-snicallback-without-server.js | 26 +++++++++++++++++++
 2 files changed, 27 insertions(+), 2 deletions(-)
 create mode 100644 test/parallel/test-tls-socket-snicallback-without-server.js

diff --git a/lib/_tls_wrap.js b/lib/_tls_wrap.js
index 07d7cb72987b2a..32fd1f322e0a96 100644
--- a/lib/_tls_wrap.js
+++ b/lib/_tls_wrap.js
@@ -505,9 +505,8 @@ TLSSocket.prototype._init = function(socket, wrap) {
   if (process.features.tls_sni &&
       options.isServer &&
       options.SNICallback &&
-      options.server &&
       (options.SNICallback !== SNICallback ||
-       options.server._contexts.length)) {
+       (options.server && options.server._contexts.length))) {
     assert(typeof options.SNICallback === 'function');
     this._SNICallback = options.SNICallback;
     ssl.enableCertCb();
diff --git a/test/parallel/test-tls-socket-snicallback-without-server.js b/test/parallel/test-tls-socket-snicallback-without-server.js
new file mode 100644
index 00000000000000..9d30bc17b96b65
--- /dev/null
+++ b/test/parallel/test-tls-socket-snicallback-without-server.js
@@ -0,0 +1,26 @@
+'use strict';
+
+// This is based on test-tls-securepair-fiftharg.js
+// for the deprecated `tls.createSecurePair()` variant.
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const tls = require('tls');
+const fixtures = require('../common/fixtures');
+const makeDuplexPair = require('../common/duplexpair');
+
+const { clientSide, serverSide } = makeDuplexPair();
+new tls.TLSSocket(serverSide, {
+  isServer: true,
+  SNICallback: common.mustCall((servername, cb) => {
+    assert.strictEqual(servername, 'www.google.com');
+  })
+});
+
+// captured traffic from browser's request to https://www.google.com
+const sslHello = fixtures.readSync('google_ssl_hello.bin');
+
+clientSide.write(sslHello);

From b34367150ef4c92d05f0a6e5a8986f73ca90fd8b Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Sat, 23 Dec 2017 09:00:43 +0100
Subject: [PATCH 12/23] test: refactor test-tls-securepair-fiftharg

Assert the server name directly in the `SNICallback`,
since `common.mustCall()` already guarantees that the callback
is called exactly once, making `process.on('exit')` unnecessary.

PR-URL: https://github.com/nodejs/node/pull/17836
Reviewed-By: Timothy Gu <timothygu99@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Jon Moss <me@jonathanmoss.me>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 test/parallel/test-tls-securepair-fiftharg.js | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/test/parallel/test-tls-securepair-fiftharg.js b/test/parallel/test-tls-securepair-fiftharg.js
index 364b70aa76b0ca..185dc43d941ca6 100644
--- a/test/parallel/test-tls-securepair-fiftharg.js
+++ b/test/parallel/test-tls-securepair-fiftharg.js
@@ -13,10 +13,9 @@ const sslcontext = tls.createSecureContext({
   key: fixtures.readSync('test_key.pem')
 });
 
-let catchedServername;
 const pair = tls.createSecurePair(sslcontext, true, false, false, {
-  SNICallback: common.mustCall(function(servername, cb) {
-    catchedServername = servername;
+  SNICallback: common.mustCall((servername, cb) => {
+    assert.strictEqual(servername, 'www.google.com');
   })
 });
 
@@ -24,7 +23,3 @@ const pair = tls.createSecurePair(sslcontext, true, false, false, {
 const sslHello = fixtures.readSync('google_ssl_hello.bin');
 
 pair.encrypted.write(sslHello);
-
-process.on('exit', function() {
-  assert.strictEqual('www.google.com', catchedServername);
-});

From cb3de880beff3cbe5958ce07939d41884f743b17 Mon Sep 17 00:00:00 2001
From: Daniel Bevenius <daniel.bevenius@gmail.com>
Date: Mon, 11 Dec 2017 13:29:58 +0100
Subject: [PATCH 13/23] crypto: add ocsp_request ClientHelloParser::Reset

I noticed that ocsp_request is not being reset in
ClientHelloParser::Reset. I've not been able to figure out the
the reason for this and wanted to bring this up just in case this
was overlooked and should be reset.

PR-URL: https://github.com/nodejs/node/pull/17753
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 src/node_crypto_clienthello-inl.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/node_crypto_clienthello-inl.h b/src/node_crypto_clienthello-inl.h
index 5aff1816b2f73e..da906cbb30522d 100644
--- a/src/node_crypto_clienthello-inl.h
+++ b/src/node_crypto_clienthello-inl.h
@@ -55,6 +55,7 @@ inline void ClientHelloParser::Reset() {
   tls_ticket_ = nullptr;
   servername_size_ = 0;
   servername_ = nullptr;
+  ocsp_request_ = 0;
 }
 
 inline void ClientHelloParser::Start(ClientHelloParser::OnHelloCb onhello_cb,

From df30fd586d123fc189887fc0f9c7f27808374c2e Mon Sep 17 00:00:00 2001
From: Ben Noordhuis <info@bnoordhuis.nl>
Date: Wed, 20 Dec 2017 01:15:22 +0100
Subject: [PATCH 14/23] buffer: optimize readDouble and readFloat methods

Compute the floating point number in JavaScript to avoid having to call
out to the C++ runtime.  The improvements are not insubstantial:

                                                             improvement confidence      p.value
    value="big" endian="BE" type="Double" noAssert="false"      292.86 %        *** 1.688367e-08
    value="big" endian="BE" type="Double" noAssert="true"       353.19 %        *** 6.079414e-10
    value="big" endian="BE" type="Float" noAssert="false"       406.21 %        *** 1.730122e-07
    value="big" endian="BE" type="Float" noAssert="true"        450.81 %        *** 6.909242e-07
    value="big" endian="LE" type="Double" noAssert="false"      268.39 %        *** 8.625486e-09
    value="big" endian="LE" type="Double" noAssert="true"       310.66 %        *** 2.798332e-15
    value="big" endian="LE" type="Float" noAssert="false"       382.99 %        *** 3.412057e-07
    value="big" endian="LE" type="Float" noAssert="true"        394.60 %        *** 1.406742e-07
    value="inf" endian="BE" type="Double" noAssert="false"      312.91 %        *** 7.407943e-12
    value="inf" endian="BE" type="Double" noAssert="true"       392.47 %        *** 3.821179e-08
    value="inf" endian="BE" type="Float" noAssert="false"       466.01 %        *** 8.953363e-08
    value="inf" endian="BE" type="Float" noAssert="true"        460.76 %        *** 5.381256e-09
    value="inf" endian="LE" type="Double" noAssert="false"      279.50 %        *** 2.390682e-09
    value="inf" endian="LE" type="Double" noAssert="true"       335.30 %        *** 3.587173e-09
    value="inf" endian="LE" type="Float" noAssert="false"       439.77 %        *** 1.057133e-07
    value="inf" endian="LE" type="Float" noAssert="true"        426.72 %        *** 4.353408e-09
    value="nan" endian="BE" type="Double" noAssert="false"      271.18 %        *** 2.281526e-05
    value="nan" endian="BE" type="Double" noAssert="true"       312.63 %        *** 1.974975e-07
    value="nan" endian="BE" type="Float" noAssert="false"       429.17 %        *** 2.416228e-07
    value="nan" endian="BE" type="Float" noAssert="true"        461.39 %        *** 1.956714e-08
    value="nan" endian="LE" type="Double" noAssert="false"      267.03 %        *** 9.938479e-12
    value="nan" endian="LE" type="Double" noAssert="true"       276.93 %        *** 7.842481e-08
    value="nan" endian="LE" type="Float" noAssert="false"       415.97 %        *** 8.082710e-07
    value="nan" endian="LE" type="Float" noAssert="true"        433.68 %        *** 1.030200e-07
    value="small" endian="BE" type="Double" noAssert="false"    273.20 %        *** 9.071652e-11
    value="small" endian="BE" type="Double" noAssert="true"     326.25 %        *** 3.120167e-08
    value="small" endian="BE" type="Float" noAssert="false"     845.61 %        *** 8.044170e-08
    value="small" endian="BE" type="Float" noAssert="true"      868.61 %        *** 2.944539e-08
    value="small" endian="LE" type="Double" noAssert="false"    251.29 %        *** 5.613930e-09
    value="small" endian="LE" type="Double" noAssert="true"     286.82 %        *** 8.149603e-10
    value="small" endian="LE" type="Float" noAssert="false"     824.87 %        *** 1.199729e-08
    value="small" endian="LE" type="Float" noAssert="true"      834.35 %        *** 4.799620e-08
    value="zero" endian="BE" type="Double" noAssert="false"     216.70 %        *** 3.872293e-12
    value="zero" endian="BE" type="Double" noAssert="true"      239.31 %        *** 6.439601e-09
    value="zero" endian="BE" type="Float" noAssert="false"      353.75 %        *** 3.639974e-07
    value="zero" endian="BE" type="Float" noAssert="true"       388.86 %        *** 7.074318e-10
    value="zero" endian="LE" type="Double" noAssert="false"     179.34 %        *** 5.230763e-06
    value="zero" endian="LE" type="Double" noAssert="true"      199.66 %        *** 2.177589e-11
    value="zero" endian="LE" type="Float" noAssert="false"      299.55 %        *** 9.961978e-08
    value="zero" endian="LE" type="Float" noAssert="true"       333.30 %        *** 2.470764e-08

PR-URL: https://github.com/nodejs/node/pull/17775
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
---
 benchmark/buffers/buffer-read-float.js | 46 +++++++++++++
 lib/buffer.js                          | 89 +++++++++++++++++++-------
 src/node_buffer.cc                     | 48 --------------
 3 files changed, 111 insertions(+), 72 deletions(-)
 create mode 100644 benchmark/buffers/buffer-read-float.js

diff --git a/benchmark/buffers/buffer-read-float.js b/benchmark/buffers/buffer-read-float.js
new file mode 100644
index 00000000000000..5dda2486c6711a
--- /dev/null
+++ b/benchmark/buffers/buffer-read-float.js
@@ -0,0 +1,46 @@
+'use strict';
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  noAssert: ['false', 'true'],
+  type: ['Double', 'Float'],
+  endian: ['BE', 'LE'],
+  value: ['zero', 'big', 'small', 'inf', 'nan'],
+  millions: [1]
+});
+
+function main(conf) {
+  const noAssert = conf.noAssert === 'true';
+  const len = +conf.millions * 1e6;
+  const buff = Buffer.alloc(8);
+  const type = conf.type || 'Double';
+  const endian = conf.endian;
+  const fn = `read${type}${endian}`;
+  const values = {
+    Double: {
+      zero: 0,
+      big: 2 ** 1023,
+      small: 2 ** -1074,
+      inf: Infinity,
+      nan: NaN,
+    },
+    Float: {
+      zero: 0,
+      big: 2 ** 127,
+      small: 2 ** -149,
+      inf: Infinity,
+      nan: NaN,
+    },
+  };
+  const value = values[type][conf.value];
+
+  buff[`write${type}${endian}`](value, 0, noAssert);
+  const testFunction = new Function('buff', `
+    for (var i = 0; i !== ${len}; i++) {
+      buff.${fn}(0, ${JSON.stringify(noAssert)});
+    }
+  `);
+  bench.start();
+  testFunction(buff);
+  bench.end(len / 1e6);
+}
diff --git a/lib/buffer.js b/lib/buffer.js
index 40aaf37e09d600..180bfe6badaf97 100644
--- a/lib/buffer.js
+++ b/lib/buffer.js
@@ -31,10 +31,6 @@ const {
   indexOfBuffer,
   indexOfNumber,
   indexOfString,
-  readDoubleBE: _readDoubleBE,
-  readDoubleLE: _readDoubleLE,
-  readFloatBE: _readFloatBE,
-  readFloatLE: _readFloatLE,
   swap16: _swap16,
   swap32: _swap32,
   swap64: _swap64,
@@ -1201,35 +1197,80 @@ Buffer.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
 };
 
 
-Buffer.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
-  offset = offset >>> 0;
-  if (!noAssert)
-    checkOffset(offset, 4, this.length);
-  return _readFloatLE(this, offset);
+// For the casual reader who has not at the current time memorized the
+// IEEE-754 standard in full detail: floating point numbers consist of
+// a fraction, an exponent and a sign bit: 23+8+1 bits for single precision
+// numbers and 52+11+1 bits for double precision numbers.
+//
+// A zero exponent is either a positive or negative zero, if the fraction
+// is zero, or a denormalized number when it is non-zero.  Multiplying the
+// fraction by the smallest possible denormal yields the denormalized number.
+//
+// An all-bits-one exponent is either a positive or negative infinity, if
+// the fraction is zero, or NaN when it is non-zero.  The standard allows
+// both quiet and signalling NaNs but since NaN is a canonical value in
+// JavaScript, we cannot (and do not) distinguish between the two.
+//
+// Other exponents are regular numbers and are computed by subtracting the bias
+// from the exponent (127 for single precision, 1023 for double precision),
+// yielding an exponent in the ranges -126-127 and -1022-1024 respectively.
+//
+// Of interest is that the fraction of a normal number has an extra bit of
+// precision that is not stored but is reconstructed by adding one after
+// multiplying the fraction with the result of 2**-bits_in_fraction.
+
+
+function toDouble(x0, x1) {
+  const frac = x0 + 0x100000000 * (x1 & 0xFFFFF);
+  const expt = (x1 >>> 20) & 2047;
+  const sign = (x1 >>> 31) ? -1 : 1;
+  if (expt === 0) {
+    if (frac === 0) return sign * 0;
+    return sign * frac * 2 ** -1074;
+  } else if (expt === 2047) {
+    if (frac === 0) return sign * Infinity;
+    return NaN;
+  }
+  return sign * 2 ** (expt - 1023) * (1 + frac * 2 ** -52);
+}
+
+
+function toFloat(x) {
+  const frac = x & 0x7FFFFF;
+  const expt = (x >>> 23) & 255;
+  const sign = (x >>> 31) ? -1 : 1;
+  if (expt === 0) {
+    if (frac === 0) return sign * 0;
+    return sign * frac * 2 ** -149;
+  } else if (expt === 255) {
+    if (frac === 0) return sign * Infinity;
+    return NaN;
+  }
+  return sign * 2 ** (expt - 127) * (1 + frac * 2 ** -23);
+}
+
+
+Buffer.prototype.readDoubleBE = function(offset, noAssert) {
+  const x1 = this.readUInt32BE(offset + 0, noAssert);
+  const x0 = this.readUInt32BE(offset + 4, noAssert);
+  return toDouble(x0, x1);
 };
 
 
-Buffer.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
-  offset = offset >>> 0;
-  if (!noAssert)
-    checkOffset(offset, 4, this.length);
-  return _readFloatBE(this, offset);
+Buffer.prototype.readDoubleLE = function(offset, noAssert) {
+  const x0 = this.readUInt32LE(offset + 0, noAssert);
+  const x1 = this.readUInt32LE(offset + 4, noAssert);
+  return toDouble(x0, x1);
 };
 
 
-Buffer.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
-  offset = offset >>> 0;
-  if (!noAssert)
-    checkOffset(offset, 8, this.length);
-  return _readDoubleLE(this, offset);
+Buffer.prototype.readFloatBE = function(offset, noAssert) {
+  return toFloat(this.readUInt32BE(offset, noAssert));
 };
 
 
-Buffer.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
-  offset = offset >>> 0;
-  if (!noAssert)
-    checkOffset(offset, 8, this.length);
-  return _readDoubleBE(this, offset);
+Buffer.prototype.readFloatLE = function(offset, noAssert) {
+  return toFloat(this.readUInt32LE(offset, noAssert));
 };
 
 
diff --git a/src/node_buffer.cc b/src/node_buffer.cc
index 49991003c3f5a0..f0be320d61f9b2 100644
--- a/src/node_buffer.cc
+++ b/src/node_buffer.cc
@@ -719,49 +719,6 @@ static inline void Swizzle(char* start, unsigned int len) {
 }
 
 
-template <typename T, enum Endianness endianness>
-void ReadFloatGeneric(const FunctionCallbackInfo<Value>& args) {
-  THROW_AND_RETURN_UNLESS_BUFFER(Environment::GetCurrent(args), args[0]);
-  SPREAD_BUFFER_ARG(args[0], ts_obj);
-
-  uint32_t offset = args[1]->Uint32Value();
-  CHECK_LE(offset + sizeof(T), ts_obj_length);
-
-  union NoAlias {
-    T val;
-    char bytes[sizeof(T)];
-  };
-
-  union NoAlias na;
-  const char* ptr = static_cast<const char*>(ts_obj_data) + offset;
-  memcpy(na.bytes, ptr, sizeof(na.bytes));
-  if (endianness != GetEndianness())
-    Swizzle(na.bytes, sizeof(na.bytes));
-
-  args.GetReturnValue().Set(na.val);
-}
-
-
-void ReadFloatLE(const FunctionCallbackInfo<Value>& args) {
-  ReadFloatGeneric<float, kLittleEndian>(args);
-}
-
-
-void ReadFloatBE(const FunctionCallbackInfo<Value>& args) {
-  ReadFloatGeneric<float, kBigEndian>(args);
-}
-
-
-void ReadDoubleLE(const FunctionCallbackInfo<Value>& args) {
-  ReadFloatGeneric<double, kLittleEndian>(args);
-}
-
-
-void ReadDoubleBE(const FunctionCallbackInfo<Value>& args) {
-  ReadFloatGeneric<double, kBigEndian>(args);
-}
-
-
 template <typename T, enum Endianness endianness>
 void WriteFloatGeneric(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
@@ -1276,11 +1233,6 @@ void Initialize(Local<Object> target,
   env->SetMethod(target, "indexOfNumber", IndexOfNumber);
   env->SetMethod(target, "indexOfString", IndexOfString);
 
-  env->SetMethod(target, "readDoubleBE", ReadDoubleBE);
-  env->SetMethod(target, "readDoubleLE", ReadDoubleLE);
-  env->SetMethod(target, "readFloatBE", ReadFloatBE);
-  env->SetMethod(target, "readFloatLE", ReadFloatLE);
-
   env->SetMethod(target, "writeDoubleBE", WriteDoubleBE);
   env->SetMethod(target, "writeDoubleLE", WriteDoubleLE);
   env->SetMethod(target, "writeFloatBE", WriteFloatBE);

From 83e5215a4e8438a43b9f0002b7a43e2fd2dd37a4 Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Tue, 19 Dec 2017 15:08:18 +0100
Subject: [PATCH 15/23] async_hooks: use typed array stack as fast path

- Communicate the current async stack length through a
  typed array field rather than a native binding method
- Add a new fixed-size `async_ids_fast_stack` typed array
  that contains the async ID stack up to a fixed limit.
  This increases performance noticeably, since most of the time
  the async ID stack will not be more than a handful of
  levels deep.
- Make the JS `pushAsyncIds()` and `popAsyncIds()` functions
  do the same thing as the native ones if the fast path
  is applicable.

Benchmarks:

    $ ./node benchmark/compare.js --new ./node --old ./node-master --runs 10 --filter next-tick process | Rscript benchmark/compare.R
    [00:03:25|% 100| 6/6 files | 20/20 runs | 1/1 configs]: Done
                                                   improvement confidence      p.value
     process/next-tick-breadth-args.js millions=4     19.72 %        *** 3.013913e-06
     process/next-tick-breadth.js millions=4          27.33 %        *** 5.847983e-11
     process/next-tick-depth-args.js millions=12      40.08 %        *** 1.237127e-13
     process/next-tick-depth.js millions=12           77.27 %        *** 1.413290e-11
     process/next-tick-exec-args.js millions=5        13.58 %        *** 1.245180e-07
     process/next-tick-exec.js millions=5             16.80 %        *** 2.961386e-07

PR-URL: https://github.com/nodejs/node/pull/17780
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 lib/internal/async_hooks.js                   | 44 ++++++++++++-
 lib/internal/bootstrap_node.js                |  6 +-
 src/aliased_buffer.h                          | 29 ++++++++-
 src/async_wrap.cc                             | 14 ++---
 src/async_wrap.h                              |  1 -
 src/env-inl.h                                 | 62 ++++++++++++-------
 src/env.cc                                    | 17 +++++
 src/env.h                                     | 26 ++++----
 .../test-async-hooks-recursive-stack.js       | 20 ++++++
 9 files changed, 165 insertions(+), 54 deletions(-)
 create mode 100644 test/parallel/test-async-hooks-recursive-stack.js

diff --git a/lib/internal/async_hooks.js b/lib/internal/async_hooks.js
index 035dd0634daf6a..7d99985dd118bb 100644
--- a/lib/internal/async_hooks.js
+++ b/lib/internal/async_hooks.js
@@ -19,6 +19,12 @@ const async_wrap = process.binding('async_wrap');
  *    retrieving the triggerAsyncId value is passing directly to the
  *    constructor -> value set in kDefaultTriggerAsyncId -> executionAsyncId of
  *    the current resource.
+ *
+ * async_ids_fast_stack is a Float64Array that contains part of the async ID
+ * stack. Each pushAsyncIds() call adds two doubles to it, and each
+ * popAsyncIds() call removes two doubles from it.
+ * It has a fixed size, so if that is exceeded, calls to the native
+ * side are used instead in pushAsyncIds() and popAsyncIds().
  */
 const { async_hook_fields, async_id_fields } = async_wrap;
 // Store the pair executionAsyncId and triggerAsyncId in a std::stack on
@@ -26,7 +32,7 @@ const { async_hook_fields, async_id_fields } = async_wrap;
 // current execution stack. This is unwound as each resource exits. In the case
 // of a fatal exception this stack is emptied after calling each hook's after()
 // callback.
-const { pushAsyncIds, popAsyncIds } = async_wrap;
+const { pushAsyncIds: pushAsyncIds_, popAsyncIds: popAsyncIds_ } = async_wrap;
 // For performance reasons, only track Proimses when a hook is enabled.
 const { enablePromiseHook, disablePromiseHook } = async_wrap;
 // Properties in active_hooks are used to keep track of the set of hooks being
@@ -60,8 +66,8 @@ const active_hooks = {
 // async execution. These are tracked so if the user didn't include callbacks
 // for a given step, that step can bail out early.
 const { kInit, kBefore, kAfter, kDestroy, kPromiseResolve,
-        kCheck, kExecutionAsyncId, kAsyncIdCounter,
-        kDefaultTriggerAsyncId } = async_wrap.constants;
+        kCheck, kExecutionAsyncId, kAsyncIdCounter, kTriggerAsyncId,
+        kDefaultTriggerAsyncId, kStackLength } = async_wrap.constants;
 
 // Used in AsyncHook and AsyncResource.
 const init_symbol = Symbol('init');
@@ -329,6 +335,38 @@ function emitDestroyScript(asyncId) {
 }
 
 
+// This is the equivalent of the native push_async_ids() call.
+function pushAsyncIds(asyncId, triggerAsyncId) {
+  const offset = async_hook_fields[kStackLength];
+  if (offset * 2 >= async_wrap.async_ids_stack.length)
+    return pushAsyncIds_(asyncId, triggerAsyncId);
+  async_wrap.async_ids_stack[offset * 2] = async_id_fields[kExecutionAsyncId];
+  async_wrap.async_ids_stack[offset * 2 + 1] = async_id_fields[kTriggerAsyncId];
+  async_hook_fields[kStackLength]++;
+  async_id_fields[kExecutionAsyncId] = asyncId;
+  async_id_fields[kTriggerAsyncId] = triggerAsyncId;
+}
+
+
+// This is the equivalent of the native pop_async_ids() call.
+function popAsyncIds(asyncId) {
+  if (async_hook_fields[kStackLength] === 0) return false;
+  const stackLength = async_hook_fields[kStackLength];
+
+  if (async_hook_fields[kCheck] > 0 &&
+      async_id_fields[kExecutionAsyncId] !== asyncId) {
+    // Do the same thing as the native code (i.e. crash hard).
+    return popAsyncIds_(asyncId);
+  }
+
+  const offset = stackLength - 1;
+  async_id_fields[kExecutionAsyncId] = async_wrap.async_ids_stack[2 * offset];
+  async_id_fields[kTriggerAsyncId] = async_wrap.async_ids_stack[2 * offset + 1];
+  async_hook_fields[kStackLength] = offset;
+  return offset > 0;
+}
+
+
 module.exports = {
   // Private API
   getHookArrays,
diff --git a/lib/internal/bootstrap_node.js b/lib/internal/bootstrap_node.js
index f8a1fa39618610..298fc9df3084ba 100644
--- a/lib/internal/bootstrap_node.js
+++ b/lib/internal/bootstrap_node.js
@@ -367,9 +367,9 @@
     // Arrays containing hook flags and ids for async_hook calls.
     const { async_hook_fields, async_id_fields } = async_wrap;
     // Internal functions needed to manipulate the stack.
-    const { clearAsyncIdStack, asyncIdStackSize } = async_wrap;
+    const { clearAsyncIdStack } = async_wrap;
     const { kAfter, kExecutionAsyncId,
-            kDefaultTriggerAsyncId } = async_wrap.constants;
+            kDefaultTriggerAsyncId, kStackLength } = async_wrap.constants;
 
     process._fatalException = function(er) {
       var caught;
@@ -407,7 +407,7 @@
           do {
             NativeModule.require('internal/async_hooks').emitAfter(
               async_id_fields[kExecutionAsyncId]);
-          } while (asyncIdStackSize() > 0);
+          } while (async_hook_fields[kStackLength] > 0);
         // Or completely empty the id stack.
         } else {
           clearAsyncIdStack();
diff --git a/src/aliased_buffer.h b/src/aliased_buffer.h
index 21aaeb61141c59..b99b01f5d94ca2 100644
--- a/src/aliased_buffer.h
+++ b/src/aliased_buffer.h
@@ -95,6 +95,21 @@ class AliasedBuffer {
     js_array_.Reset();
   }
 
+  AliasedBuffer& operator=(AliasedBuffer&& that) {
+    this->~AliasedBuffer();
+    isolate_ = that.isolate_;
+    count_ = that.count_;
+    byte_offset_ = that.byte_offset_;
+    buffer_ = that.buffer_;
+    free_buffer_ = that.free_buffer_;
+
+    js_array_.Reset(isolate_, that.js_array_.Get(isolate_));
+
+    that.buffer_ = nullptr;
+    that.js_array_.Reset();
+    return *this;
+  }
+
   /**
    * Helper class that is returned from operator[] to support assignment into
    * a specified location.
@@ -111,11 +126,17 @@ class AliasedBuffer {
           index_(that.index_) {
     }
 
-    inline Reference& operator=(const NativeT &val) {
+    template <typename T>
+    inline Reference& operator=(const T& val) {
       aliased_buffer_->SetValue(index_, val);
       return *this;
     }
 
+    // This is not caught by the template operator= above.
+    inline Reference& operator=(const Reference& val) {
+      return *this = static_cast<NativeT>(val);
+    }
+
     operator NativeT() const {
       return aliased_buffer_->GetValue(index_);
     }
@@ -186,8 +207,12 @@ class AliasedBuffer {
     return GetValue(index);
   }
 
+  size_t Length() const {
+    return count_;
+  }
+
  private:
-  v8::Isolate* const isolate_;
+  v8::Isolate* isolate_;
   size_t count_;
   size_t byte_offset_;
   NativeT* buffer_;
diff --git a/src/async_wrap.cc b/src/async_wrap.cc
index e87ebec3d366c7..6276dac6ffab52 100644
--- a/src/async_wrap.cc
+++ b/src/async_wrap.cc
@@ -467,13 +467,6 @@ void AsyncWrap::PopAsyncIds(const FunctionCallbackInfo<Value>& args) {
 }
 
 
-void AsyncWrap::AsyncIdStackSize(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
-  args.GetReturnValue().Set(
-      static_cast<double>(env->async_hooks()->stack_size()));
-}
-
-
 void AsyncWrap::ClearAsyncIdStack(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   env->async_hooks()->clear_async_id_stack();
@@ -512,7 +505,6 @@ void AsyncWrap::Initialize(Local<Object> target,
   env->SetMethod(target, "setupHooks", SetupHooks);
   env->SetMethod(target, "pushAsyncIds", PushAsyncIds);
   env->SetMethod(target, "popAsyncIds", PopAsyncIds);
-  env->SetMethod(target, "asyncIdStackSize", AsyncIdStackSize);
   env->SetMethod(target, "clearAsyncIdStack", ClearAsyncIdStack);
   env->SetMethod(target, "queueDestroyAsyncId", QueueDestroyAsyncId);
   env->SetMethod(target, "enablePromiseHook", EnablePromiseHook);
@@ -550,6 +542,10 @@ void AsyncWrap::Initialize(Local<Object> target,
                          "async_id_fields",
                          env->async_hooks()->async_id_fields().GetJSArray());
 
+  target->Set(context,
+              env->async_ids_stack_string(),
+              env->async_hooks()->async_ids_stack().GetJSArray()).FromJust();
+
   Local<Object> constants = Object::New(isolate);
 #define SET_HOOKS_CONSTANT(name)                                              \
   FORCE_SET_TARGET_FIELD(                                                     \
@@ -566,6 +562,7 @@ void AsyncWrap::Initialize(Local<Object> target,
   SET_HOOKS_CONSTANT(kTriggerAsyncId);
   SET_HOOKS_CONSTANT(kAsyncIdCounter);
   SET_HOOKS_CONSTANT(kDefaultTriggerAsyncId);
+  SET_HOOKS_CONSTANT(kStackLength);
 #undef SET_HOOKS_CONSTANT
   FORCE_SET_TARGET_FIELD(target, "constants", constants);
 
@@ -595,6 +592,7 @@ void AsyncWrap::Initialize(Local<Object> target,
   env->set_async_hooks_after_function(Local<Function>());
   env->set_async_hooks_destroy_function(Local<Function>());
   env->set_async_hooks_promise_resolve_function(Local<Function>());
+  env->set_async_hooks_binding(target);
 }
 
 
diff --git a/src/async_wrap.h b/src/async_wrap.h
index c5dd4506886984..9b5632598bcc0b 100644
--- a/src/async_wrap.h
+++ b/src/async_wrap.h
@@ -123,7 +123,6 @@ class AsyncWrap : public BaseObject {
   static void GetAsyncId(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void PushAsyncIds(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void PopAsyncIds(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void AsyncIdStackSize(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void ClearAsyncIdStack(
     const v8::FunctionCallbackInfo<v8::Value>& args);
   static void AsyncReset(const v8::FunctionCallbackInfo<v8::Value>& args);
diff --git a/src/env-inl.h b/src/env-inl.h
index 9af7c1215afdc2..07fc359758f31c 100644
--- a/src/env-inl.h
+++ b/src/env-inl.h
@@ -53,11 +53,11 @@ inline MultiIsolatePlatform* IsolateData::platform() const {
   return platform_;
 }
 
-inline Environment::AsyncHooks::AsyncHooks(v8::Isolate* isolate)
-    : isolate_(isolate),
-      fields_(isolate, kFieldsCount),
-      async_id_fields_(isolate, kUidFieldsCount) {
-  v8::HandleScope handle_scope(isolate_);
+inline Environment::AsyncHooks::AsyncHooks()
+    : async_ids_stack_(env()->isolate(), 16 * 2),
+      fields_(env()->isolate(), kFieldsCount),
+      async_id_fields_(env()->isolate(), kUidFieldsCount) {
+  v8::HandleScope handle_scope(env()->isolate());
 
   // Always perform async_hooks checks, not just when async_hooks is enabled.
   // TODO(AndreasMadsen): Consider removing this for LTS releases.
@@ -81,9 +81,9 @@ inline Environment::AsyncHooks::AsyncHooks(v8::Isolate* isolate)
   // strings can be retrieved quickly.
 #define V(Provider)                                                           \
   providers_[AsyncWrap::PROVIDER_ ## Provider].Set(                           \
-      isolate_,                                                               \
+      env()->isolate(),                                                       \
       v8::String::NewFromOneByte(                                             \
-        isolate_,                                                             \
+        env()->isolate(),                                                     \
         reinterpret_cast<const uint8_t*>(#Provider),                          \
         v8::NewStringType::kInternalized,                                     \
         sizeof(#Provider) - 1).ToLocalChecked());
@@ -101,8 +101,13 @@ Environment::AsyncHooks::async_id_fields() {
   return async_id_fields_;
 }
 
+inline AliasedBuffer<double, v8::Float64Array>&
+Environment::AsyncHooks::async_ids_stack() {
+  return async_ids_stack_;
+}
+
 inline v8::Local<v8::String> Environment::AsyncHooks::provider_string(int idx) {
-  return providers_[idx].Get(isolate_);
+  return providers_[idx].Get(env()->isolate());
 }
 
 inline void Environment::AsyncHooks::no_force_checks() {
@@ -110,6 +115,11 @@ inline void Environment::AsyncHooks::no_force_checks() {
   fields_[kCheck] = fields_[kCheck] - 1;
 }
 
+inline Environment* Environment::AsyncHooks::env() {
+  return Environment::ForAsyncHooks(this);
+}
+
+// Remember to keep this code aligned with pushAsyncIds() in JS.
 inline void Environment::AsyncHooks::push_async_ids(double async_id,
                                               double trigger_async_id) {
   // Since async_hooks is experimental, do only perform the check
@@ -119,16 +129,21 @@ inline void Environment::AsyncHooks::push_async_ids(double async_id,
     CHECK_GE(trigger_async_id, -1);
   }
 
-  async_ids_stack_.push({ async_id_fields_[kExecutionAsyncId],
-                    async_id_fields_[kTriggerAsyncId] });
+  uint32_t offset = fields_[kStackLength];
+  if (offset * 2 >= async_ids_stack_.Length())
+    grow_async_ids_stack();
+  async_ids_stack_[2 * offset] = async_id_fields_[kExecutionAsyncId];
+  async_ids_stack_[2 * offset + 1] = async_id_fields_[kTriggerAsyncId];
+  fields_[kStackLength] = fields_[kStackLength] + 1;
   async_id_fields_[kExecutionAsyncId] = async_id;
   async_id_fields_[kTriggerAsyncId] = trigger_async_id;
 }
 
+// Remember to keep this code aligned with popAsyncIds() in JS.
 inline bool Environment::AsyncHooks::pop_async_id(double async_id) {
   // In case of an exception then this may have already been reset, if the
   // stack was multiple MakeCallback()'s deep.
-  if (async_ids_stack_.empty()) return false;
+  if (fields_[kStackLength] == 0) return false;
 
   // Ask for the async_id to be restored as a check that the stack
   // hasn't been corrupted.
@@ -140,32 +155,27 @@ inline bool Environment::AsyncHooks::pop_async_id(double async_id) {
             "actual: %.f, expected: %.f)\n",
             async_id_fields_.GetValue(kExecutionAsyncId),
             async_id);
-    Environment* env = Environment::GetCurrent(isolate_);
     DumpBacktrace(stderr);
     fflush(stderr);
-    if (!env->abort_on_uncaught_exception())
+    if (!env()->abort_on_uncaught_exception())
       exit(1);
     fprintf(stderr, "\n");
     fflush(stderr);
     ABORT_NO_BACKTRACE();
   }
 
-  auto async_ids = async_ids_stack_.top();
-  async_ids_stack_.pop();
-  async_id_fields_[kExecutionAsyncId] = async_ids.async_id;
-  async_id_fields_[kTriggerAsyncId] = async_ids.trigger_async_id;
-  return !async_ids_stack_.empty();
-}
+  uint32_t offset = fields_[kStackLength] - 1;
+  async_id_fields_[kExecutionAsyncId] = async_ids_stack_[2 * offset];
+  async_id_fields_[kTriggerAsyncId] = async_ids_stack_[2 * offset + 1];
+  fields_[kStackLength] = offset;
 
-inline size_t Environment::AsyncHooks::stack_size() {
-  return async_ids_stack_.size();
+  return fields_[kStackLength] > 0;
 }
 
 inline void Environment::AsyncHooks::clear_async_id_stack() {
-  while (!async_ids_stack_.empty())
-    async_ids_stack_.pop();
   async_id_fields_[kExecutionAsyncId] = 0;
   async_id_fields_[kTriggerAsyncId] = 0;
+  fields_[kStackLength] = 0;
 }
 
 inline Environment::AsyncHooks::DefaultTriggerAsyncIdScope
@@ -189,6 +199,11 @@ inline Environment::AsyncHooks::DefaultTriggerAsyncIdScope
 }
 
 
+Environment* Environment::ForAsyncHooks(AsyncHooks* hooks) {
+  return ContainerOf(&Environment::async_hooks_, hooks);
+}
+
+
 inline Environment::AsyncCallbackScope::AsyncCallbackScope(Environment* env)
     : env_(env) {
   env_->makecallback_cntr_++;
@@ -254,7 +269,6 @@ inline Environment::Environment(IsolateData* isolate_data,
                                 v8::Local<v8::Context> context)
     : isolate_(context->GetIsolate()),
       isolate_data_(isolate_data),
-      async_hooks_(context->GetIsolate()),
       timer_base_(uv_now(isolate_data->event_loop())),
       using_domains_(false),
       printed_error_(false),
diff --git a/src/env.cc b/src/env.cc
index c3f42302ae02cd..eb8cad15edcaf6 100644
--- a/src/env.cc
+++ b/src/env.cc
@@ -403,4 +403,21 @@ void Environment::CollectUVExceptionInfo(v8::Local<v8::Value> object,
                              syscall, message, path, dest);
 }
 
+
+void Environment::AsyncHooks::grow_async_ids_stack() {
+  const uint32_t old_capacity = async_ids_stack_.Length() / 2;
+  const uint32_t new_capacity = old_capacity * 1.5;
+  AliasedBuffer<double, v8::Float64Array> new_buffer(
+      env()->isolate(), new_capacity * 2);
+
+  for (uint32_t i = 0; i < old_capacity * 2; ++i)
+    new_buffer[i] = async_ids_stack_[i];
+  async_ids_stack_ = std::move(new_buffer);
+
+  env()->async_hooks_binding()->Set(
+      env()->context(),
+      env()->async_ids_stack_string(),
+      async_ids_stack_.GetJSArray()).FromJust();
+}
+
 }  // namespace node
diff --git a/src/env.h b/src/env.h
index 2c77949bc5e38e..cf118ac8d7e4e8 100644
--- a/src/env.h
+++ b/src/env.h
@@ -41,7 +41,6 @@
 #include <map>
 #include <stdint.h>
 #include <vector>
-#include <stack>
 #include <unordered_map>
 
 struct nghttp2_rcbuf;
@@ -100,6 +99,7 @@ class ModuleWrap;
   V(address_string, "address")                                                \
   V(args_string, "args")                                                      \
   V(async, "async")                                                           \
+  V(async_ids_stack_string, "async_ids_stack")                                \
   V(buffer_string, "buffer")                                                  \
   V(bytes_string, "bytes")                                                    \
   V(bytes_parsed_string, "bytesParsed")                                       \
@@ -280,6 +280,7 @@ class ModuleWrap;
   V(async_hooks_before_function, v8::Function)                                \
   V(async_hooks_after_function, v8::Function)                                 \
   V(async_hooks_promise_resolve_function, v8::Function)                       \
+  V(async_hooks_binding, v8::Object)                                          \
   V(binding_cache_object, v8::Object)                                         \
   V(internal_binding_cache_object, v8::Object)                                \
   V(buffer_prototype_object, v8::Object)                                      \
@@ -314,11 +315,6 @@ class ModuleWrap;
 
 class Environment;
 
-struct node_async_ids {
-  double async_id;
-  double trigger_async_id;
-};
-
 class IsolateData {
  public:
   IsolateData(v8::Isolate* isolate, uv_loop_t* event_loop,
@@ -382,6 +378,7 @@ class Environment {
       kPromiseResolve,
       kTotals,
       kCheck,
+      kStackLength,
       kFieldsCount,
     };
 
@@ -393,18 +390,17 @@ class Environment {
       kUidFieldsCount,
     };
 
-    AsyncHooks() = delete;
-
     inline AliasedBuffer<uint32_t, v8::Uint32Array>& fields();
     inline AliasedBuffer<double, v8::Float64Array>& async_id_fields();
+    inline AliasedBuffer<double, v8::Float64Array>& async_ids_stack();
 
     inline v8::Local<v8::String> provider_string(int idx);
 
     inline void no_force_checks();
+    inline Environment* env();
 
     inline void push_async_ids(double async_id, double trigger_async_id);
     inline bool pop_async_id(double async_id);
-    inline size_t stack_size();
     inline void clear_async_id_stack();  // Used in fatal exceptions.
 
     // Used to set the kDefaultTriggerAsyncId in a scope. This is instead of
@@ -426,19 +422,21 @@ class Environment {
 
    private:
     friend class Environment;  // So we can call the constructor.
-    inline explicit AsyncHooks(v8::Isolate* isolate);
+    inline AsyncHooks();
     // Keep a list of all Persistent strings used for Provider types.
     v8::Eternal<v8::String> providers_[AsyncWrap::PROVIDERS_LENGTH];
-    // Used by provider_string().
-    v8::Isolate* isolate_;
+    // Keep track of the environment copy itself.
+    Environment* env_;
     // Stores the ids of the current execution context stack.
-    std::stack<struct node_async_ids> async_ids_stack_;
+    AliasedBuffer<double, v8::Float64Array> async_ids_stack_;
     // Attached to a Uint32Array that tracks the number of active hooks for
     // each type.
     AliasedBuffer<uint32_t, v8::Uint32Array> fields_;
     // Attached to a Float64Array that tracks the state of async resources.
     AliasedBuffer<double, v8::Float64Array> async_id_fields_;
 
+    void grow_async_ids_stack();
+
     DISALLOW_COPY_AND_ASSIGN(AsyncHooks);
   };
 
@@ -693,6 +691,8 @@ class Environment {
 
   inline bool inside_should_not_abort_on_uncaught_scope() const;
 
+  static inline Environment* ForAsyncHooks(AsyncHooks* hooks);
+
  private:
   inline void ThrowError(v8::Local<v8::Value> (*fun)(v8::Local<v8::String>),
                          const char* errmsg);
diff --git a/test/parallel/test-async-hooks-recursive-stack.js b/test/parallel/test-async-hooks-recursive-stack.js
new file mode 100644
index 00000000000000..7ab73dc1bf4538
--- /dev/null
+++ b/test/parallel/test-async-hooks-recursive-stack.js
@@ -0,0 +1,20 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const async_hooks = require('async_hooks');
+
+// This test verifies that the async ID stack can grow indefinitely.
+
+function recurse(n) {
+  const a = new async_hooks.AsyncResource('foobar');
+  a.emitBefore();
+  assert.strictEqual(a.asyncId(), async_hooks.executionAsyncId());
+  assert.strictEqual(a.triggerAsyncId(), async_hooks.triggerAsyncId());
+  if (n >= 0)
+    recurse(n - 1);
+  assert.strictEqual(a.asyncId(), async_hooks.executionAsyncId());
+  assert.strictEqual(a.triggerAsyncId(), async_hooks.triggerAsyncId());
+  a.emitAfter();
+}
+
+recurse(1000);

From 24c71fb47cd772d4b4f8f3d55e5be24ba7a43342 Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Mon, 25 Dec 2017 21:38:10 +0100
Subject: [PATCH 16/23] test: make test-tls-invoke-queued use public API

`parallel/test-tls-invoke-queued` previously used the internal
`_write()` API to hook into the internals more directly, but this
invalidates the general assumption made by streams APIs that
only a single write is active at a time, and which is enforced
through the public API.

PR-URL: https://github.com/nodejs/node/pull/17864
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Weijia Wang <starkwang@126.com>
Reviewed-By: Daniel Bevenius <daniel.bevenius@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 test/parallel/test-tls-invoke-queued.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/test/parallel/test-tls-invoke-queued.js b/test/parallel/test-tls-invoke-queued.js
index 578ee4cbfd76f2..754b02ba0bae99 100644
--- a/test/parallel/test-tls-invoke-queued.js
+++ b/test/parallel/test-tls-invoke-queued.js
@@ -36,12 +36,12 @@ const server = tls.createServer({
   key: fixtures.readKey('agent1-key.pem'),
   cert: fixtures.readKey('agent1-cert.pem')
 }, common.mustCall(function(c) {
-  c._write('hello ', null, common.mustCall(function() {
-    c._write('world!', null, common.mustCall(function() {
+  c.write('hello ', null, common.mustCall(function() {
+    c.write('world!', null, common.mustCall(function() {
       c.destroy();
     }));
     // Data on next _write() will be written but callback will not be invoked
-    c._write(' gosh', null, common.mustNotCall());
+    c.write(' gosh', null, common.mustNotCall());
   }));
 
   server.close();

From c56972779b8c239a48df46b7caadf1ef1b9eacd2 Mon Sep 17 00:00:00 2001
From: Joyee Cheung <joyeec9h3@gmail.com>
Date: Mon, 25 Dec 2017 21:36:15 +0800
Subject: [PATCH 17/23] src: expose uv.errmap to binding

Add a errno -> [error code, uv error message] map to the uv binding
so the error message can be assembled in the JS layer.

PR-URL: https://github.com/nodejs/node/pull/17338
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
---
 src/uv.cc                                 | 25 +++++++++++++++++++++--
 test/parallel/test-uv-binding-constant.js | 12 +++++------
 test/parallel/test-uv-errno.js            |  2 +-
 3 files changed, 30 insertions(+), 9 deletions(-)

diff --git a/src/uv.cc b/src/uv.cc
index f70da1baae5deb..3c115cf05b5a3a 100644
--- a/src/uv.cc
+++ b/src/uv.cc
@@ -27,10 +27,15 @@
 namespace node {
 namespace {
 
+using v8::Array;
 using v8::Context;
 using v8::FunctionCallbackInfo;
+using v8::Integer;
+using v8::Isolate;
 using v8::Local;
+using v8::Map;
 using v8::Object;
+using v8::String;
 using v8::Value;
 
 
@@ -47,14 +52,30 @@ void InitializeUV(Local<Object> target,
                   Local<Value> unused,
                   Local<Context> context) {
   Environment* env = Environment::GetCurrent(context);
-  target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "errname"),
+  Isolate* isolate = env->isolate();
+  target->Set(FIXED_ONE_BYTE_STRING(isolate, "errname"),
               env->NewFunctionTemplate(ErrName)->GetFunction());
 
 #define V(name, _) NODE_DEFINE_CONSTANT(target, UV_##name);
   UV_ERRNO_MAP(V)
 #undef V
-}
 
+  Local<Map> err_map = Map::New(isolate);
+
+#define V(name, msg) do {                                                     \
+  Local<Array> arr = Array::New(isolate, 2);                                  \
+  arr->Set(0, OneByteString(isolate, #name));                                 \
+  arr->Set(1, OneByteString(isolate, msg));                                   \
+  err_map->Set(context,                                                       \
+               Integer::New(isolate, UV_##name),                              \
+               arr).ToLocalChecked();                                         \
+} while (0);
+  UV_ERRNO_MAP(V)
+#undef V
+
+  target->Set(context, FIXED_ONE_BYTE_STRING(isolate, "errmap"),
+              err_map).FromJust();
+}
 
 }  // anonymous namespace
 }  // namespace node
diff --git a/test/parallel/test-uv-binding-constant.js b/test/parallel/test-uv-binding-constant.js
index cad08575ca92eb..beae7672db12f5 100644
--- a/test/parallel/test-uv-binding-constant.js
+++ b/test/parallel/test-uv-binding-constant.js
@@ -9,10 +9,10 @@ const uv = process.binding('uv');
 
 const keys = Object.keys(uv);
 keys.forEach((key) => {
-  if (key === 'errname')
-    return; // skip this
-  const val = uv[key];
-  assert.throws(() => uv[key] = 1,
-                /^TypeError: Cannot assign to read only property/);
-  assert.strictEqual(uv[key], val);
+  if (key.startsWith('UV_')) {
+    const val = uv[key];
+    assert.throws(() => uv[key] = 1,
+                  /^TypeError: Cannot assign to read only property/);
+    assert.strictEqual(uv[key], val);
+  }
 });
diff --git a/test/parallel/test-uv-errno.js b/test/parallel/test-uv-errno.js
index d5ae7548a040d7..223be9058050d6 100644
--- a/test/parallel/test-uv-errno.js
+++ b/test/parallel/test-uv-errno.js
@@ -8,7 +8,7 @@ const uv = process.binding('uv');
 const keys = Object.keys(uv);
 
 keys.forEach((key) => {
-  if (key === 'errname')
+  if (!key.startsWith('UV_'))
     return;
 
   assert.doesNotThrow(() => {

From 6ca10de9468ed027f5e0b45f721d441df5972bc9 Mon Sep 17 00:00:00 2001
From: Joyee Cheung <joyeec9h3@gmail.com>
Date: Mon, 27 Nov 2017 13:08:05 +0900
Subject: [PATCH 18/23] fs: simplify the error context collection in C++

- Simplify the SyncCall template function, only collect error
  number and syscall in the C++ layer and collect the rest of context
  in JS for flexibility.
- Remove the stringFromPath JS helper now that the unprefixed path is
  directly put into the context before the binding is invoked with the
  prefixed path.
- Validate more properties in fs.access tests.

PR-URL: https://github.com/nodejs/node/pull/17338
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
---
 lib/fs.js                       |  4 ++--
 lib/internal/errors.js          | 35 +++++++++++----------------
 src/node_file.cc                | 42 ++++++++++++++++++++-------------
 test/parallel/test-fs-access.js | 24 +++++++++++++++++++
 4 files changed, 66 insertions(+), 39 deletions(-)

diff --git a/lib/fs.js b/lib/fs.js
index 93be37533405da..f357ff2b9d7691 100644
--- a/lib/fs.js
+++ b/lib/fs.js
@@ -329,10 +329,10 @@ fs.accessSync = function(path, mode) {
   else
     mode = mode | 0;
 
-  const ctx = {};
+  const ctx = { path };
   binding.access(pathModule.toNamespacedPath(path), mode, undefined, ctx);
 
-  if (ctx.code !== undefined) {
+  if (ctx.errno !== undefined) {
     throw new errors.uvException(ctx);
   }
 };
diff --git a/lib/internal/errors.js b/lib/internal/errors.js
index 9e3d1a9355e4f0..db501a1d3cfec8 100644
--- a/lib/internal/errors.js
+++ b/lib/internal/errors.js
@@ -14,6 +14,7 @@ const kCode = Symbol('code');
 const kInfo = Symbol('info');
 const messages = new Map();
 
+const { errmap } = process.binding('uv');
 const { kMaxLength } = process.binding('buffer');
 const { defineProperty } = Object;
 
@@ -194,43 +195,35 @@ function E(sym, val) {
   messages.set(sym, typeof val === 'function' ? val : String(val));
 }
 
-// JS counterpart of StringFromPath, although here path is a buffer.
-function stringFromPath(path) {
-  const str = path.toString();
-  if (process.platform !== 'win32') {
-    return str;
-  }
-
-  if (str.startsWith('\\\\?\\UNC\\')) {
-    return '\\\\' + str.slice(8);
-  } else if (str.startsWith('\\\\?\\')) {
-    return str.slice(4);
-  }
-  return str;
-}
-
 // This creates an error compatible with errors produced in UVException
 // using the context collected in CollectUVExceptionInfo
 // The goal is to migrate them to ERR_* errors later when
 // compatibility is not a concern
 function uvException(ctx) {
   const err = new Error();
-  err.errno = ctx.errno;
-  err.code = ctx.code;
-  err.syscall = ctx.syscall;
 
-  let message = `${ctx.code}: ${ctx.message}, ${ctx.syscall}`;
+  for (const prop of Object.keys(ctx)) {
+    if (prop === 'message' || prop === 'path' || prop === 'dest') {
+      continue;
+    }
+    err[prop] = ctx[prop];
+  }
+
+  const [ code, uvmsg ] = errmap.get(ctx.errno);
+  err.code = code;
+  let message = `${code}: ${uvmsg}, ${ctx.syscall}`;
   if (ctx.path) {
-    const path = stringFromPath(ctx.path);
+    const path = ctx.path.toString();
     message += ` '${path}'`;
     err.path = path;
   }
   if (ctx.dest) {
-    const dest = stringFromPath(ctx.dest);
+    const dest = ctx.dest.toString();
     message += ` -> '${dest}'`;
     err.dest = dest;
   }
   err.message = message;
+
   Error.captureStackTrace(err, uvException);
   return err;
 }
diff --git a/src/node_file.cc b/src/node_file.cc
index 272e0906447357..3373ad8707e225 100644
--- a/src/node_file.cc
+++ b/src/node_file.cc
@@ -88,6 +88,7 @@ using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
 using v8::HandleScope;
 using v8::Integer;
+using v8::Isolate;
 using v8::Local;
 using v8::MaybeLocal;
 using v8::Number;
@@ -157,6 +158,15 @@ FSReqAfterScope::~FSReqAfterScope() {
   wrap_->Dispose();
 }
 
+// TODO(joyeecheung): create a normal context object, and
+// construct the actual errors in the JS land using the context.
+// The context should include fds for some fs APIs, currently they are
+// missing in the error messages. The path, dest, syscall, fd, .etc
+// can be put into the context before the binding is even invoked,
+// the only information that has to come from the C++ layer is the
+// error number (and possibly the syscall for abstraction),
+// which is also why the errors should have been constructed
+// in JS for more flexibility.
 void FSReqAfterScope::Reject(uv_fs_t* req) {
   wrap_->Reject(UVException(wrap_->env()->isolate(),
                             req->result,
@@ -354,28 +364,28 @@ inline FSReqWrap* AsyncCall(Environment* env, Local<Object> req,
 #define ASYNC_CALL(after, func, req, encoding, ...)                           \
   ASYNC_DEST_CALL(after, func, req, nullptr, encoding, __VA_ARGS__)           \
 
-// Template counterpart of SYNC_DEST_CALL
+// Template counterpart of SYNC_CALL, except that it only puts
+// the error number and the syscall in the context instead of
+// creating an error in the C++ land.
 template <typename Func, typename... Args>
-inline void SyncDestCall(Environment* env, Local<Value> ctx,
-    const char* path, const char* dest, const char* syscall,
-    Func fn, Args... args) {
+inline void SyncCall(Environment* env, Local<Value> ctx,
+    const char* syscall, Func fn, Args... args) {
   fs_req_wrap req_wrap;
   env->PrintSyncTrace();
   int err = fn(env->event_loop(), &req_wrap.req, args..., nullptr);
-  if (err) {
+  if (err < 0) {
     Local<Context> context = env->context();
     Local<Object> ctx_obj = ctx->ToObject(context).ToLocalChecked();
-    env->CollectUVExceptionInfo(ctx_obj, err, syscall, nullptr, path, dest);
+    Isolate *isolate = env->isolate();
+    ctx_obj->Set(context,
+             env->errno_string(),
+             Integer::New(isolate, err)).FromJust();
+    ctx_obj->Set(context,
+             env->syscall_string(),
+             OneByteString(isolate, syscall)).FromJust();
   }
 }
 
-// Template counterpart of SYNC_CALL
-template <typename Func, typename... Args>
-inline void SyncCall(Environment* env, Local<Value> ctx,
-    const char* path, const char* syscall, Func fn, Args... args) {
-  return SyncDestCall(env, ctx, path, nullptr, syscall, fn, args...);
-}
-
 #define SYNC_DEST_CALL(func, path, dest, ...)                                 \
   fs_req_wrap req_wrap;                                                       \
   env->PrintSyncTrace();                                                      \
@@ -404,15 +414,15 @@ void Access(const FunctionCallbackInfo<Value>& args) {
   BufferValue path(env->isolate(), args[0]);
   int mode = static_cast<int>(args[1]->Int32Value(context).FromJust());
 
-  if (args[2]->IsObject()) {
+  if (args[2]->IsObject()) {  // access(path, mode, req)
     Local<Object> req_obj = args[2]->ToObject(context).ToLocalChecked();
     FSReqWrap* req_wrap = AsyncCall(
         env, req_obj, UTF8, "access", AfterNoArgs, uv_fs_access, *path, mode);
     if (req_wrap != nullptr) {
       args.GetReturnValue().Set(req_wrap->persistent());
     }
-  } else {
-    SyncCall(env, args[3], *path, "access", uv_fs_access, *path, mode);
+  } else {  // access(path, mode, undefined, ctx)
+    SyncCall(env, args[3], "access", uv_fs_access, *path, mode);
   }
 }
 
diff --git a/test/parallel/test-fs-access.js b/test/parallel/test-fs-access.js
index 719e1108fe1c02..9811f9340873b7 100644
--- a/test/parallel/test-fs-access.js
+++ b/test/parallel/test-fs-access.js
@@ -1,8 +1,14 @@
 'use strict';
+
+// This tests that fs.access and fs.accessSync works as expected
+// and the errors thrown from these APIs include the desired properties
+
 const common = require('../common');
 const assert = require('assert');
 const fs = require('fs');
 const path = require('path');
+const uv = process.binding('uv');
+
 const doesNotExist = path.join(common.tmpDir, '__this_should_not_exist');
 const readOnlyFile = path.join(common.tmpDir, 'read_only_file');
 const readWriteFile = path.join(common.tmpDir, 'read_write_file');
@@ -130,6 +136,24 @@ assert.throws(
       `ENOENT: no such file or directory, access '${doesNotExist}'`
     );
     assert.strictEqual(err.constructor, Error);
+    assert.strictEqual(err.syscall, 'access');
+    assert.strictEqual(err.errno, uv.UV_ENOENT);
+    return true;
+  }
+);
+
+assert.throws(
+  () => { fs.accessSync(Buffer.from(doesNotExist)); },
+  (err) => {
+    assert.strictEqual(err.code, 'ENOENT');
+    assert.strictEqual(err.path, doesNotExist);
+    assert.strictEqual(
+      err.message,
+      `ENOENT: no such file or directory, access '${doesNotExist}'`
+    );
+    assert.strictEqual(err.constructor, Error);
+    assert.strictEqual(err.syscall, 'access');
+    assert.strictEqual(err.errno, uv.UV_ENOENT);
     return true;
   }
 );

From 9f122e3b5513fd354b3876d06ea322b676b7350d Mon Sep 17 00:00:00 2001
From: Joyee Cheung <joyeec9h3@gmail.com>
Date: Wed, 29 Nov 2017 12:52:16 +0800
Subject: [PATCH 19/23] fs: throw fs.close errors in JS

* Collect the error context in both JS and C++, then throw
  the error in JS
* Test that the errors thrown from fs.close and fs.closeSync
  includes the correct error code, error number and syscall
  properties

PR-URL: https://github.com/nodejs/node/pull/17338
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
---
 lib/fs.js                             |  6 +++-
 src/node_file.cc                      | 18 +++++++----
 test/parallel/test-fs-close-errors.js | 43 +++++++++++++++++++++++++++
 3 files changed, 61 insertions(+), 6 deletions(-)

diff --git a/lib/fs.js b/lib/fs.js
index f357ff2b9d7691..5cde94ec516b73 100644
--- a/lib/fs.js
+++ b/lib/fs.js
@@ -661,7 +661,11 @@ fs.closeSync = function(fd) {
   if (!isUint32(fd))
     throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'fd', 'integer');
 
-  return binding.close(fd);
+  const ctx = {};
+  binding.close(fd, undefined, ctx);
+  if (ctx.errno !== undefined) {
+    throw new errors.uvException(ctx);
+  }
 };
 
 function modeNum(m, def) {
diff --git a/src/node_file.cc b/src/node_file.cc
index 3373ad8707e225..3f680c14d64702 100644
--- a/src/node_file.cc
+++ b/src/node_file.cc
@@ -429,15 +429,23 @@ void Access(const FunctionCallbackInfo<Value>& args) {
 
 void Close(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
+  Local<Context> context = env->context();
 
+  int length = args.Length();
+  CHECK_GE(length, 2);
   CHECK(args[0]->IsInt32());
 
-  int fd = args[0]->Int32Value();
+  int fd = static_cast<int>(args[0]->Int32Value(context).FromJust());
 
-  if (args[1]->IsObject()) {
-    ASYNC_CALL(AfterNoArgs, close, args[1], UTF8, fd)
-  } else {
-    SYNC_CALL(close, 0, fd)
+  if (args[1]->IsObject()) {  // close(fd, req)
+    Local<Object> req_obj = args[1]->ToObject(context).ToLocalChecked();
+    FSReqWrap* req_wrap = AsyncCall(
+        env, req_obj, UTF8, "close", AfterNoArgs, uv_fs_close, fd);
+    if (req_wrap != nullptr) {
+      args.GetReturnValue().Set(req_wrap->persistent());
+    }
+  } else {  // close(fd, undefined, ctx)
+    SyncCall(env, args[2], "close", uv_fs_close, fd);
   }
 }
 
diff --git a/test/parallel/test-fs-close-errors.js b/test/parallel/test-fs-close-errors.js
index cadcf2f78c4aa4..4f0d31369a2651 100644
--- a/test/parallel/test-fs-close-errors.js
+++ b/test/parallel/test-fs-close-errors.js
@@ -1,7 +1,12 @@
 'use strict';
 
+// This tests that the errors thrown from fs.close and fs.closeSync
+// include the desired properties
+
 const common = require('../common');
+const assert = require('assert');
 const fs = require('fs');
+const uv = process.binding('uv');
 
 ['', false, null, undefined, {}, []].forEach((i) => {
   common.expectsError(
@@ -21,3 +26,41 @@ const fs = require('fs');
     }
   );
 });
+
+{
+  assert.throws(
+    () => {
+      const fd = fs.openSync(__filename, 'r');
+      fs.closeSync(fd);
+      fs.closeSync(fd);
+    },
+    (err) => {
+      assert.strictEqual(err.code, 'EBADF');
+      assert.strictEqual(
+        err.message,
+        'EBADF: bad file descriptor, close'
+      );
+      assert.strictEqual(err.constructor, Error);
+      assert.strictEqual(err.syscall, 'close');
+      assert.strictEqual(err.errno, uv.UV_EBADF);
+      return true;
+    }
+  );
+}
+
+{
+  const fd = fs.openSync(__filename, 'r');
+  fs.close(fd, common.mustCall((err) => {
+    assert.ifError(err);
+    fs.close(fd, common.mustCall((err) => {
+      assert.strictEqual(err.code, 'EBADF');
+      assert.strictEqual(
+        err.message,
+        'EBADF: bad file descriptor, close'
+      );
+      assert.strictEqual(err.constructor, Error);
+      assert.strictEqual(err.syscall, 'close');
+      assert.strictEqual(err.errno, uv.UV_EBADF);
+    }));
+  }));
+}

From d3ac18a176b26c0df517f48bed77d070bb07a267 Mon Sep 17 00:00:00 2001
From: Anton Paras <anton@paras.nu>
Date: Sat, 23 Dec 2017 01:53:17 -0800
Subject: [PATCH 20/23] lib: migrate _http_outgoing.js's remaining errors

A couple of lib/_http_outgoing.js's errors were still in the
"old style": `throw new Error(<some message here>)`.

This commit migrates those 2 old style errors to the "new style":
internal/errors.js's error-system.

In the future, changes to these errors' messages won't break
semver-major status. With the old style, changes to these errors'
messages broke semver-major status. It was inconvenient.

Refs: https://github.com/nodejs/node/issues/17709
PR-URL: https://github.com/nodejs/node/pull/17837
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 lib/_http_outgoing.js                               |  4 ++--
 test/parallel/test-http-res-write-after-end.js      |  5 +++--
 test/parallel/test-http-server-write-after-end.js   |  6 ++++--
 test/parallel/test-outgoing-message-pipe.js         | 13 ++++++-------
 ...ipe-outgoing-message-data-emitted-after-ended.js |  6 +++---
 5 files changed, 18 insertions(+), 16 deletions(-)

diff --git a/lib/_http_outgoing.js b/lib/_http_outgoing.js
index 07cf84866fd831..324373f3851658 100644
--- a/lib/_http_outgoing.js
+++ b/lib/_http_outgoing.js
@@ -629,7 +629,7 @@ OutgoingMessage.prototype.write = function write(chunk, encoding, callback) {
 
 function write_(msg, chunk, encoding, callback, fromEnd) {
   if (msg.finished) {
-    var err = new Error('write after end');
+    const err = new errors.Error('ERR_STREAM_WRITE_AFTER_END');
     nextTick(msg.socket && msg.socket[async_id_symbol],
              writeAfterEndNT.bind(msg),
              err,
@@ -880,7 +880,7 @@ OutgoingMessage.prototype.flush = internalUtil.deprecate(function() {
 
 OutgoingMessage.prototype.pipe = function pipe() {
   // OutgoingMessage should be write-only. Piping from it is disabled.
-  this.emit('error', new Error('Cannot pipe, not readable'));
+  this.emit('error', new errors.Error('ERR_STREAM_CANNOT_PIPE'));
 };
 
 module.exports = {
diff --git a/test/parallel/test-http-res-write-after-end.js b/test/parallel/test-http-res-write-after-end.js
index 32c6cf2e082668..1d34cf6dcb4841 100644
--- a/test/parallel/test-http-res-write-after-end.js
+++ b/test/parallel/test-http-res-write-after-end.js
@@ -25,8 +25,9 @@ const assert = require('assert');
 const http = require('http');
 
 const server = http.Server(common.mustCall(function(req, res) {
-  res.on('error', common.mustCall(function onResError(err) {
-    assert.strictEqual(err.message, 'write after end');
+  res.on('error', common.expectsError({
+    code: 'ERR_STREAM_WRITE_AFTER_END',
+    type: Error
   }));
 
   res.write('This should write.');
diff --git a/test/parallel/test-http-server-write-after-end.js b/test/parallel/test-http-server-write-after-end.js
index 045cdcf4b75afb..a405844cfc9659 100644
--- a/test/parallel/test-http-server-write-after-end.js
+++ b/test/parallel/test-http-server-write-after-end.js
@@ -2,7 +2,6 @@
 
 const common = require('../common');
 const http = require('http');
-const assert = require('assert');
 
 // Fix for https://github.com/nodejs/node/issues/14368
 
@@ -10,7 +9,10 @@ const server = http.createServer(handle);
 
 function handle(req, res) {
   res.on('error', common.mustCall((err) => {
-    assert.strictEqual(err.message, 'write after end');
+    common.expectsError({
+      code: 'ERR_STREAM_WRITE_AFTER_END',
+      type: Error
+    })(err);
     server.close();
   }));
 
diff --git a/test/parallel/test-outgoing-message-pipe.js b/test/parallel/test-outgoing-message-pipe.js
index 2030d8f43b09be..7cfe3687ecc8a7 100644
--- a/test/parallel/test-outgoing-message-pipe.js
+++ b/test/parallel/test-outgoing-message-pipe.js
@@ -1,15 +1,14 @@
 'use strict';
-const assert = require('assert');
 const common = require('../common');
 const OutgoingMessage = require('_http_outgoing').OutgoingMessage;
 
 // Verify that an error is thrown upon a call to `OutgoingMessage.pipe`.
 
 const outgoingMessage = new OutgoingMessage();
-assert.throws(
-  common.mustCall(() => { outgoingMessage.pipe(outgoingMessage); }),
-  (err) => {
-    return ((err instanceof Error) && /Cannot pipe, not readable/.test(err));
-  },
-  'OutgoingMessage.pipe should throw an error'
+common.expectsError(
+  () => { outgoingMessage.pipe(outgoingMessage); },
+  {
+    code: 'ERR_STREAM_CANNOT_PIPE',
+    type: Error
+  }
 );
diff --git a/test/parallel/test-pipe-outgoing-message-data-emitted-after-ended.js b/test/parallel/test-pipe-outgoing-message-data-emitted-after-ended.js
index 0bd823908a6107..c6191a906b32d6 100644
--- a/test/parallel/test-pipe-outgoing-message-data-emitted-after-ended.js
+++ b/test/parallel/test-pipe-outgoing-message-data-emitted-after-ended.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
 const http = require('http');
-const assert = require('assert');
 const stream = require('stream');
 
 // Verify that when piping a stream to an `OutgoingMessage` (or a type that
@@ -17,8 +16,9 @@ const server = http.createServer(common.mustCall(function(req, res) {
   process.nextTick(common.mustCall(() => {
     res.end();
     myStream.emit('data', 'some data');
-    res.on('error', common.mustCall(function(err) {
-      assert.strictEqual(err.message, 'write after end');
+    res.on('error', common.expectsError({
+      code: 'ERR_STREAM_WRITE_AFTER_END',
+      type: Error
     }));
 
     process.nextTick(common.mustCall(() => server.close()));

From c560ae48c30207eff4c476de3be0bb7cdec1f7a7 Mon Sep 17 00:00:00 2001
From: Omar Crisostomo <omarcb@micorreo.upp.edu.mx>
Date: Wed, 27 Dec 2017 14:21:49 -0600
Subject: [PATCH 21/23] test: add test-fs-read-constructor-errors test

test added to extend the code coverage testing of the project
---
 .../test-fs-read-constructor-errors.js        | 35 +++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 test/parallel/test-fs-read-constructor-errors.js

diff --git a/test/parallel/test-fs-read-constructor-errors.js b/test/parallel/test-fs-read-constructor-errors.js
new file mode 100644
index 00000000000000..b7d9a358f0a7fb
--- /dev/null
+++ b/test/parallel/test-fs-read-constructor-errors.js
@@ -0,0 +1,35 @@
+'use strict';
+
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+const fs = require('fs');
+const filepath = fixtures.path('x.txt');
+const fd = fs.openSync(filepath, 'r');
+const expected = Buffer.from('xyz\n');
+
+common.expectsError(() => {
+  fs.read('notnumber',
+          Buffer.allocUnsafe(expected.length),
+          0,
+          expected.length,
+          0,
+          common.mustNotCall());
+}, { code: 'ERR_INVALID_ARG_TYPE', type: TypeError });
+
+common.expectsError(() => {
+  fs.read(fd,
+          Buffer.allocUnsafe(expected.length),
+          -1,
+          expected.length,
+          0,
+          common.mustNotCall());
+}, { code: 'ERR_OUT_OF_RANGE', type: RangeError });
+
+common.expectsError(() => {
+  fs.read(fd,
+          Buffer.allocUnsafe(expected.length),
+          0,
+          -1,
+          0,
+          common.mustNotCall());
+}, { code: 'ERR_OUT_OF_RANGE', type: RangeError });

From bfae5acd62ba75b634cfb72c7fd17428773b3902 Mon Sep 17 00:00:00 2001
From: Omar Crisostomo <omarcb@micorreo.upp.edu.mx>
Date: Wed, 27 Dec 2017 14:22:12 -0600
Subject: [PATCH 22/23] test: add test-fs-read-sync-constructor-errors test

test added to extend the code coverage testing of the project
---
 .../test-fs-read-sync-constructor-errors.js   | 34 +++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 test/parallel/test-fs-read-sync-constructor-errors.js

diff --git a/test/parallel/test-fs-read-sync-constructor-errors.js b/test/parallel/test-fs-read-sync-constructor-errors.js
new file mode 100644
index 00000000000000..3d88c57bfed77f
--- /dev/null
+++ b/test/parallel/test-fs-read-sync-constructor-errors.js
@@ -0,0 +1,34 @@
+'use strict';
+
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+const fs = require('fs');
+const filepath = fixtures.path('x.txt');
+const fd = fs.openSync(filepath, 'r');
+const expected = Buffer.from('xyz\n');
+
+common.expectsError(() => {
+  fs.readSync('notnumber',
+              Buffer.allocUnsafe(expected.length),
+              0,
+              expected.length,
+              0);
+}, { code: 'ERR_INVALID_ARG_TYPE', type: TypeError });
+
+common.expectsError(() => {
+  fs.readSync(fd,
+              Buffer.allocUnsafe(expected.length),
+              -1,
+              expected.length,
+              0,
+              common.mustNotCall());
+}, { code: 'ERR_OUT_OF_RANGE', type: RangeError });
+
+common.expectsError(() => {
+  fs.readSync(fd,
+              Buffer.allocUnsafe(expected.length),
+              0,
+              -1,
+              0,
+              common.mustNotCall());
+}, { code: 'ERR_OUT_OF_RANGE', type: RangeError });

From 047b2d7dffe6df452ef23f7413b75ac8377be759 Mon Sep 17 00:00:00 2001
From: Omar Crisostomo Barrera <omar13cb@gmail.com>
Date: Wed, 27 Dec 2017 14:55:21 -0600
Subject: [PATCH 23/23] Update test-fs-read-constructor-errors.js

---
 test/parallel/test-fs-read-constructor-errors.js | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/test/parallel/test-fs-read-constructor-errors.js b/test/parallel/test-fs-read-constructor-errors.js
index b7d9a358f0a7fb..1295c8ec0284bc 100644
--- a/test/parallel/test-fs-read-constructor-errors.js
+++ b/test/parallel/test-fs-read-constructor-errors.js
@@ -1,8 +1,11 @@
 'use strict';
 
 const common = require('../common');
+
 const fixtures = require('../common/fixtures');
+
 const fs = require('fs');
+
 const filepath = fixtures.path('x.txt');
 const fd = fs.openSync(filepath, 'r');
 const expected = Buffer.from('xyz\n');