feat(gpapi): recover from WebKit GBM buffer failures

This commit is contained in:
Kevin Yue committed 2026-11-18 15:03:58 +08:00
1 parent ab3908b809
commit 65fce7bcf0
8 files changed
+271 -53

No files matched your search

+3 -1
View File
@@ -64,8 +64,10 @@ oslog = { version = "0.2", default-features = false, optional = true }
[target.'cfg(not(any(target_os="macos", target_os="windows")))'.dependencies] [target.'cfg(not(any(target_os="macos", target_os="windows")))'.dependencies]
gtk = { version = "0.18", optional = true } gtk = { version = "0.18", optional = true }
[target.'cfg(target_os="linux")'.dependencies] [target.'cfg(any(target_os="linux", target_os="freebsd", target_os="openbsd"))'.dependencies]
directories = { workspace = true, optional = true } directories = { workspace = true, optional = true }
[target.'cfg(target_os="linux")'.dependencies]
libloading = { version = "0.9", optional = true } libloading = { version = "0.9", optional = true }
[target.'cfg(target_os="macos")'.dependencies] [target.'cfg(target_os="macos")'.dependencies]
+40 -6
View File
@@ -70,17 +70,17 @@ impl GuiVariant {
} }
} }
#[cfg(target_os = "linux")] #[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
fn preference_path() -> anyhow::Result<PathBuf> { fn preference_path(name: &str) -> anyhow::Result<PathBuf> {
let dirs = directories::ProjectDirs::from("com.yuezk", "GlobalProtect-openconnect", "gpclient") let dirs = directories::ProjectDirs::from("com.yuezk", "GlobalProtect-openconnect", "gpclient")
.ok_or_else(|| anyhow::anyhow!("Failed to locate GUI preference directory"))?; .ok_or_else(|| anyhow::anyhow!("Failed to locate GUI preference directory"))?;
Ok(dirs.config_dir().join("gui")) Ok(dirs.config_dir().join(name))
} }
pub fn preferred() -> anyhow::Result<GuiVariant> { pub fn preferred() -> anyhow::Result<GuiVariant> {
#[cfg(target_os = "linux")] #[cfg(target_os = "linux")]
{ {
match std::fs::read_to_string(preference_path()?) { match std::fs::read_to_string(preference_path("gui")?) {
Ok(value) => match value.trim() { Ok(value) => match value.trim() {
"gpgui" => Ok(GuiVariant::Tauri), "gpgui" => Ok(GuiVariant::Tauri),
"gpgui-nsh" => Ok(GuiVariant::Nsh), "gpgui-nsh" => Ok(GuiVariant::Nsh),
@@ -96,12 +96,46 @@ pub fn preferred() -> anyhow::Result<GuiVariant> {
#[cfg(target_os = "linux")] #[cfg(target_os = "linux")]
pub fn save_preference(variant: GuiVariant) -> anyhow::Result<()> { pub fn save_preference(variant: GuiVariant) -> anyhow::Result<()> {
save_launch_preference("gui", variant.binary_name())
}
pub const COMPATIBILITY_GRAPHICS_SUPPORTED: bool =
cfg!(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"));
pub const FORCE_SHARED_MEMORY: &str = "WEBKIT_DMABUF_RENDERER_FORCE_SHM";
const COMPATIBILITY_GRAPHICS: &str = "compatibility-graphics";
#[cfg(not(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd")))]
fn preference_path(_: &str) -> anyhow::Result<PathBuf> {
anyhow::bail!("Compatibility graphics is unavailable")
}
pub fn compatibility_graphics_enabled() -> bool {
COMPATIBILITY_GRAPHICS_SUPPORTED && preference_path(COMPATIBILITY_GRAPHICS).is_ok_and(|path| path.is_file())
}
pub fn set_compatibility_graphics(enabled: bool) -> anyhow::Result<()> {
anyhow::ensure!(
COMPATIBILITY_GRAPHICS_SUPPORTED,
"Compatibility graphics is unavailable"
);
if enabled {
return save_launch_preference(COMPATIBILITY_GRAPHICS, "enabled");
}
match std::fs::remove_file(preference_path(COMPATIBILITY_GRAPHICS)?) {
Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(()),
result => result.map_err(Into::into),
}
}
fn save_launch_preference(name: &str, value: &str) -> anyhow::Result<()> {
use std::io::Write; use std::io::Write;
let path = preference_path()?; let path = preference_path(name)?;
let directory = path.parent().unwrap(); let directory = path.parent().unwrap();
std::fs::create_dir_all(directory)?; std::fs::create_dir_all(directory)?;
let mut file = tempfile::NamedTempFile::new_in(directory)?; let mut file = tempfile::NamedTempFile::new_in(directory)?;
writeln!(file, "{}", variant.binary_name())?; writeln!(file, "{value}")?;
file.persist(path)?; file.persist(path)?;
Ok(()) Ok(())
} }
+67 -10
View File
@@ -17,7 +17,10 @@ use super::{
command_traits::CommandExt, command_traits::CommandExt,
}; };
use super::rendering_recovery::{RenderingCrash, StderrDiagnostic, eligible, is_crash_exit}; use super::rendering_recovery::{
AUTH_STDERR_PREFIX, GbmBufferFailure, RenderingCrash, StderrDiagnostic, allows_shared_memory_override, eligible,
is_crash_exit, is_gbm_diagnostic,
};
const MAX_AUTH_RESULT_BYTES: usize = 256 * 1024; const MAX_AUTH_RESULT_BYTES: usize = 256 * 1024;
@@ -53,6 +56,7 @@ pub struct SamlAuthLauncher<'a> {
verbose: Option<&'a str>, verbose: Option<&'a str>,
log_format: LogFormat, log_format: LogFormat,
dmabuf_disabled: bool, dmabuf_disabled: bool,
desktop_compatibility_graphics: bool,
} }
impl<'a> SamlAuthLauncher<'a> { impl<'a> SamlAuthLauncher<'a> {
@@ -85,9 +89,15 @@ impl<'a> SamlAuthLauncher<'a> {
verbose: None, verbose: None,
log_format: LogFormat::Text, log_format: LogFormat::Text,
dmabuf_disabled: false, dmabuf_disabled: false,
desktop_compatibility_graphics: false,
} }
} }
pub fn desktop_compatibility_graphics(mut self) -> Self {
self.desktop_compatibility_graphics = true;
self
}
pub fn dmabuf_disabled(mut self, disabled: bool) -> Self { pub fn dmabuf_disabled(mut self, disabled: bool) -> Self {
self.dmabuf_disabled = disabled; self.dmabuf_disabled = disabled;
self self
@@ -298,41 +308,68 @@ impl<'a> SamlAuthLauncher<'a> {
if embedded && bundled && self.dmabuf_disabled { if embedded && bundled && self.dmabuf_disabled {
command.env("WEBKIT_DISABLE_DMABUF_RENDERER", "1"); command.env("WEBKIT_DISABLE_DMABUF_RENDERER", "1");
} }
let desktop_webview = embedded && bundled && self.desktop_compatibility_graphics;
let can_use_shared_memory = desktop_webview && allows_shared_memory_override(&command, true);
let use_shared_memory = can_use_shared_memory && crate::gui::compatibility_graphics_enabled();
if use_shared_memory {
command.env(crate::gui::FORCE_SHARED_MEMORY, "1");
}
let detect_gbm_failure = can_use_shared_memory && !use_shared_memory;
let stdin = auth_stdin(self.browser); let stdin = auth_stdin(self.browser);
let cancellation = self.cancellation.clone(); let cancellation = self.cancellation.clone();
let output = tokio::task::spawn_blocking(move || { let output = tokio::task::spawn_blocking(move || {
#[cfg(feature = "logger")]
let stderr = crate::logger::diagnostic_writer();
#[cfg(not(feature = "logger"))]
let stderr: Box<dyn std::io::Write + Send> = Box::new(std::io::stderr());
let mut stderr = if desktop_webview {
Box::new(std::io::LineWriter::new(AuthStderr(stderr)))
} else {
stderr
};
let gbm_failed = std::cell::Cell::new(false);
let check = || { let check = || {
if cancellation.is_cancelled() { if cancellation.is_cancelled() {
Err(std::io::Error::new( Err(std::io::Error::new(
std::io::ErrorKind::Interrupted, std::io::ErrorKind::Interrupted,
"Authentication cancelled", "Authentication cancelled",
)) ))
} else if gbm_failed.get() {
Err(std::io::Error::other(GbmBufferFailure))
} else { } else {
Ok(()) Ok(())
} }
}; };
let mut diagnostic = StderrDiagnostic::default(); let mut diagnostic = StderrDiagnostic::default();
#[cfg(feature = "logger")]
let mut stderr = crate::logger::diagnostic_writer();
#[cfg(not(feature = "logger"))]
let mut stderr = std::io::stderr();
let output = run_observed( let output = run_observed(
command, command,
&check, &check,
Some(MAX_AUTH_RESULT_BYTES), Some(MAX_AUTH_RESULT_BYTES),
&mut |bytes| diagnostic.push(bytes), &mut |bytes| {
diagnostic.push(bytes);
gbm_failed.set(detect_gbm_failure && diagnostic.should_retry_gbm(can_recover));
},
&mut stderr, &mut stderr,
stdin, stdin,
)?; );
Ok::<_, std::io::Error>((output.output, diagnostic.matched())) std::io::Write::flush(&mut stderr)?;
if gbm_failed.get() && !cancellation.is_cancelled() {
return Err(GbmBufferFailure.into());
}
let output = output?;
Ok::<_, anyhow::Error>((output.output, diagnostic.matched()))
}) })
.await?; .await?;
let (output, rendering_diagnostic) = match output { let (output, rendering_diagnostic) = match output {
Ok(output) => output, Ok(output) => output,
Err(error) if error.kind() == std::io::ErrorKind::Interrupted => { Err(error)
if error
.downcast_ref::<std::io::Error>()
.is_some_and(|error| error.kind() == std::io::ErrorKind::Interrupted) =>
{
return Err(crate::auth::AuthenticationCancelled.into()); return Err(crate::auth::AuthenticationCancelled.into());
} }
Err(error) => return Err(error.into()), Err(error) => return Err(error),
}; };
if self.cancellation.is_cancelled() { if self.cancellation.is_cancelled() {
@@ -342,6 +379,26 @@ impl<'a> SamlAuthLauncher<'a> {
} }
} }
// Attribute GBM failures to gpauth before forwarding them to the desktop supervisor.
struct AuthStderr(Box<dyn std::io::Write + Send>);
impl std::io::Write for AuthStderr {
fn write(&mut self, bytes: &[u8]) -> std::io::Result<usize> {
for line in bytes.split_inclusive(|&byte| byte == b'\n') {
if is_gbm_diagnostic(line) {
self.0.write_all(&[AUTH_STDERR_PREFIX, line].concat())?;
} else {
self.0.write_all(line)?;
}
}
Ok(bytes.len())
}
fn flush(&mut self) -> std::io::Result<()> {
self.0.flush()
}
}
/// `gpauth --browser manual` reads the pasted `globalprotectcallback:` data from the user's terminal. /// `gpauth --browser manual` reads the pasted `globalprotectcallback:` data from the user's terminal.
fn auth_stdin(browser: Option<&str>) -> ChildInput<'static> { fn auth_stdin(browser: Option<&str>) -> ChildInput<'static> {
match browser { match browser {
+19 -3
View File
@@ -1,10 +1,14 @@
use super::{ use super::{
command_runner::{ChildInput, run_observed}, command_runner::{ChildInput, run_observed},
rendering_recovery::{RenderingCrash, StderrDiagnostic, eligible_with_inheritance, is_crash_exit}, rendering_recovery::{
GbmBufferFailure, RenderingCrash, StderrDiagnostic, allows_shared_memory_override, eligible_with_inheritance,
is_crash_exit,
},
}; };
use crate::service::transport::SessionCredential; use crate::service::transport::SessionCredential;
use anyhow::Context; use anyhow::Context;
use std::{ use std::{
cell::Cell,
collections::HashMap, collections::HashMap,
fs::OpenOptions, fs::OpenOptions,
path::PathBuf, path::PathBuf,
@@ -19,8 +23,10 @@ pub(super) async fn launch_desktop_child(
envs: Option<&HashMap<String, String>>, envs: Option<&HashMap<String, String>>,
credential: &SessionCredential, credential: &SessionCredential,
cancellation: &CancellationToken, cancellation: &CancellationToken,
detect_gbm_failure: bool,
) -> anyhow::Result<ExitStatus> { ) -> anyhow::Result<ExitStatus> {
let retry_eligible = eligible_with_inheritance(&command, envs.is_none()); let retry_eligible = eligible_with_inheritance(&command, envs.is_none());
let detect_gbm_failure = detect_gbm_failure && allows_shared_memory_override(&command, envs.is_none());
let log_file = match envs { let log_file = match envs {
Some(envs) => envs.get("GP_LOG_FILE").map(PathBuf::from), Some(envs) => envs.get("GP_LOG_FILE").map(PathBuf::from),
None => std::env::var_os("GP_LOG_FILE").map(PathBuf::from), None => std::env::var_os("GP_LOG_FILE").map(PathBuf::from),
@@ -38,12 +44,15 @@ pub(super) async fn launch_desktop_child(
let cancellation = cancellation.clone(); let cancellation = cancellation.clone();
tokio::task::spawn_blocking(move || { tokio::task::spawn_blocking(move || {
let gbm_failed = Cell::new(false);
let check = || { let check = || {
if cancellation.is_cancelled() { if cancellation.is_cancelled() {
Err(std::io::Error::new( Err(std::io::Error::new(
std::io::ErrorKind::Interrupted, std::io::ErrorKind::Interrupted,
"Desktop child launch cancelled", "Desktop child launch cancelled",
)) ))
} else if gbm_failed.get() {
Err(std::io::Error::other(GbmBufferFailure))
} else { } else {
Ok(()) Ok(())
} }
@@ -53,10 +62,17 @@ pub(super) async fn launch_desktop_child(
command, command,
&check, &check,
None, None,
&mut |bytes| diagnostic.push(bytes), &mut |bytes| {
diagnostic.push(bytes);
gbm_failed.set(detect_gbm_failure && diagnostic.should_retry_gbm(retry_eligible));
},
&mut sink, &mut sink,
ChildInput::Frame(&frame), ChildInput::Frame(&frame),
)?; );
if gbm_failed.get() && !cancellation.is_cancelled() {
return Err(GbmBufferFailure.into());
}
let observed = observed?;
let output = observed.output; let output = observed.output;
if is_crash_exit(output.status) && retry_eligible && diagnostic.matched() { if is_crash_exit(output.status) && retry_eligible && diagnostic.matched() {
return Err(RenderingCrash { status: output.status }.into()); return Err(RenderingCrash { status: output.status }.into());
+5 -1
View File
@@ -170,7 +170,11 @@ impl<'a> DesktopLauncher<'a> {
} }
match outcome { match outcome {
Err(error) if recovery.recover(&error) => { Err(error) if recovery.recover(&error) => {
warn!("{error}; restarting the desktop launch with DMABUF disabled and opaque windows"); if recovery.shared_memory() {
warn!("{error}; restarting the desktop launch with compatibility graphics");
} else {
warn!("{error}; restarting the desktop launch with DMABUF disabled and opaque windows");
}
expecting_renewal = true; expecting_renewal = true;
input.write_all(&[DESKTOP_RENDERING_RETRY]).await?; input.write_all(&[DESKTOP_RENDERING_RETRY]).await?;
} }
@@ -79,6 +79,7 @@ impl<'a> GuiHelperLauncher<'a> {
self.envs, self.envs,
self.credential, self.credential,
cancellation, cancellation,
false,
) )
.await?; .await?;
Ok(()) Ok(())
+46 -26
View File
@@ -101,6 +101,12 @@ impl<'a> GuiLauncher<'a> {
if let Some(envs) = &self.envs { if let Some(envs) = &self.envs {
cmd.env_clear().envs(envs); cmd.env_clear().envs(envs);
} }
if self.variant == crate::gui::GuiVariant::Tauri
&& crate::gui::compatibility_graphics_enabled()
&& super::rendering_recovery::allows_shared_memory_override(cmd.as_std(), self.envs.is_none())
{
cmd.env(crate::gui::FORCE_SHARED_MEMORY, "1");
}
cmd.arg("--service-credential-on-stdin"); cmd.arg("--service-credential-on-stdin");
if self.minimized { if self.minimized {
cmd.arg("--minimized"); cmd.arg("--minimized");
@@ -112,6 +118,7 @@ impl<'a> GuiLauncher<'a> {
self.envs.as_ref(), self.envs.as_ref(),
&self.credential, &self.credential,
cancellation, cancellation,
self.variant == crate::gui::GuiVariant::Tauri,
) )
.await .await
} }
@@ -207,32 +214,45 @@ impl<'a> GuiLauncher<'a> {
gui_switch::reply(&mut socket, Ok(GuiSwitchOutcome::DownloadRequired)).await?; gui_switch::reply(&mut socket, Ok(GuiSwitchOutcome::DownloadRequired)).await?;
return Ok(None); return Ok(None);
} }
service_input.write_all(&[DESKTOP_SWITCH_BEGIN]).await?; use super::rendering_recovery::{GbmBufferFailure, RecoveryState};
pending = true; let mut recovery = RecoveryState::default();
let credential = super::desktop_launcher::read_credential(service_output).await? let mut program = program;
.ok_or_else(|| anyhow::anyhow!("Service closed before issuing the switch credential"))?; let (mut child, start_result) = loop {
anyhow::ensure!(credential.product_version() == self.version, "Service product version mismatch"); service_input.write_all(&[DESKTOP_SWITCH_BEGIN]).await?;
let ready = gui_switch::SwitchListener::new()?; pending = true;
let mut envs = self.envs.clone().unwrap_or_else(|| std::env::vars().collect()); let credential = super::desktop_launcher::read_credential(service_output).await?
envs.insert(gui_switch::READY_ENV.into(), ready.path().to_string_lossy().into_owned()); .ok_or_else(|| anyhow::anyhow!("Service closed before issuing the switch credential"))?;
let launcher = Self::new(self.version, Arc::new(credential), variant) anyhow::ensure!(credential.product_version() == self.version, "Service product version mismatch");
.envs(envs) let ready = gui_switch::SwitchListener::new()?;
.minimized(false); let mut envs = self.envs.clone().unwrap_or_else(|| std::env::vars().collect());
let program = match program { envs.insert(gui_switch::READY_ENV.into(), ready.path().to_string_lossy().into_owned());
Some(program) => program, let launcher = Self::new(self.version, Arc::new(credential), variant)
None => launcher.resolve_program(cancellation, command.theme).await?, .envs(envs)
}; .minimized(false);
let mut child = launcher.start_owned(program, cancellation.child_token()); let executable = match &program {
let start_result = tokio::select! { Some(program) => program.clone(),
result = tokio::time::timeout(std::time::Duration::from_secs(30), ready.ready()) => { None => launcher.resolve_program(cancellation, command.theme).await?,
result.map_err(|_| anyhow::anyhow!("The selected GUI did not finish starting" )).and_then(|result| result) };
}, let mut child = launcher.start_owned(executable.clone(), cancellation.child_token());
outcome = &mut child.task => { let start_result = tokio::select! {
return match outcome? { result = tokio::time::timeout(std::time::Duration::from_secs(30), ready.ready()) => {
Ok(status) => Err(anyhow::anyhow!("The selected GUI exited during startup: {status}")), result.map_err(|_| anyhow::anyhow!("The selected GUI did not finish starting" )).and_then(|result| result)
Err(error) => Err(error), },
}; outcome = &mut child.task => {
} match outcome? {
Ok(status) => return Err(anyhow::anyhow!("The selected GUI exited during startup: {status}")),
Err(error) if error.is::<GbmBufferFailure>() && recovery.recover(&error) => {
log::warn!("{error}; restarting the selected GUI with compatibility graphics");
service_input.write_all(&[DESKTOP_SWITCH_CANCEL]).await?;
pending = false;
program = Some(executable);
continue;
}
Err(error) => return Err(recovery.terminal(error)),
}
}
};
break (child, start_result);
}; };
if let Err(error) = start_result.and_then(|()| crate::gui::save_preference(variant)) { if let Err(error) = start_result.and_then(|()| crate::gui::save_preference(variant)) {
child.cancel.cancel(); child.cancel.cancel();
+90 -6
View File
@@ -1,6 +1,9 @@
use std::process::{Command, ExitStatus}; use std::process::{Command, ExitStatus};
const DMABUF: &str = "WEBKIT_DISABLE_DMABUF_RENDERER"; const DMABUF: &str = "WEBKIT_DISABLE_DMABUF_RENDERER";
pub const MAIN_WEBVIEW_INITIALIZED: &str = "GP Connect main webview initialized";
const GBM_DIAGNOSTIC: &[u8] = b"Failed to create GBM buffer";
pub(crate) const AUTH_STDERR_PREFIX: &[u8] = b"gpauth stderr: ";
const DIAGNOSTIC: &[u8] = b"Error 71 (Protocol error) dispatching to Wayland display"; const DIAGNOSTIC: &[u8] = b"Error 71 (Protocol error) dispatching to Wayland display";
#[derive(Debug, thiserror::Error)] #[derive(Debug, thiserror::Error)]
@@ -16,20 +19,33 @@ pub struct RecoveryFailed(#[source] anyhow::Error);
#[derive(Default)] #[derive(Default)]
pub struct RecoveryState { pub struct RecoveryState {
first_failure: Option<String>, first_failure: Option<String>,
shared_memory: bool,
} }
impl RecoveryState { impl RecoveryState {
pub fn dmabuf_disabled(&self) -> bool { pub fn dmabuf_disabled(&self) -> bool {
self.first_failure.is_some() self.first_failure.is_some() && !self.shared_memory
}
pub fn shared_memory(&self) -> bool {
self.shared_memory
} }
pub fn recover(&mut self, error: &anyhow::Error) -> bool { pub fn recover(&mut self, error: &anyhow::Error) -> bool {
if self.first_failure.is_none() && error.downcast_ref::<RenderingCrash>().is_some() { if self.first_failure.is_some() {
self.first_failure = Some(error.to_string()); return false;
true
} else {
false
} }
let gbm_failure = error.downcast_ref::<GbmBufferFailure>().is_some();
if !gbm_failure && error.downcast_ref::<RenderingCrash>().is_none() {
return false;
}
if gbm_failure && let Err(error) = crate::gui::set_compatibility_graphics(true) {
log::warn!("Could not save compatibility graphics setting: {error:#}");
return false;
}
self.first_failure = Some(error.to_string());
self.shared_memory = gbm_failure;
true
} }
pub fn terminal(&self, error: anyhow::Error) -> anyhow::Error { pub fn terminal(&self, error: anyhow::Error) -> anyhow::Error {
@@ -70,6 +86,16 @@ pub(crate) fn eligible_with_inheritance(command: &Command, inherits: bool) -> bo
&& effective_env(command, DMABUF, inherits).is_none() && effective_env(command, DMABUF, inherits).is_none()
} }
pub(crate) fn allows_shared_memory_override(command: &Command, inherits: bool) -> bool {
crate::gui::COMPATIBILITY_GRAPHICS_SUPPORTED
&& effective_env(command, DMABUF, inherits).is_none()
&& effective_env(command, crate::gui::FORCE_SHARED_MEMORY, inherits).is_none()
}
#[derive(Debug, thiserror::Error)]
#[error("WebKit failed to create a GBM buffer")]
pub(crate) struct GbmBufferFailure;
fn effective_env(command: &Command, key: &str, inherits: bool) -> Option<std::ffi::OsString> { fn effective_env(command: &Command, key: &str, inherits: bool) -> Option<std::ffi::OsString> {
for (name, value) in command.get_envs() { for (name, value) in command.get_envs() {
if name == key { if name == key {
@@ -79,12 +105,21 @@ fn effective_env(command: &Command, key: &str, inherits: bool) -> Option<std::ff
inherits.then(|| std::env::var_os(key)).flatten() inherits.then(|| std::env::var_os(key)).flatten()
} }
pub(crate) fn is_gbm_diagnostic(line: &[u8]) -> bool {
!line.starts_with(AUTH_STDERR_PREFIX)
&& line
.windows(GBM_DIAGNOSTIC.len())
.any(|message| message == GBM_DIAGNOSTIC)
}
/// Observes diagnostic lines without retaining arbitrary application output. /// Observes diagnostic lines without retaining arbitrary application output.
#[derive(Default)] #[derive(Default)]
pub(crate) struct StderrDiagnostic { pub(crate) struct StderrDiagnostic {
line: Vec<u8>, line: Vec<u8>,
overflow: bool, overflow: bool,
matched: bool, matched: bool,
gbm_failed: bool,
main_webview_initialized: bool,
} }
impl StderrDiagnostic { impl StderrDiagnostic {
@@ -104,6 +139,14 @@ impl StderrDiagnostic {
fn check_line(&mut self) { fn check_line(&mut self) {
let line = self.line.trim_ascii_end(); let line = self.line.trim_ascii_end();
if !self.overflow {
if line == MAIN_WEBVIEW_INITIALIZED.as_bytes() {
self.main_webview_initialized = true;
}
if !self.main_webview_initialized && is_gbm_diagnostic(line) {
self.gbm_failed = true;
}
}
let message = line.strip_suffix(b".").unwrap_or(line); let message = line.strip_suffix(b".").unwrap_or(line);
if !self.overflow if !self.overflow
&& (line.starts_with(b"Gdk-Message:") && (line.starts_with(b"Gdk-Message:")
@@ -117,6 +160,10 @@ impl StderrDiagnostic {
} }
} }
pub(crate) fn should_retry_gbm(&self, can_retry_wayland: bool) -> bool {
self.gbm_failed && !(can_retry_wayland && self.matched)
}
pub(crate) fn matched(&mut self) -> bool { pub(crate) fn matched(&mut self) -> bool {
self.check_line(); self.check_line();
self.matched self.matched
@@ -127,6 +174,43 @@ impl StderrDiagnostic {
mod tests { mod tests {
use super::*; use super::*;
#[test]
fn detects_gbm_failure_before_main_webview_initializes() {
for line in [
b"Failed to create GBM buffer of size 280x404: Invalid argument\n".as_slice(),
b"(WebKitWebProcess:42): Warning: Failed to create GBM buffer\n",
b"gpauth: Failed to create GBM buffer\n",
] {
let mut observer = StderrDiagnostic::default();
for bytes in line.chunks(7) {
observer.push(bytes);
}
assert!(observer.gbm_failed);
assert!(!observer.matched());
}
}
#[test]
fn ignores_gbm_failure_after_startup_and_from_auth_stderr() {
let mut observer = StderrDiagnostic::default();
observer
.push(b"gpauth stderr: (WebKitWebProcess:42): Failed to create GBM buffer of size 900x648: Invalid argument\n");
assert!(!observer.gbm_failed);
observer.push(format!("{MAIN_WEBVIEW_INITIALIZED}\n").as_bytes());
observer.push(b"Failed to create GBM buffer of size 840x640: Invalid argument\n");
assert!(!observer.gbm_failed);
}
#[test]
fn preserves_wayland_retry_when_both_diagnostics_are_observed() {
let mut observer = StderrDiagnostic::default();
observer.push(b"Failed to create GBM buffer of size 280x404: Invalid argument\n");
observer.push(b"Gdk-Message: Error 71 (Protocol error) dispatching to Wayland display.\n");
assert!(observer.matched());
assert!(!observer.should_retry_gbm(true));
assert!(observer.should_retry_gbm(false));
}
#[test] #[test]
fn recognizes_split_diagnostic_without_matching_quoted_warning() { fn recognizes_split_diagnostic_without_matching_quoted_warning() {
let mut observer = StderrDiagnostic::default(); let mut observer = StderrDiagnostic::default();