Implement PMTU_RAISE_TIMER for PMTUD re-probing

After PMTUD settles on a PLPMTU it never probes again, so a path that
later supports a larger MTU is never rediscovered. Arm a raise timer
(default 600s) once a PMTU is found and re-enter the Search Phase when
it expires, per RFC 8899 Section 5.1.1, reusing the existing optimistic
binary search.

The interval is configurable through Config, the C FFI, and tokio-quiche
settings; a zero duration disables re-probing and preserves the previous
settle-and-stop behavior.

Author: cf-rhett

quiche/include/quiche.h

@@ -177,6 +177,14 @@ void quiche_config_grease(quiche_config *config, bool v);
 // Configures whether to do path MTU discovery.
 void quiche_config_discover_pmtu(quiche_config *config, bool v);
 
+// Configures the maximum number of PMTUD probe attempts before treating a size
+// as failed.
+void quiche_config_set_pmtud_max_probes(quiche_config *config, uint8_t max_probes);
+
+// Configures how long PMTUD stays on a discovered PMTU before re-entering the
+// Search Phase, in milliseconds. Zero disables periodic re-probing.
+void quiche_config_set_pmtud_raise_timer(quiche_config *config, uint64_t millis);
+
 // Enables logging of secrets.
 void quiche_config_log_keys(quiche_config *config);
 

quiche/src/ffi.rs

@@ -222,6 +222,13 @@ pub extern "C" fn quiche_config_set_pmtud_max_probes(
     config.set_pmtud_max_probes(max_probes);
 }
 
