File 3032-Move-recv-buffer-to-process-struct.patch of Package erlang

Overview Repositories Revisions Requests Users Attributes Meta

File 3032-Move-recv-buffer-to-process-struct.patch of Package erlang

From aee4cd9da8c5de72aff3ede506fc590fb17f3627 Mon Sep 17 00:00:00 2001
From: Raimo Niskanen <raimo@erlang.org>
Date: Tue, 6 Feb 2024 09:43:35 +0100
Subject: [PATCH 02/22] Move recv buffer to process struct

In preparation to keep buffer between NIF calls...
---
 erts/emulator/nifs/common/prim_socket_int.h  |   8 +-
 erts/emulator/nifs/common/prim_socket_nif.c  |   4 +
 erts/emulator/nifs/unix/unix_socket_syncio.c | 199 +++++++++----------
 3 files changed, 104 insertions(+), 107 deletions(-)

diff --git a/erts/emulator/nifs/common/prim_socket_int.h b/erts/emulator/nifs/common/prim_socket_int.h
index 2d48874e27..dcd38666e1 100644
--- a/erts/emulator/nifs/common/prim_socket_int.h
+++ b/erts/emulator/nifs/common/prim_socket_int.h
@@ -1,7 +1,7 @@
 /*
  * %CopyrightBegin%
  *
- * Copyright Ericsson AB 2022-2023. All Rights Reserved.
+ * Copyright Ericsson AB 2022-2024. All Rights Reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -476,8 +476,10 @@ typedef struct {
     ESockRequestor*    currentReaderP; // NULL or &currentReader
 #endif
     ESockRequestQueue  readersQ;
-    ErlNifBinary       rbuffer;      // DO WE NEED THIS
-    Uint32             readCapacity; // DO WE NEED THIS
+
+    ErlNifBinary       readBuf;
+    ssize_t            readResult;
+
     ESockCounter       readPkgCnt;
     ESockCounter       readPkgMax;
     ESockCounter       readPkgMaxCnt;
diff --git a/erts/emulator/nifs/common/prim_socket_nif.c b/erts/emulator/nifs/common/prim_socket_nif.c
index a61131c177..223be923e1 100644
--- a/erts/emulator/nifs/common/prim_socket_nif.c
+++ b/erts/emulator/nifs/common/prim_socket_nif.c
@@ -11799,6 +11799,10 @@ ESockDescriptor* esock_alloc_descriptor(SOCKET sock)
     descP->readersQ.first = NULL;
     descP->readersQ.last  = NULL;
 
+    descP->readBuf.size   = 0;
+    descP->readBuf.data   = NULL;
+    descP->readResult     = 0;
+
     descP->readPkgCnt     = 0;
     descP->readPkgMax     = 0;
     descP->readPkgMaxCnt  = 0;
diff --git a/erts/emulator/nifs/unix/unix_socket_syncio.c b/erts/emulator/nifs/unix/unix_socket_syncio.c
index 2683e1d0d7..b7446b0e87 100644
--- a/erts/emulator/nifs/unix/unix_socket_syncio.c
+++ b/erts/emulator/nifs/unix/unix_socket_syncio.c
@@ -1,4 +1,4 @@
-/*
+;/*
  * %CopyrightBegin%
  *
  * Copyright Ericsson AB 2022-2024. All Rights Reserved.
@@ -324,10 +324,8 @@ static ERL_NIF_TERM essio_sendfile_ok(ErlNifEnv*       env,
 
 static ERL_NIF_TERM recv_check_result(ErlNifEnv*       env,
                                       ESockDescriptor* descP,
-                                      ssize_t          read,
                                       ssize_t          toRead,
                                       int              saveErrno,
-                                      ErlNifBinary*    bufP,
                                       ERL_NIF_TERM     sockRef,
                                       ERL_NIF_TERM     recvRef);
 static ERL_NIF_TERM recvfrom_check_result(ErlNifEnv*       env,
@@ -345,27 +343,19 @@ static BOOLEAN_T recv_check_reader(ErlNifEnv*       env,
                                    ERL_NIF_TERM*    checkResult);
 static ERL_NIF_TERM recv_check_full(ErlNifEnv*       env,
                                     ESockDescriptor* descP,
-                                    ssize_t          read,
                                     ssize_t          toRead,
-                                    ErlNifBinary*    bufP,
                                     ERL_NIF_TERM     sockRef,
                                     ERL_NIF_TERM     recvRef);
 static ERL_NIF_TERM recv_check_full_maybe_done(ErlNifEnv*       env,
                                                ESockDescriptor* descP,
-                                               ssize_t          read,
-                                               ErlNifBinary*    bufP,
                                                ERL_NIF_TERM     sockRef,
                                                ERL_NIF_TERM     recvRef);
 static ERL_NIF_TERM recv_check_full_done(ErlNifEnv*       env,
                                          ESockDescriptor* descP,
-                                         ssize_t          read,
-                                         ErlNifBinary*    bufP,
                                          ERL_NIF_TERM     sockRef);
 static ERL_NIF_TERM recv_check_fail(ErlNifEnv*       env,
                                     ESockDescriptor* descP,
                                     int              saveErrno,
-                                    ErlNifBinary*    buf1P,
-                                    ErlNifBinary*    buf2P,
                                     ERL_NIF_TERM     sockRef,
                                     ERL_NIF_TERM     recvRef);
 static ERL_NIF_TERM recv_check_fail_gen(ErlNifEnv*       env,
@@ -382,21 +372,15 @@ static ERL_NIF_TERM recv_check_retry(ErlNifEnv*       env,
                                      ERL_NIF_TERM     recvRef);
 static ERL_NIF_TERM recv_check_partial(ErlNifEnv*       env,
                                        ESockDescriptor* descP,
-                                       ssize_t          read,
                                        ssize_t          toRead,
-                                       ErlNifBinary*    bufP,
                                        ERL_NIF_TERM     sockRef,
                                        ERL_NIF_TERM     recvRef);
 static ERL_NIF_TERM recv_check_partial_done(ErlNifEnv*       env,
                                             ESockDescriptor* descP,
-                                            ssize_t          read,
-                                            ErlNifBinary*    bufP,
                                             ERL_NIF_TERM     sockRef,
                                             ERL_NIF_TERM     returnTag);
 static ERL_NIF_TERM recv_check_partial_part(ErlNifEnv*       env,
                                             ESockDescriptor* descP,
-                                            ssize_t          read,
-                                            ErlNifBinary*    bufP,
                                             ERL_NIF_TERM     sockRef,
                                             ERL_NIF_TERM     recvRef);
 static void recv_init_current_reader(ErlNifEnv*       env,
@@ -2614,8 +2598,9 @@ ERL_NIF_TERM essio_recv(ErlNifEnv*       env,
                    "essio_recv {%d} -> read: %ld (%d)\r\n",
                    descP->sock, (long) read, save_errno) );
 
-    return recv_check_result(env, descP, read, len, save_errno,
-                             &buf, sockRef, recvRef);
+    descP->readBuf    = buf;
+    descP->readResult = read;
+    return recv_check_result(env, descP, len, save_errno, sockRef, recvRef);
 }
 
 
@@ -2626,10 +2611,8 @@ ERL_NIF_TERM essio_recv(ErlNifEnv*       env,
 static
 ERL_NIF_TERM recv_check_result(ErlNifEnv*       env,
                                ESockDescriptor* descP,
-                               ssize_t          read,
                                ssize_t          toRead,
                                int              saveErrno,
-                               ErlNifBinary*    bufP,
                                ERL_NIF_TERM     sockRef,
                                ERL_NIF_TERM     recvRef)
 {
@@ -2637,26 +2620,26 @@ ERL_NIF_TERM recv_check_result(ErlNifEnv*       env,
 
     SSDBG( descP,
            ("UNIX-ESSIO", "recv_check_result(%T) {%d} -> entry with"
-            "\r\n   read:      %ld"
-            "\r\n   toRead:    %ld"
-            "\r\n   saveErrno: %d"
-            "\r\n   recvRef:   %T"
+            "\r\n   readResult: %ld"
+            "\r\n   toRead:     %ld"
+            "\r\n   saveErrno:  %d"
+            "\r\n   recvRef:    %T"
             "\r\n", sockRef, descP->sock,
-            (long) read, (long) toRead, saveErrno, recvRef) );
+            (long) descP->readResult, (long) toRead, saveErrno, recvRef) );
 
 
     /* <KOLLA>
      *
-     * We need to handle read = 0 for other type(s) (DGRAM) when
+     * We need to handle readResult = 0 for other type(s) (DGRAM) when
      * its actually valid to read 0 bytes.
      *
      * </KOLLA>
      */
