TCP server - socket file descriptor is corrupted when the GC is used #18263

Activity

1. ghostiam

   added

   BugThis tag is applied to issues which reports bugs.This tag is applied to issues which reports bugs.

   on May 25, 2023
2. ghostiam commented on May 25, 2023

   

   ghostiam

   on May 25, 2023

   Last edited by ghostiam

   Author

   More actions

   Did a little research:

   • If remove spawn then there will be no corruption.
   • if remove the calls to read() and write(), leave only close(), then file descriptor corruption will still occur.
   • Explored the generated C code, removed the call to free() in the function generator (with compiler rebuild) main__handle_connection_thread_wrapper , but nothing changed.

   I think the GC can't keep track of what is being launched via pthread...

   Old updates

   UPD:
   If replace memdup in the generated C code with memdup_uncollectable in the return method accept_only(), then the error disappears (but, yes, a memory leak is expected).

   _result_net__TcpConn_ptr net__TcpListener_accept_only(net__TcpListener* l) {
   ...
   	}
   	_result_net__TcpConn_ptr _t4;
   -	_result_ok(&(net__TcpConn*[]) { ((net__TcpConn*)memdup(&(net__TcpConn){.sock = (net__TcpSocket){.Socket = (net__Socket){.handle = 0,},},.handle = new_handle,.write_deadline = (time__Time){.year = 0,.month = 0,.day = 0,.hour = 0,.minute = 0,.second = 0,.microsecond = 0,._v_unix = 0,.is_local = 0,},.read_deadline = (time__Time){.year = 0,.month = 0,.day = 0,.hour = 0,.minute = 0,.second = 0,.microsecond = 0,._v_unix = 0,.is_local = 0,},.read_timeout = _const_net__tcp_default_read_timeout,.write_timeout = _const_net__tcp_default_write_timeout,.is_blocking = 0,}, sizeof(net__TcpConn))) }, (_result*)(&_t4), sizeof(net__TcpConn*));
   +	_result_ok(&(net__TcpConn*[]) { ((net__TcpConn*)memdup_uncollectable(&(net__TcpConn){.sock = (net__TcpSocket){.Socket = (net__Socket){.handle = 0,},},.handle = new_handle,.write_deadline = (time__Time){.year = 0,.month = 0,.day = 0,.hour = 0,.minute = 0,.second = 0,.microsecond = 0,._v_unix = 0,.is_local = 0,},.read_deadline = (time__Time){.year = 0,.month = 0,.day = 0,.hour = 0,.minute = 0,.second = 0,.microsecond = 0,._v_unix = 0,.is_local = 0,},.read_timeout = _const_net__tcp_default_read_timeout,.write_timeout = _const_net__tcp_default_write_timeout,.is_blocking = 0,}, sizeof(net__TcpConn))) }, (_result*)(&_t4), sizeof(net__TcpConn*));
   	return _t4;
   }

   UPD2: In UPD3 the way is easier.

   I was able to solve the problem by corrupting the FD with only `V` (but yes, there was a memory leak). To do this, I had to remove `mut` from all `TcpConn` methods and replace

   pub fn (mut l TcpListener) accept() !&TcpConn {
pub fn (mut l TcpListener) accept_only() !&TcpConn {
fn (mut s TcpSocket) close() ! {

   with

   pub fn (mut l TcpListener) accept() !TcpConn {
pub fn (mut l TcpListener) accept_only() !TcpConn {
fn (s TcpSocket) close() ! {

   UPD3:
   It turned out that it is possible to solve the problem easier and with less memory leak.

   Apparently, it is impossible to transfer reference to the coroutine, the GC is clearly not ready for it.

   Diffs

   /vlib/net/tcp.v 
   
   98c98
   < pub fn (mut c TcpConn) close() ! {
   ---
   > pub fn ( c TcpConn) close() ! {
   156c156
   < pub fn (mut c TcpConn) write_ptr(b &u8, len int) !int {
   ---
   > pub fn ( c TcpConn) write_ptr(b &u8, len int) !int {
   201c201
   < pub fn (mut c TcpConn) write_string(s string) !int {
   ---
   > pub fn ( c TcpConn) write_string(s string) !int {
   280c280
   < pub mut:
   ---
   >       pub mut:
   282c282
   < mut:
   ---
   >       mut:
   485c485
   < fn (mut s TcpSocket) close() ! {
   ---
   > fn ( s TcpSocket) close() ! {

   main.v
   -		spawn handle_connection(mut conn, timeout, count)
   +		spawn handle_connection(conn, timeout, count)
   
   - fn handle_connection(mut conn net.TcpConn, timeout time.Duration, count int) {
   + fn handle_connection(conn net.TcpConn, timeout time.Duration, count int) {

   UPD 4:
   And an even easier way... Wrap conn in a structure...

   pub struct Test {
   mut:
   	conn net.TcpConn
   }

   We get a memory leak, but got rid of the corrupting to the FD.

   I made a mistake, there is no memory leak, it's because of my experiments that I forgot to roll back the compiler with my breaking changes.
   That is, wrapping TcpConn in a struct solves the problem without any disadvantages.

   Full code

   module main
   
   import net
   import time
   
   fn main() {
   	serve('127.0.0.1:1080', 5 * time.second)!
   }
   
   pub struct Test {
   mut:
   	conn net.TcpConn
   }
   
   fn serve(addr string, timeout time.Duration) ! {
   	mut l := net.listen_tcp(.ip, addr) or { return error('Listening on ${addr}: ${err}') }
   	// l.set_accept_timeout(timeout)
   
   	eprintln('Listening on ${addr}')
   
   	mut count := 0
   	for {
   		mut conn := l.accept() or {
   			if err.code() == net.err_timed_out_code {
   				// just skip network timeouts, they are normal
   				continue
   			}
   			eprintln('error: accept(), reason: ${err}; skipping')
   			continue
   		}
   
   		count += 1
   		eprintln('${count} ${conn.sock.handle}(${conn.sock.handle}) accept()')
   
   		// eprintln('${count} Connected from ${conn.peer_addr()!}')
   
   		// spawn handle_connection(mut conn, timeout, count)
   		spawn handle_connection(Test{conn}, timeout, count)
   	}
   }
   
   // fn handle_connection(mut conn net.TcpConn, timeout time.Duration, count int) {
   fn handle_connection(c Test, timeout time.Duration, count int) {
   	mut conn := c.conn
   
   	handle_store := conn.sock.handle
   
   	time.sleep(1 * time.millisecond)
   
   	defer {
   		// eprintln('${count} Disconnecting from ${conn.peer_addr() or { net.Addr{} }}')
   
   		eprintln('${count} ${conn.sock.handle}(${handle_store}) close()')
   
   		conn.close() or {
   			eprintln('${count} ${conn.sock.handle}(${handle_store}) error: close(): ${err}')
   		}
   
   		// eprintln('${count} Disconnected')
   	}
   
   	conn.set_read_timeout(timeout)
   	conn.set_write_timeout(timeout)
   
   	mut buffer := []u8{len: 512}
   	defer {
   		unsafe {
   			buffer.free()
   		}
   	}
   
   	eprintln('${count} ${conn.sock.handle}(${handle_store}) read()')
   
   	l := conn.read(mut buffer) or {
   		eprintln('${count} ${conn.sock.handle}(${handle_store})  error: read(): ${err}')
   		return
   	}
   
   	// eprintln('Read from ${conn.peer_addr() or {}}, length: ${l}')
   	// eprintln(buffer[..l].bytestr())
   
   	eprintln('${count} ${conn.sock.handle}(${handle_store}) write()')
   
   	resp := 'Test OK'
   	conn.write_string('HTTP/1.0 200 OK\r\nContent-Length: ${resp.len}\r\n\r\n${resp}\r\n') or {
   		eprintln('${count} ${conn.sock.handle}(${handle_store})  error: write(): ${err}')
   		return
   	}
   }

   UPD5:
   upd:And as it turns out, the most significant difference is in how I pass TcpConn...

   No bug

   pub struct Test {
   mut:
       conn net.TcpConn
   }

   Has bug

   pub struct Test {
   mut:
       conn &net.TcpConn
   }

   The difference in C code is how the data is passed to the function.
   mut conn := c.conn

   No bug:
   conn = HEAP(net__TcpConn, (c->conn));
   +
   handle_store = (*(conn)).sock.Socket.handle;

   Has bug
   conn = c->conn;
   or
   conn = &c->conn;
   +
   handle_store = conn->sock.Socket.handle;

   UPD6:
   The easiest fix? But once I caught file descriptor corruption even with this fix...

   		count += 1
   		eprintln('${count} ${conn.sock.handle}(${conn.sock.handle}) accept()')
   
   		// eprintln('${count} Connected from ${conn.peer_addr()!}')
   
   -		spawn handle_connection(mut conn, timeout, count)
   +		spawn handle_connection(conn, timeout, count)
   
   -fn handle_connection(conn net.TcpConn, timeout time.Duration, count int) {
   +fn handle_connection(c net.TcpConn, timeout time.Duration, count int) {
   +	mut conn := c
   
   	handle_store := conn.sock.handle
3. kbkpbot commented on Jun 6, 2023

   

   kbkpbot

   on Jun 6, 2023

   Contributor

   More actions

   It seems there are some bug in the thread usage.
   I create a more simpler test case :

   module main
   
   import time
   
   struct Socket {
           conn int
   }
   
   fn thread_fn(t &Socket) {
           t1 := t.conn
           time.sleep(10)
           t2 := t.conn
           if t1 != t2 {
                   println('Error! t.conn=${t.conn} t1=${t1} t2=${t2}')
           }
   }
   
   fn main() {
           mut conn := 1
           for {
                   xx := Socket{ conn: conn++ }
                   spawn thread_fn(&xx)
                   time.sleep(10)
           }
   }

   It will produce a lot of error messages.

   🚀React with 🚀1Reacted by Vladislav Fursov
4. pithing commented on Jul 12, 2023

   

   pithing

   on Jul 12, 2023

   More actions

   change:

           xx := &Socket{ conn: conn++ }
           spawn thread_fn(xx)
   

   It seems to be a bug derived from a function reference passed before.
5. medvednikov

   added 2 commits that reference this issue on Apr 15, 2026

   tcp server - socket file descriptor is corrupted when the gc... (fixes …

   ...

   This issue will close once commit 5244be9 is merged into the 'master' branch.

   5244be9

   tcp server - socket file descriptor is corrupted when the gc... (fixes …

   ...

   This issue will close once commit c7327d4 is merged into the 'master' branch.

   c7327d4
6. medvednikov

   closed this as completedin fc6d5cdon Apr 17, 2026
7. pull

   added a commit that references this issue on Apr 17, 2026

   checker: fix TCP server socket file descriptor corruption when using …

   ...

   This issue will close once commit fc6d5cd is merged into the 'master' branch.

   fc6d5cd