+#[no_mangle]
+pub extern "C" fn quiche_config_set_pmtud_raise_timer(
+    config: &mut Config, millis: u64,
+) {
+    config.set_pmtud_raise_timer(Duration::from_millis(millis));
+}
+
 #[no_mangle]
 pub extern "C" fn quiche_config_log_keys(config: &mut Config) {
     config.log_keys();

quiche/src/lib.rs

@@ -579,6 +579,7 @@ pub struct Config {
 
     pmtud: bool,
     pmtud_max_probes: u8,
+    pmtud_raise_timer: Option<Duration>,
 
     hystart: bool,
 
@@ -660,6 +661,7 @@ impl Config {
             enable_send_streams_blocked: false,
             pmtud: false,
             pmtud_max_probes: pmtud::MAX_PROBES_DEFAULT,
+            pmtud_raise_timer: Some(pmtud::PMTU_RAISE_TIMER_DEFAULT),
             hystart: true,
             pacing: true,
             max_pacing_rate: None,
@@ -786,6 +788,16 @@ impl Config {
         self.pmtud_max_probes = max_probes;
     }
 
+    /// Configures how long PMTUD stays on a discovered PMTU before re-entering
+    /// the Search Phase to probe for a larger path MTU.
+    ///
+    /// Defaults to 600s per [RFC 8899 Section 5.1.1](https://datatracker.ietf.org/doc/html/rfc8899#section-5.1.1).
+    /// A duration of zero disables periodic re-probing, so PMTUD stops once a
+    /// PMTU is found.
+    pub fn set_pmtud_raise_timer(&mut self, raise_timer: Duration) {
+        self.pmtud_raise_timer = (!raise_timer.is_zero()).then_some(raise_timer);
+    }
+
     /// Configures whether to send GREASE values.
     ///
     /// The default value is `true`.
@@ -1356,6 +1368,11 @@ where
     /// The configuration for recovery.
     recovery_config: recovery::RecoveryConfig,
 
+    /// Period on the discovered PMTU before re-entering the Search Phase,
+    /// applied to paths that enable PMTUD during the handshake. [`None`]
+    /// disables periodic re-probing.
+    pmtud_raise_timer: Option<Duration>,
+
     /// The path manager.
     paths: path::PathMap,
 
@@ -2080,6 +2097,8 @@ impl<F: BufFactory> Connection<F> {
 
             recovery_config,
 
+            pmtud_raise_timer: config.pmtud_raise_timer,
+
             paths,
             path_challenge_recv_max_queue_len: config
                 .path_challenge_recv_max_queue_len,
@@ -2683,7 +2702,10 @@ impl<F: BufFactory> Connection<F> {
     ) -> Result<()> {
         let ex_data = tls::ExData::from_ssl_ref(ssl).ok_or(Error::TlsFail)?;
 
-        ex_data.pmtud = Some((discover, max_probes));
+        ex_data.pmtud = Some(pmtud::PmtudParams {
+            enable: discover,
+            max_probes,
+        });
 
         Ok(())
     }
@@ -3538,7 +3560,7 @@ impl<F: BufFactory> Connection<F> {
                             // Ensure the probe is within the supported MTU range
                             // before updating the max datagram size
                             if let Some(current_mtu) =
-                                pmtud.successful_probe(mtu_probe)
+                                pmtud.successful_probe(mtu_probe, now)
                             {
                                 qlog_with_type!(
                                     EventType::QuicEventType(
@@ -4295,7 +4317,7 @@ impl<F: BufFactory> Connection<F> {
                         if let Some(failed_probe) = mtu_probe {
                             if let Some(pmtud) = p.pmtud.as_mut() {
                                 trace!("pmtud probe dropped: {failed_probe}");
-                                pmtud.failed_probe(failed_probe);
+                                pmtud.failed_probe(failed_probe, now);
                             }
                         }
                     },
@@ -7009,12 +7031,23 @@ impl<F: BufFactory> Connection<F> {
                 .filter_map(|(_, p)| p.recovery.loss_detection_timer())
                 .min();
 
+            let pmtud_raise_timer = self
+                .paths
+                .iter()
+                .filter_map(|(_, p)| p.pmtud.as_ref()?.raise_timer())
+                .min();
+
             let key_update_timer = self.crypto_ctx[packet::Epoch::Application]
                 .key_update
                 .as_ref()
                 .map(|key_update| key_update.timer);
 
-            let timers = [self.idle_timer, path_timer, key_update_timer];
+            let timers = [
+                self.idle_timer,
+                path_timer,
+                pmtud_raise_timer,
+                key_update_timer,
+            ];
 
             timers.iter().filter_map(|&x| x).min()
         }
@@ -7105,6 +7138,10 @@ impl<F: BufFactory> Connection<F> {
                     });
                 }
             }
+
+            if let Some(pmtud) = p.pmtud.as_mut() {
+                pmtud.on_raise_timeout(now);
+            }
         }
 
         // Notify timeout events to the application.
@@ -8034,11 +8071,11 @@ impl<F: BufFactory> Connection<F> {
                         self.tx_cap_factor = ex_data.tx_cap_factor;
                     }
 
-                    if let Some((discover, max_probes)) = ex_data.pmtud {
+                    if let Some(params) = ex_data.pmtud {
                         self.paths.set_discover_pmtu_on_existing_paths(
-                            discover,
+                            params,
+                            self.pmtud_raise_timer,
                             self.recovery_config.max_send_udp_payload_size,
-                            max_probes,
                         );
                     }
 

quiche/src/path.rs

@@ -251,7 +251,11 @@ impl Path {
                         .unwrap_or(c.max_send_udp_payload_size),
                     c.max_send_udp_payload_size,
                 );
-                Some(pmtud::Pmtud::new(maximum_supported_mtu, c.pmtud_max_probes))
+                Some(pmtud::Pmtud::new(
+                    maximum_supported_mtu,
+                    c.pmtud_max_probes,
+                    c.pmtud_raise_timer,
+                ))
             } else {
                 None
             }
@@ -907,14 +911,15 @@ impl PathMap {
 
     /// Configures path MTU discovery on all existing paths.
     pub fn set_discover_pmtu_on_existing_paths(
-        &mut self, discover: bool, max_send_udp_payload_size: usize,
-        pmtud_max_probes: u8,
+        &mut self, params: pmtud::PmtudParams, raise_interval: Option<Duration>,
+        max_send_udp_payload_size: usize,
     ) {
         for (_, path) in self.paths.iter_mut() {
-            path.pmtud = if discover {
+            path.pmtud = if params.enable {
                 Some(pmtud::Pmtud::new(
                     max_send_udp_payload_size,
-                    pmtud_max_probes,
+                    params.max_probes,
+                    raise_interval,
                 ))
             } else {
                 None