Fix QNS?

larseggert · larseggert · commit 65cdb2372d48 · 2025-03-28T08:58:59.000+02:00
diff --git a/neqo-bin/src/client/mod.rs b/neqo-bin/src/client/mod.rs
@@ -472,9 +472,9 @@ impl<'a, H: Handler> Runner<'a, H> {
         let mut send = false; // Should we send on the next loop interation?
         let mut maybe_gso_failed = false;
 
-        loop {
+        'outer: loop {
             if (send || exit) && !batch_data.is_empty() {
-                let meta = batch_meta.take().unwrap();
+                let meta = batch_meta.clone().unwrap();
                 // Send all collected datagrams as GSO-sized chunks.
                 for gso_chunk in batch_data.chunks(self.socket.max_gso_segments() * meta.len()) {
                     // Optimistically attempt sending datagram. In case the OS
@@ -492,9 +492,10 @@ impl<'a, H: Handler> Runner<'a, H> {
                                 if !maybe_gso_failed && self.socket.max_gso_segments() == 1 {
                                     // Retry this once.
                                     maybe_gso_failed = true;
-                                } else {
-                                    return e;
+                                    qdebug!("GSO failed, retrying without");
+                                    continue 'outer;
                                 }
+                                return e;
                             }
                         }
                     }
@@ -507,6 +508,7 @@ impl<'a, H: Handler> Runner<'a, H> {
                     batch_meta = Some(next.into());
                 } else {
                     batch_data.clear();
+                    batch_meta = None;
                     send = false;
                 }
             }
diff --git a/neqo-bin/src/server/mod.rs b/neqo-bin/src/server/mod.rs
@@ -258,9 +258,9 @@ impl ServerRunner {
         let mut send = false; // Should we send on the next loop interation?
         let mut maybe_gso_failed = false;
 
-        loop {
+        'outer: loop {
             if (send || exit) && !batch_data.is_empty() {
-                let meta = batch_meta.take().unwrap();
+                let meta = batch_meta.clone().unwrap();
                 // Send all collected datagrams as GSO-sized chunks.
                 let socket = Self::find_socket(sockets, meta.source());
                 for gso_chunk in batch_data.chunks(socket.max_gso_segments() * meta.len()) {
@@ -279,9 +279,10 @@ impl ServerRunner {
                                 if !maybe_gso_failed && socket.max_gso_segments() == 1 {
                                     // Retry this once.
                                     maybe_gso_failed = true;
-                                } else {
-                                    return e;
+                                    qdebug!("GSO failed, retrying without");
+                                    continue 'outer;
                                 }
+                                return e;
                             }
                         }
                     }
@@ -294,6 +295,7 @@ impl ServerRunner {
                     batch_meta = Some(next.into());
                 } else {
                     batch_data.clear();
+                    batch_meta = None;
                     send = false;
                 }
             }

Original file line number	Diff line number	Diff line change
`@@ -472,9 +472,9 @@ impl<'a, H: Handler> Runner<'a, H> {`
`472`	`472`	`let mut send = false; // Should we send on the next loop interation?`
`473`	`473`	`let mut maybe_gso_failed = false;`
`474`	`474`
`475`		`- loop {`
	`475`	`+ 'outer: loop {`
`476`	`476`	`if (send \|\| exit) && !batch_data.is_empty() {`
`477`		`- let meta = batch_meta.take().unwrap();`
	`477`	`+ let meta = batch_meta.clone().unwrap();`
`478`	`478`	`// Send all collected datagrams as GSO-sized chunks.`
`479`	`479`	`for gso_chunk in batch_data.chunks(self.socket.max_gso_segments() * meta.len()) {`
`480`	`480`	`// Optimistically attempt sending datagram. In case the OS`
`@@ -492,9 +492,10 @@ impl<'a, H: Handler> Runner<'a, H> {`
`492`	`492`	`if !maybe_gso_failed && self.socket.max_gso_segments() == 1 {`
`493`	`493`	`// Retry this once.`
`494`	`494`	`maybe_gso_failed = true;`
`495`		`- } else {`
`496`		`- return e;`
	`495`	`+ qdebug!("GSO failed, retrying without");`
	`496`	`+ continue 'outer;`
`497`	`497`	`}`
	`498`	`+ return e;`
`498`	`499`	`}`
`499`	`500`	`}`
`500`	`501`	`}`
`@@ -507,6 +508,7 @@ impl<'a, H: Handler> Runner<'a, H> {`
`507`	`508`	`batch_meta = Some(next.into());`
`508`	`509`	`} else {`
`509`	`510`	`batch_data.clear();`
	`511`	`+ batch_meta = None;`
`510`	`512`	`send = false;`
`511`	`513`	`}`
`512`	`514`	`}`
Original file line number	Diff line number	Diff line change
`@@ -258,9 +258,9 @@ impl ServerRunner {`
`258`	`258`	`let mut send = false; // Should we send on the next loop interation?`
`259`	`259`	`let mut maybe_gso_failed = false;`
`260`	`260`
`261`		`- loop {`
	`261`	`+ 'outer: loop {`
`262`	`262`	`if (send \|\| exit) && !batch_data.is_empty() {`
`263`		`- let meta = batch_meta.take().unwrap();`
	`263`	`+ let meta = batch_meta.clone().unwrap();`
`264`	`264`	`// Send all collected datagrams as GSO-sized chunks.`
`265`	`265`	`let socket = Self::find_socket(sockets, meta.source());`
`266`	`266`	`for gso_chunk in batch_data.chunks(socket.max_gso_segments() * meta.len()) {`
`@@ -279,9 +279,10 @@ impl ServerRunner {`
`279`	`279`	`if !maybe_gso_failed && socket.max_gso_segments() == 1 {`
`280`	`280`	`// Retry this once.`
`281`	`281`	`maybe_gso_failed = true;`
`282`		`- } else {`
`283`		`- return e;`
	`282`	`+ qdebug!("GSO failed, retrying without");`
	`283`	`+ continue 'outer;`
`284`	`284`	`}`
	`285`	`+ return e;`
`285`	`286`	`}`
`286`	`287`	`}`
`287`	`288`	`}`
`@@ -294,6 +295,7 @@ impl ServerRunner {`
`294`	`295`	`batch_meta = Some(next.into());`
`295`	`296`	`} else {`
`296`	`297`	`batch_data.clear();`
	`298`	`+ batch_meta = None;`
`297`	`299`	`send = false;`
`298`	`300`	`}`
`299`	`301`	`}`