-    
-    if ((read == 0) && (descP->type == SOCK_STREAM)) {
+
+    if ((descP->readResult == 0) && (descP->type == SOCK_STREAM)) {
         ERL_NIF_TERM reason = esock_atom_closed;
         res = esock_make_error(env, reason);
-        
+
         ESOCK_CNT_INC(env, descP, sockRef,
                       esock_atom_read_fails, &descP->readFails, 1);
 
@@ -2671,34 +2654,38 @@ ERL_NIF_TERM recv_check_result(ErlNifEnv*       env,
 
         recv_error_current_reader(env, descP, sockRef, reason);
 
-        FREE_BIN(bufP);
+        FREE_BIN(&descP->readBuf);
+        descP->readBuf.data = NULL;
+        descP->readBuf.size = 0;
 
     } else {
-    
+
         /* There is a special case: If the provided 'to read' value is
          * zero (0) (only for type =/= stream).
          * That means that we read as much as we can, using the default
          * read buffer size.
          */
 
-        if (bufP->size == read) {
+        if (descP->readBuf.size == descP->readResult) {
 
             /* +++ We filled the buffer +++ */
 
             SSDBG( descP,
                    ("UNIX-ESSIO",
                     "recv_check_result(%T) {%d} -> [%lu] filled the buffer\r\n",
-                    sockRef, descP->sock, (unsigned long) bufP->size) );
+                    sockRef, descP->sock,
+                    (unsigned long) descP->readBuf.size) );
 
-            res = recv_check_full(env, descP, read, toRead, bufP,
-                                  sockRef, recvRef);
+            res = recv_check_full(env, descP, toRead, sockRef, recvRef);
 
-        } else if (read < 0) {
+        } else if (descP->readResult < 0) {
 
             /* +++ Error handling +++ */
 
-            res = recv_check_fail(env, descP, saveErrno, bufP, NULL,
-                                  sockRef, recvRef);
+            res = recv_check_fail(env, descP, saveErrno, sockRef, recvRef);
+            FREE_BIN(&descP->readBuf);
+            descP->readBuf.data = NULL;
+            descP->readBuf.size = 0;
 
         } else {
 
@@ -2708,11 +2695,10 @@ ERL_NIF_TERM recv_check_result(ErlNifEnv*       env,
                    ("UNIX-ESSIO",
                     "recv_check_result(%T) {%d} -> [%lu] "
                     "did not fill the buffer (%ld)\r\n",
-                    sockRef, descP->sock, (unsigned long) bufP->size,
-                    (long) read) );
+                    sockRef, descP->sock, (unsigned long) descP->readBuf.size,
+                    (long) descP->readResult) );
 
-            res = recv_check_partial(env, descP, read, toRead, bufP,
-                                     sockRef, recvRef);
+            res = recv_check_partial(env, descP, toRead, sockRef, recvRef);
         }
     }
 
