TCP Socket Listen: Accept Queue [ESTABLISHED CONNECTIONS]

[Abishekcs]

Issue (Rage): rage-rb/rage#379

What this PR does ?

Adds a way to check how many connections are currently waiting in a listening socket's accept queue, by port number, on Linux.

When a client connects, the kernel completes the TCP handshake before the app gets involved, and the holds the finished connection in the accept queue until the app calls accept(). This queue has a fixed max size, the backlog, bounded by somaxconn, and if it fills up, new connections get dropped from the SYN Queue or reset before the app ever sees them. Checking its depth is a useful health signal, if it stays near the limit, the app isn't accepting fast enough.

fio_accept_queue_backlog_port(port) queries the kernel directly, matching by port instead of requiring a facil.io connection handle. It checks both IPv4 and IPv6m and sums the depths if more than one listening socket shares the port. A Ruby binding, Iodine.accept_quque_backlog(port), is included.

Refrences

• https://veithen.io/2014/01/01/how-tcp-backlog-works-in-linux.html
• https://krisnova.net/posts/linux-accept-queues/
• https://arthurchiao.art/blog/tcp-listen-a-tale-of-two-queues/

Testing

• I tried using this on codebase using rage (this implementation was just for testing).

test.mp4

• An also tried with a simple code which only uses Iodine and creates a simple TCP connection

require "iodine"
require "socket"

Iodine.workers = 1

Iodine.on_state(:on_start) do
  # 1. a plain TCPServer with 5 queued connections — no iodine involvement
  ts = TCPServer.new("127.0.0.1", 0)
  ts_port = ts.addr[1]
  socks = 5.times.map { TCPSocket.new("127.0.0.1", ts_port) }
  sleep 0.2
  p [:tcpserver_queued, Iodine.accept_queue_backlog(ts_port)]
  socks.each(&:close)
  ts.close

  # 2. iodine's own idle listener
  p [:iodine_idle, Iodine.accept_queue_backlog(3000)]

  # 3. no listener anywhere on a free port
  p [:nothing_listening, Iodine.accept_queue_backlog(45678)]

  # 4. two SO_REUSEPORT listeners on one port → depths should SUM
  def listener(port)
    s = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM)
    s.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1)
    s.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEPORT, 1)
    s.bind(Socket.sockaddr_in(port, "127.0.0.1"))
    s.listen(128)
    s
  end
  s1 = listener(0)
  sp = s1.local_address.ip_port
  s2 = listener(sp)
  c1 = 3.times.map { TCPSocket.new("127.0.0.1", sp) }
  c2 = 2.times.map { TCPSocket.new("127.0.0.1", sp) }
  sleep 0.2
  p [:reuseport_sum, Iodine.accept_queue_backlog(sp)]
  (c1 + c2).each(&:close)
  s1.close
  s2.close

  Iodine.run { Iodine.stop }
end

Iodine.listen(:port => 3000, :handler => Proc.new { [200, {}, ["ok"]] })
Iodine.start

[Abishekcs]

@rsamoilov PR is ready for review. Please review it whenever you are free. Thank you!