tcp: Change RCV WND value from a static value to a dynamic value based on global mem avail

Author: AndreasAakesson

api/net/tcp/connection.hpp

@@ -231,7 +231,8 @@ class Connection {
     SEQ_OUT_OF_ORDER,
     ACK_NOT_SET,
     ACK_OUT_OF_ORDER,
-    RST
+    RST,
+    RCV_WND_ZERO
   }; // < Drop_reason
 
   /**
@@ -599,6 +600,11 @@ class Connection {
    */
   void reset_callbacks();
 
+
+  using Recv_window_getter = delegate<uint32_t()>;
+  void set_recv_wnd_getter(Recv_window_getter func)
+  { recv_wnd_getter = func; }
+
 private:
   /** "Parent" for Connection. */
   TCP& host_;
@@ -626,6 +632,10 @@ class Connection {
   /** Round Trip Time Measurer */
   RTTM rttm;
 
+  /** Function from where to retrieve
+   * the current recv window size for this connection */
+  Recv_window_getter recv_wnd_getter;
+
   /** Callbacks */
   ConnectCallback         on_connect_;
   DisconnectCallback      on_disconnect_;

api/net/tcp/tcp.hpp

@@ -518,6 +518,15 @@ namespace net {
       return this->cpu_id;
     }
 
+    /**
+     * @brief      Return a value that's supposed to describe how much
+     *             a connection should announce as it's RCV WND,
+     *             with regards to the whole system.
+     *
+     * @return     A RCV WND value, maximum 1GB
+     */
+    static uint32_t global_recv_wnd();
+
   private:
     IPStack&      inet_;
     Listeners     listeners_;

src/net/tcp/connection.cpp

@@ -36,6 +36,7 @@ Connection::Connection(TCP& host, Socket local, Socket remote, ConnectCallback c
     cb{host_.window_size()},
     read_request(nullptr),
     writeq(),
+    recv_wnd_getter{TCP::global_recv_wnd},
     on_connect_{std::move(callback)},
     on_disconnect_({this, &Connection::default_on_disconnect}),
     rtx_timer({this, &Connection::rtx_timeout}),
@@ -323,7 +324,9 @@ Packet_view_ptr Connection::create_outgoing_packet()
   // Set Destination (remote)
   packet->set_destination(remote_);
 
-  packet->set_win(std::min((cb.RCV.WND >> cb.RCV.wind_shift), (uint32_t)default_window_size));
+  const auto recv_wnd = recv_wnd_getter();
+  //printf("recv_wnd %u\n", recv_wnd);
+  packet->set_win(cb.RCV.WND >> cb.RCV.wind_shift);
 
   if(cb.SND.TS_OK)
     packet->add_tcp_option_aligned<Option::opt_ts_align>(host_.get_ts_value(), cb.get_ts_recent());
@@ -683,6 +686,15 @@ void Connection::recv_data(const Packet_view& in)
 {
   Expects(in.has_tcp_data());
 
+  // just drop the packet if we don't have a recv wnd.
+  // this is really awful and probably unnecesseary,
+  // since it could be that we already preallocated that memory in our vector.
+  // i also think we shouldn't reach this point due to State::check_seq checking
+  // if we're inside the window. if packet is out of order tho we can change the RCV wnd (i think).
+  if(recv_wnd_getter() == 0)
+    drop(in, Drop_reason::RCV_WND_ZERO);
+
+
   // Keep track if a packet is being sent during the async read callback
   const auto snd_nxt = cb.SND.NXT;
 
@@ -719,6 +731,8 @@ void Connection::recv_data(const Packet_view& in)
       const auto recv = read_request->insert(in.seq(), in.tcp_data(), length, in.isset(PSH));
       // this ensures that the data we ACK is actually put in our buffer.
       Ensures(recv == length);
+      // adjust the rcv wnd to (maybe) new value
+      cb.RCV.WND = recv_wnd_getter();
     }
   }
   // Packet out of order

src/net/tcp/tcp.cpp

@@ -29,6 +29,7 @@
 #include <rtc> // nanos_now (get_ts_value)
 #include <net/tcp/packet4_view.hpp>
 #include <net/tcp/packet6_view.hpp>
+#include <kernel/os.hpp>
 
 using namespace std;
 using namespace net;
@@ -254,6 +255,8 @@ void TCP::receive(Packet_view& packet)
 
   // No open connection found, find listener for destination
   debug("<TCP::receive> No connection found - looking for listener..\n");
+  // TODO: Avoid creating a new connection if we're running out of memory.
+  // something like "mem avail" > (max_buffer_limit * 3) maybe
   auto listener_it = find_listener(dest);
 
   // Listener found => Create Listener
@@ -370,6 +373,15 @@ void TCP::reset_pmtu(Socket dest, IP4::PMTU pmtu) {
   }
 }
 
+uint32_t TCP::global_recv_wnd()
+{
+  // 80% of free mem
+  // normalize to 0 to avoid negative value (???)
+  ssize_t avail = std::max<ssize_t>((static_cast<ssize_t>(OS::heap_avail()) * 80 / 100) / 2, 0);
+  //printf("heap: %zi avail: %zu\n", (ssize_t)OS::heap_avail(), avail);
+  return std::min<size_t>(avail, (1 << 30)); // max can only be 1GB
+}
+
 void TCP::transmit(tcp::Packet_view_ptr packet)
 {
   // Generate checksum.