@@ -2846,8 +2832,8 @@ ERL_NIF_TERM recvfrom_check_result(ErlNifEnv*       env,
 
         /* +++ Error handling +++ */
 
-        res = recv_check_fail(env, descP, saveErrno, bufP, NULL,
-                              sockRef, recvRef);
+        res = recv_check_fail(env, descP, saveErrno, sockRef, recvRef);
+        FREE_BIN(bufP);
 
     } else {
 
@@ -2870,7 +2856,7 @@ ERL_NIF_TERM recvfrom_check_result(ErlNifEnv*       env,
                       &descP->readByteCnt, read);
 
         recv_update_current_reader(env, descP, sockRef);
-        
+
         res = esock_make_ok2(env, MKT2(env, eSockAddr, data));
 
     }
@@ -3031,8 +3017,8 @@ ERL_NIF_TERM recvmsg_check_result(ErlNifEnv*       env,
 
         /* +++ Error handling +++ */
 
-        res = recv_check_fail(env, descP, saveErrno, dataBufP, ctrlBufP,
-                              sockRef, recvRef);
+        res = recv_check_fail(env, descP, saveErrno, sockRef, recvRef);
+        FREE_BIN(dataBufP); FREE_BIN(ctrlBufP);
 
     } else {
 
@@ -6488,6 +6474,12 @@ void essio_dtor(ErlNifEnv*       env,
     descP->writeState |= (ESOCK_STATE_DTOR | ESOCK_STATE_CLOSED);
     descP->pattern     = (ESOCK_DESC_PATTERN_DTOR | ESOCK_STATE_CLOSED);
 
+    if (descP->readBuf.data != NULL) {
+        FREE_BIN(&descP->readBuf);
+        descP->readBuf.data = NULL;
+        descP->readBuf.size = 0;
+    }
+
     esock_free_env("dtor reader", descP->currentReader.env);
     descP->currentReader.env = NULL;
 
@@ -6838,9 +6830,7 @@ BOOLEAN_T recv_check_reader(ErlNifEnv*       env,
 static
 ERL_NIF_TERM recv_check_full(ErlNifEnv*       env,
                              ESockDescriptor* descP,
-                             ssize_t          read,
                              ssize_t          toRead,
-                             ErlNifBinary*    bufP,
                              ERL_NIF_TERM     sockRef,
                              ERL_NIF_TERM     recvRef)
 {
@@ -6865,14 +6855,14 @@ ERL_NIF_TERM recv_check_full(ErlNifEnv*       env,
         SSDBG( descP,
                ("UNIX-ESSIO",
                 "recv_check_full(%T) {%d} -> shall we continue reading?"
-                "\r\n   read:    %ld"
-                "\r\n   rNum:    %u"
-                "\r\n   rNumCnt: %u"
+                "\r\n   readResult: %ld"
+                "\r\n   rNum:       %u"
+                "\r\n   rNumCnt:    %u"
                 "\r\n", sockRef, descP->sock,
-                (unsigned long) read, descP->rNum, descP->rNumCnt) );
+                (unsigned long) descP->readResult, descP->rNum,
+                descP->rNumCnt) );
 
-        res = recv_check_full_maybe_done(env, descP, read, bufP,
-                                         sockRef, recvRef);
+        res = recv_check_full_maybe_done(env, descP, sockRef, recvRef);
 
     } else {
 
@@ -6884,7 +6874,7 @@ ERL_NIF_TERM recv_check_full(ErlNifEnv*       env,
                 "we got exactly what we could fit\r\n",
                 sockRef, descP->sock, (long) toRead) );
 
-        res = recv_check_full_done(env, descP, read, bufP, sockRef);
+        res = recv_check_full_done(env, descP, sockRef);
 
     }
 
@@ -6908,14 +6898,15 @@ ERL_NIF_TERM recv_check_full(ErlNifEnv*       env,
 static
 ERL_NIF_TERM recv_check_full_maybe_done(ErlNifEnv*       env,
                                         ESockDescriptor* descP,
-                                        ssize_t          read,
-                                        ErlNifBinary*    bufP,
                                         ERL_NIF_TERM     sockRef,
                                         ERL_NIF_TERM     recvRef)
 {
+    ERL_NIF_TERM ret;
+
     ESOCK_CNT_INC(env, descP, sockRef,
-                  esock_atom_read_byte, &descP->readByteCnt, read);
-    descP->readPkgMaxCnt += read;
+                  esock_atom_read_byte, &descP->readByteCnt,
+                  descP->readResult);
+    descP->readPkgMaxCnt += descP->readResult;
 
     descP->rNumCnt++;
     if (descP->rNumCnt >= descP->rNum) {
@@ -6934,25 +6925,31 @@ ERL_NIF_TERM recv_check_full_maybe_done(ErlNifEnv*       env,
          * erlang term (no need for an explicit free).
          */
 
-        return esock_make_ok2(env, MKBIN(env, bufP));
+        ret = esock_make_ok2(env, MKBIN(env, &descP->readBuf));
+        descP->readBuf.data = NULL;
+        descP->readBuf.size = 0;
+    } else {
 
-    }
+        /* Yes, we *do* need to continue reading */
 
-    /* Yes, we *do* need to continue reading */
+        recv_init_current_reader(env, descP, recvRef);
 
-    recv_init_current_reader(env, descP, recvRef);
+        /* This transfers "ownership" of the *allocated* binary to an
+         * erlang term (no need for an explicit free).
+         */
 
-    /* This transfers "ownership" of the *allocated* binary to an
-     * erlang term (no need for an explicit free).
-     */
+        SSDBG( descP,
+               ("UNIX-ESSIO",
+                "recv_check_full_maybe_done(%T) {%d} -> [%lu] "
+                "we are done for now - read more\r\n",
+                sockRef, descP->sock, (unsigned long) descP->readBuf.size) );
 
-    SSDBG( descP,
-           ("UNIX-ESSIO",
-            "recv_check_full_maybe_done(%T) {%d} -> [%lu] "
-            "we are done for now - read more\r\n",
-            sockRef, descP->sock, (unsigned long)bufP->size) );
+        ret = MKT2(env, esock_atom_more, MKBIN(env, &descP->readBuf));
+        descP->readBuf.data = NULL;
+        descP->readBuf.size = 0;
+    }
 
-    return MKT2(env, esock_atom_more, MKBIN(env, bufP));
+    return ret;
 }
 
 
@@ -6965,8 +6962,6 @@ ERL_NIF_TERM recv_check_full_maybe_done(ErlNifEnv*       env,
 static
 ERL_NIF_TERM recv_check_full_done(ErlNifEnv*       env,
                                   ESockDescriptor* descP,
-                                  ssize_t          read,
-                                  ErlNifBinary*    bufP,
                                   ERL_NIF_TERM     sockRef)
 {
     ERL_NIF_TERM data;
@@ -6974,11 +6969,12 @@ ERL_NIF_TERM recv_check_full_done(ErlNifEnv*       env,
     ESOCK_CNT_INC(env, descP, sockRef,
                   esock_atom_read_pkg, &descP->readPkgCnt, 1);
     ESOCK_CNT_INC(env, descP, sockRef,
-                  esock_atom_read_byte, &descP->readByteCnt, read);
+                  esock_atom_read_byte, &descP->readByteCnt,
+                  descP->readResult);
 
     descP->rNumCnt = 0;
 
-    descP->readPkgMaxCnt += read;
+    descP->readPkgMaxCnt += descP->readResult;
     if (descP->readPkgMaxCnt > descP->readPkgMax)
         descP->readPkgMax = descP->readPkgMaxCnt;
     descP->readPkgMaxCnt = 0;
@@ -6988,7 +6984,9 @@ ERL_NIF_TERM recv_check_full_done(ErlNifEnv*       env,
     /* This transfers "ownership" of the *allocated* binary to an
      * erlang term (no need for an explicit free).
      */
-    data = MKBIN(env, bufP);
+    data = MKBIN(env, &descP->readBuf);
+    descP->readBuf.data = NULL;
+    descP->readBuf.size = 0;
 
     return esock_make_ok2(env, data);
 }
@@ -7004,16 +7002,11 @@ static
 ERL_NIF_TERM recv_check_fail(ErlNifEnv*       env,
                              ESockDescriptor* descP,
                              int              saveErrno,
-                             ErlNifBinary*    buf1P,
-                             ErlNifBinary*    buf2P,
                              ERL_NIF_TERM     sockRef,
                              ERL_NIF_TERM     recvRef)
 {
     ERL_NIF_TERM res;
 
-    FREE_BIN(buf1P);
-    if (buf2P != NULL) FREE_BIN(buf2P);
-
     descP->rNumCnt = 0;
 
     if (saveErrno == ECONNRESET)  {
@@ -7170,9 +7163,7 @@ ERL_NIF_TERM recv_check_retry(ErlNifEnv*       env,
 static
 ERL_NIF_TERM recv_check_partial(ErlNifEnv*       env,
                                 ESockDescriptor* descP,
-                                ssize_t          read,
                                 ssize_t          toRead,
-                                ErlNifBinary*    bufP,
                                 ERL_NIF_TERM     sockRef,
                                 ERL_NIF_TERM     recvRef)
 {
@@ -7199,7 +7190,7 @@ ERL_NIF_TERM recv_check_partial(ErlNifEnv*       env,
                     "\r\n", sockRef, descP->sock, (long) toRead,
                     recvRef) );
 
-            res = recv_check_partial_done(env, descP, read, bufP, sockRef,
+            res = recv_check_partial_done(env, descP, sockRef,
                                           esock_atom_timeout);
         } else {
 
@@ -7215,8 +7206,7 @@ ERL_NIF_TERM recv_check_partial(ErlNifEnv*       env,
                     "\r\n", sockRef, descP->sock, (long) toRead,
                     recvRef) );
 
-            res = recv_check_partial_part(env, descP, read,
-                                          bufP, sockRef, recvRef);
+            res = recv_check_partial_part(env, descP, sockRef, recvRef);
         }
     } else {
 
@@ -7229,8 +7219,7 @@ ERL_NIF_TERM recv_check_partial(ErlNifEnv*       env,
                 "\r\n", sockRef, descP->sock, (long) toRead,
                 recvRef) );
 
-        res = recv_check_partial_done(env, descP, read, bufP, sockRef,
-                                          esock_atom_ok);
+        res = recv_check_partial_done(env, descP, sockRef, esock_atom_ok);
     }
 
     return res;
@@ -7245,8 +7234,6 @@ ERL_NIF_TERM recv_check_partial(ErlNifEnv*       env,
 static
 ERL_NIF_TERM recv_check_partial_done(ErlNifEnv*       env,
                                      ESockDescriptor* descP,
-                                     ssize_t          read,
-                                     ErlNifBinary*    bufP,
                                      ERL_NIF_TERM     sockRef,
                                      ERL_NIF_TERM     returnTag)
 {
@@ -7256,9 +7243,9 @@ ERL_NIF_TERM recv_check_partial_done(ErlNifEnv*       env,
     ESOCK_CNT_INC(env, descP, sockRef,
                   esock_atom_read_pkg, &descP->readPkgCnt, 1);
     ESOCK_CNT_INC(env, descP, sockRef,
-                  esock_atom_read_byte, &descP->readByteCnt, read);
+                  esock_atom_read_byte, &descP->readByteCnt, descP->readResult);
 
-    descP->readPkgMaxCnt += read;
+    descP->readPkgMaxCnt += descP->readResult;
     if (descP->readPkgMaxCnt > descP->readPkgMax)
         descP->readPkgMax = descP->readPkgMaxCnt;
     descP->readPkgMaxCnt = 0;
@@ -7268,15 +7255,16 @@ ERL_NIF_TERM recv_check_partial_done(ErlNifEnv*       env,
     /* This transfers "ownership" of the *allocated* binary to an
      * erlang term (no need for an explicit free).
      */
-    ESOCK_ASSERT( REALLOC_BIN(bufP, read) );
-    data = MKBIN(env, bufP);
+    ESOCK_ASSERT( REALLOC_BIN(&descP->readBuf, descP->readResult) );
+    data = MKBIN(env, &descP->readBuf);
+    descP->readBuf.data = NULL;
+    descP->readBuf.size = 0;
 
     SSDBG( descP,
            ("UNIX-ESSIO", "recv_check_partial_done(%T) {%d} -> [%ld] done\r\n",
-            sockRef, descP->sock, (long) read) );
+            sockRef, descP->sock, (long) descP->readResult) );
 
     return MKT2(env, returnTag, data);
-    return esock_make_ok2(env, data);
 }
 
 
@@ -7289,8 +7277,6 @@ ERL_NIF_TERM recv_check_partial_done(ErlNifEnv*       env,
 static
 ERL_NIF_TERM recv_check_partial_part(ErlNifEnv*       env,
                                      ESockDescriptor* descP,
-                                     ssize_t          read,
-                                     ErlNifBinary*    bufP,
                                      ERL_NIF_TERM     sockRef,
                                      ERL_NIF_TERM     recvRef)
 {
@@ -7298,7 +7284,7 @@ ERL_NIF_TERM recv_check_partial_part(ErlNifEnv*       env,
     int          sres;
 
     ESOCK_CNT_INC(env, descP, sockRef,
-                  esock_atom_read_byte, &descP->readByteCnt, read);
+                  esock_atom_read_byte, &descP->readByteCnt, descP->readResult);
 
     recv_init_current_reader(env, descP, recvRef);
 
@@ -7315,12 +7301,17 @@ ERL_NIF_TERM recv_check_partial_part(ErlNifEnv*       env,
         res = enif_raise_exception(env,
                                    MKT2(env, esock_atom_select_read,
                                         MKI(env, sres)));
+        FREE_BIN(&descP->readBuf);
+        descP->readBuf.data = NULL;
+        descP->readBuf.size = 0;
     } else {
         ERL_NIF_TERM data;
 
         descP->readState |= ESOCK_STATE_SELECTED;
-        ESOCK_ASSERT( REALLOC_BIN(bufP, read) );
-	data = MKBIN(env, bufP);
+        ESOCK_ASSERT( REALLOC_BIN(&descP->readBuf, descP->readResult) );
+	data = MKBIN(env, &descP->readBuf);
+        descP->readBuf.data = NULL;
+        descP->readBuf.size = 0;
 	res  = MKT2(env, esock_atom_select, data);
     }
 
-- 
2.35.3

Places

File 3032-Move-recv-buffer-to-process-struct.patch of Package erlang

Places