Merge pull request #2003 from KristianJerpetjon/0.13.x

tcp: fix for checking that ack is within window

Author: alfreb

api/fs/common.hpp

@@ -21,6 +21,7 @@
 
 #include <memory>
 #include <string>
+#include <pmr>
 #include <vector>
 #include "path.hpp"
 #include <common>
@@ -35,12 +36,12 @@ namespace fs {
   /**
    * @brief Shared vector used as a buffer within the filesystem subsystem
    */
-  using buffer_t = std::shared_ptr<std::vector<uint8_t>>;
+  using buffer_t = os::mem::buf_ptr;
 
   /** Construct a shared vector **/
   template <typename... Args>
   buffer_t construct_buffer(Args&&... args) {
-    return std::make_shared<std::vector<uint8_t>> (std::forward<Args> (args)...);
+    return std::make_shared<os::mem::buffer> (std::forward<Args> (args)...);
   }
 
   /** Container types **/

api/hw/block_device.hpp

@@ -22,6 +22,7 @@
 #include <cstdint>
 #include <delegate>
 #include <memory>
+#include <pmr>
 #include <vector>
 
 namespace hw {
@@ -32,7 +33,7 @@ namespace hw {
 class Block_device {
 public:
   using block_t       = uint64_t;
-  using buffer_t      = std::shared_ptr<std::vector<uint8_t>>;
+  using buffer_t      = os::mem::buf_ptr;
   using on_read_func  = delegate<void(buffer_t)>;
   using on_write_func = delegate<void(bool error)>;
 
@@ -149,7 +150,7 @@ class Block_device {
    * This functionality is not enabled by default, nor always supported
   **/
   virtual void write(block_t blk, buffer_t, on_write_func) = 0;
-  
+
   virtual bool write_sync(block_t blk, buffer_t) = 0;
 
   /**

api/net/stream.hpp

@@ -23,6 +23,7 @@
 #include <cstddef>
 #include <delegate>
 #include <memory>
+#include <pmr>
 #include <vector>
 #include <net/socket.hpp>
 
@@ -34,13 +35,13 @@ namespace net {
    */
   class Stream {
   public:
-    using buffer_t = std::shared_ptr<std::vector<uint8_t>>;
+    using buffer_t = os::mem::buf_ptr;
     using ptr      = Stream_ptr;
 
     /** Construct a shared vector used by streams **/
     template <typename... Args>
     static buffer_t construct_buffer(Args&&... args) {
-      return std::make_shared<std::vector<uint8_t>> (std::forward<Args> (args)...);
+      return std::make_shared<os::mem::buffer> (std::forward<Args> (args)...);
     }
 
     /** Called when the stream is ready to be used. */

api/net/tcp/common.hpp

@@ -22,8 +22,10 @@
 #include <net/addr.hpp>
 #include <net/checksum.hpp>
 #include <chrono>
-#include <vector>
+
 #include <util/units.hpp>
+#include <vector>
+#include <pmr>
 
 namespace net {
   namespace tcp {
@@ -50,8 +52,9 @@ namespace net {
     static const std::chrono::milliseconds  default_dack_timeout {40};
 
     using namespace util::literals;
-    static constexpr size_t default_min_bufsize {4_KiB};
-    static constexpr size_t default_max_bufsize {256_KiB};
+    static constexpr size_t default_min_bufsize   {4_KiB};
+    static constexpr size_t default_max_bufsize   {256_KiB};
+    static constexpr size_t default_total_bufsize {64_MiB};
 
     using Address = net::Addr;
 
@@ -62,12 +65,12 @@ namespace net {
     using seq_t = uint32_t;
 
     /** A shared buffer pointer */
-    using buffer_t = std::shared_ptr<std::vector<uint8_t>>;
+    using buffer_t = os::mem::buf_ptr;
 
     /** Construct a shared vector used in TCP **/
     template <typename... Args>
     buffer_t construct_buffer(Args&&... args) {
-      return std::make_shared<std::vector<uint8_t>> (std::forward<Args> (args)...);
+      return std::make_shared<os::mem::buffer> (std::forward<Args> (args)...);
     }
 
     class Connection;

api/net/tcp/connection.hpp

@@ -31,6 +31,8 @@
 #include <delegate>
 #include <util/timer.hpp>
 
+#include <util/alloc_pmr.hpp>
+
 namespace net {
   // Forward declaration of the TCP object
   class TCP;
@@ -625,6 +627,7 @@ class Connection {
 
   /** The given read request */
   std::unique_ptr<Read_request> read_request;
+  os::mem::Pmr_pool::Resource_ptr bufalloc{nullptr};
 
   /** Queue for write requests to process */
   Write_queue writeq;

api/net/tcp/read_buffer.hpp

@@ -34,6 +34,7 @@ namespace tcp {
  */
 class Read_buffer {
 public:
+  using Alloc = os::mem::buffer::allocator_type;
   /**
    * @brief      Construct a read buffer.
    *             Min and max need to be power of 2.
@@ -44,6 +45,8 @@ class Read_buffer {
    */
   Read_buffer(const seq_t start, const size_t min, const size_t max);
 
+  Read_buffer(const seq_t start, const size_t min, const size_t max, const Alloc& alloc);
+
   /**
    * @brief      Insert data into the buffer relative to the sequence number.
    *

api/net/tcp/read_request.hpp

@@ -31,10 +31,11 @@ class Read_request {
   using Buffer_ptr = std::unique_ptr<Read_buffer>;
   using Buffer_queue = std::deque<Buffer_ptr>;
   using ReadCallback = delegate<void(buffer_t)>;
+  using Alloc        = os::mem::buffer::allocator_type;
   static constexpr size_t buffer_limit = 2;
   ReadCallback callback;
 
-  Read_request(seq_t start, size_t min, size_t max, ReadCallback cb);
+  Read_request(seq_t start, size_t min, size_t max, ReadCallback cb, Alloc&& alloc = Alloc());
 
   size_t insert(seq_t seq, const uint8_t* data, size_t n, bool psh = false);
 
@@ -57,6 +58,7 @@ class Read_request {
 
 private:
   Buffer_queue buffers;
+  Alloc        alloc;
 
   Read_buffer* get_buffer(const seq_t seq);
 

api/net/tcp/tcp.hpp

@@ -31,6 +31,7 @@
 #include <net/socket.hpp>
 #include <net/ip4/ip4.hpp>
 #include <util/bitops.hpp>
+#include <util/alloc_pmr.hpp>
 
 namespace net {
 
@@ -370,6 +371,22 @@ namespace net {
     uint16_t max_syn_backlog() const
     { return max_syn_backlog_; }
 
+    /**
+     * @brief      Set the maximum allowed memory
+     *             to be used by this TCP.
+     *
+     * @param[in]  size  The limit in bytes
+     */
+    void set_total_bufsize(const size_t size)
+    {
+      total_bufsize_ = size;
+      mempool_.set_total_capacity(total_bufsize_);
+    }
+
+    const os::mem::Pmr_pool& mempool() {
+      return mempool_;
+    }
+
     /**
      * @brief      Sets the minimum buffer size.
      *
@@ -532,6 +549,12 @@ namespace net {
     Listeners     listeners_;
     Connections   connections_;
 
+    size_t total_bufsize_;
+    os::mem::Pmr_pool mempool_;
+
+    size_t min_bufsize_;
+    size_t max_bufsize_;
+
     Port_utils& ports_;
 
     downstream  network_layer_out_;
@@ -557,9 +580,6 @@ namespace net {
     /** Maximum SYN queue backlog */
     uint16_t                  max_syn_backlog_;
 
-    size_t min_bufsize_       {tcp::default_min_bufsize};
-    size_t max_bufsize_       {tcp::default_max_bufsize};
-
     /** Stats */
     uint64_t* bytes_rx_ = nullptr;
     uint64_t* bytes_tx_ = nullptr;

api/pmr

@@ -0,0 +1,16 @@
+#pragma once
+
+#if __has_include(<memory_resource>)
+#include <memory_resource>
+#else
+#include <experimental/memory_resource>
+#include <experimental/vector>
+namespace std {
+  namespace pmr = std::experimental::pmr;
+}
+#endif
+
+namespace os::mem {
+  using buffer  = std::pmr::vector<uint8_t>;
+  using buf_ptr = std::shared_ptr<buffer>;
+}

api/util/alloc_buddy.hpp

@@ -21,14 +21,7 @@
 #include <common>
 #include <sstream>
 #include <array>
-#if __has_include(<memory_resource>)
-#include <memory_resource>
-#else
-#include <experimental/memory_resource>
-namespace std::pmr {
-  using memory_resource = std::experimental::pmr::memory_resource;
-}
-#endif
+#include <pmr>
 #include <stdlib.h>
 #include <math.h>