leyoda/cosmic-comp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

chore: update smithay + switch to tracing

Browse source
This commit is contained in:
Victoria Brekenfeld 2023-02-24 17:41:52 +01:00
parent 844ed552b9
commit 35de500c00
35 changed files with 622 additions and 754 deletions
Download patch file Download diff file Expand all files Collapse all files

596
Cargo.lock generated
View file

File diff suppressed because it is too large Load diff

23
Cargo.toml
View file

@ -10,13 +10,6 @@ anyhow = { version = "1.0.51", features = ["backtrace"] }
bitflags = "1.3.2"
bytemuck = "1.12"
calloop = { version = "0.10.1", features = ["executor"] }
slog = { version = "2.7", features = ["release_max_level_info", "max_level_debug"] }#, features = [ "release_max_level_debug", "max_level_trace"] }
slog-term = "2.8"
slog-async = "2.7"
slog-journald = "2.2.0"
slog-scope = "4.4"
slog-stdlog = "4.1"
log = "0.4"
serde = { version = "1", features = ["derive"] }
serde_json = "1"
sendfd = "0.4.1"
@ -41,23 +34,27 @@ cosmic-protocols = { git = "https://github.com/pop-os/cosmic-protocols", branch
libcosmic = { git = "https://github.com/pop-os/libcosmic", rev = "abf8fc96c", default-features = false, features = ["softbuffer"] }
iced_softbuffer = { git = "https://github.com/pop-os/libcosmic", rev = "abf8fc96c" }
ordered-float = "3.0"
glow = "0.11.2"
tracing-subscriber = { version = "0.3.16", features = ["env-filter", "tracing-log"] }
tracing-journald = "0.3.0"
tracing = "0.1.37"
[dependencies.smithay]
version = "0.3"
git = "https://github.com/Smithay/smithay.git"
rev = "2de946cf9e"
git = "https://github.com/smithay/smithay.git"
branch = "30dc3abb57"
default-features = false
features = ["backend_drm", "backend_gbm", "backend_egl", "backend_libinput", "backend_session_libseat", "backend_udev", "backend_winit", "backend_vulkan", "backend_x11", "desktop", "use_system_lib", "renderer_glow", "renderer_multi", "wayland_frontend", "slog-stdlog", "xwayland"]
features = ["backend_drm", "backend_gbm", "backend_egl", "backend_libinput", "backend_session_libseat", "backend_udev", "backend_winit", "backend_vulkan", "backend_x11", "desktop", "use_system_lib", "renderer_glow", "renderer_multi", "wayland_frontend", "xwayland"]
[dependencies.smithay-egui]
git = "https://github.com/Smithay/smithay-egui.git"
rev = "610a7dbf80"
rev = "1145f5ff91"
features = ["svg"]
optional = true
[features]
default = []
debug = ["egui", "smithay-egui", "renderdoc"]
debug = ["egui", "smithay-egui", "renderdoc", "anyhow/backtrace"]
[profile.dev]
lto = "thin"
@ -70,4 +67,4 @@ debug = true
lto = "fat"
[patch."https://github.com/Smithay/smithay.git"]
smithay = { git = "https://github.com/smithay//smithay", rev = "09e29418e5" }
smithay = { git = "https://github.com/pop-os/smithay", rev = "6276454e856" }

125
src/backend/kms/mod.rs
View file

@ -55,6 +55,7 @@ use smithay::{
wayland::{dmabuf::DmabufGlobal, seat::WaylandFocus},
xwayland::XWaylandClientData,
};
use tracing::{debug, error, info, warn};
use std::{
cell::RefCell,
@ -112,15 +113,15 @@ pub fn init_backend(
event_loop: &mut EventLoop<'static, Data>,
state: &mut State,
) -> Result<()> {
let (session, notifier) = LibSeatSession::new(None).context("Failed to acquire session")?;
let (session, notifier) = LibSeatSession::new().context("Failed to acquire session")?;
let udev_backend = UdevBackend::new(session.seat(), None)?;
let udev_backend = UdevBackend::new(session.seat())?;
let mut libinput_context =
Libinput::new_with_udev::<LibinputSessionInterface<LibSeatSession>>(session.clone().into());
libinput_context
.udev_assign_seat(&session.seat())
.map_err(|_| anyhow::anyhow!("Failed to assign seat to libinput"))?;
let libinput_backend = LibinputInputBackend::new(libinput_context.clone(), None);
let libinput_backend = LibinputInputBackend::new(libinput_context.clone());
let libinput_event_source = event_loop
.handle()
@ -136,17 +137,17 @@ pub fn init_backend(
None,
None,
) {
slog_scope::crit!(
"Error scheduling event loop for output {}: {:?}",
error!(
?err,
"Error scheduling event loop for output {}.",
output.name(),
err
);
}
}
})
.map_err(|err| err.error)
.context("Failed to initialize libinput event source")?;
let api = GpuManager::new(GbmGlesBackend::<GlowRenderer>::default(), None)
let api = GpuManager::new(GbmGlesBackend::<GlowRenderer>::default())
.context("Failed to initialize renderers")?;
// TODO get this info from system76-power, if available and setup a watcher
@ -173,7 +174,7 @@ pub fn init_backend(
panic!("Failed to initialize any GPU");
})
};
slog_scope::info!("Using {} as primary gpu for rendering", primary);
info!("Using {} as primary gpu for rendering.", primary);
let udev_dispatcher = Dispatcher::new(udev_backend, move |event, _, data: &mut Data| {
match match event {
@ -191,10 +192,10 @@ pub fn init_backend(
.with_context(|| format!("Failed to remove drm device: {}", device_id)),
} {
Ok(()) => {
slog_scope::debug!("Successfully handled udev event")
debug!("Successfully handled udev event.")
}
Err(err) => {
slog_scope::error!("Error while handling udev event: {}", err)
error!(?err, "Error while handling udev event.")
}
}
});
@ -211,7 +212,7 @@ pub fn init_backend(
.insert_source(notifier, move |event, &mut (), data| match event {
SessionEvent::ActivateSession => {
if let Err(err) = libinput_context.resume() {
slog_scope::error!("Failed to resume libinput context: {:?}", err);
error!(?err, "Failed to resume libinput context.");
}
for device in data.state.backend.kms().devices.values() {
device.drm.as_source_ref().activate();
@ -222,21 +223,13 @@ pub fn init_backend(
let drm_node = match DrmNode::from_dev_id(dev) {
Ok(node) => node,
Err(err) => {
slog_scope::error!(
"Failed to read drm device {}: {}",
path.display(),
err
);
error!(?err, "Failed to read drm device {}.", path.display(),);
continue;
}
};
if data.state.backend.kms().devices.contains_key(&drm_node) {
if let Err(err) = data.state.device_changed(dev) {
slog_scope::error!(
"Failed to update drm device {}: {}",
path.display(),
err
);
error!(?err, "Failed to update drm device {}.", path.display(),);
}
} else {
if let Err(err) = data.state.device_added(
@ -245,11 +238,7 @@ pub fn init_backend(
&data.display.handle(),
true,
) {
slog_scope::error!(
"Failed to add drm device {}: {}",
path.display(),
err
);
error!(?err, "Failed to add drm device {}.", path.display(),);
}
}
}
@ -284,10 +273,10 @@ pub fn init_backend(
None
},
) {
slog_scope::crit!(
"Error scheduling event loop for output {}: {:?}",
error!(
?err,
"Error scheduling event loop for output {}.",
output.name(),
err
);
}
}
@ -352,27 +341,24 @@ impl State {
return Ok(());
}
let fd = DrmDeviceFd::new(
unsafe {
DeviceFd::from_raw_fd(
self.backend
.kms()
.session
.open(
&path,
OFlag::O_RDWR | OFlag::O_CLOEXEC | OFlag::O_NOCTTY | OFlag::O_NONBLOCK,
let fd = DrmDeviceFd::new(unsafe {
DeviceFd::from_raw_fd(
self.backend
.kms()
.session
.open(
&path,
OFlag::O_RDWR | OFlag::O_CLOEXEC | OFlag::O_NOCTTY | OFlag::O_NONBLOCK,
)
.with_context(|| {
format!(
"Failed to optain file descriptor for drm device: {}",
path.display()
)
.with_context(|| {
format!(
"Failed to optain file descriptor for drm device: {}",
path.display()
)
})?,
)
},
None,
);
let drm = DrmDevice::new(fd.clone(), false, None)
})?,
)
});
let drm = DrmDevice::new(fd.clone(), false)
.with_context(|| format!("Failed to initialize drm device for: {}", path.display()))?;
let drm_node = DrmNode::from_dev_id(dev)?;
let supports_atomic = drm.is_atomic();
@ -380,7 +366,7 @@ impl State {
let gbm = GbmDevice::new(fd)
.with_context(|| format!("Failed to initialize GBM device for {}", path.display()))?;
let (render_node, formats) = {
let egl_display = EGLDisplay::new(gbm.clone(), None).with_context(|| {
let egl_display = EGLDisplay::new(gbm.clone()).with_context(|| {
format!("Failed to create EGLDisplay for device: {}", path.display())
})?;
let egl_device = EGLDevice::device_for_display(&egl_display).with_context(|| {
@ -391,7 +377,7 @@ impl State {
.ok()
.and_then(std::convert::identity)
.unwrap_or(drm_node);
let egl_context = EGLContext::new(&egl_display, None).with_context(|| {
let egl_context = EGLContext::new(&egl_display).with_context(|| {
format!(
"Failed to create EGLContext for device {:?}:{}",
egl_device,
@ -458,7 +444,7 @@ impl State {
})
}
Some(Err(err)) => {
slog_scope::warn!("Failed to submit frame: {}", err);
warn!(?err, "Failed to submit frame.");
None
}
_ => None, // got disabled
@ -487,12 +473,12 @@ impl State {
Some(repaint_delay),
scheduled_sessions,
) {
slog_scope::warn!("Failed to schedule render: {}", err);
warn!(?err, "Failed to schedule render.");
}
}
}
DrmEvent::Error(err) => {
slog_scope::warn!("Failed to read events of device {:?}: {}", dev, err);
warn!(?err, "Failed to read events of device {:?}.", dev);
}
});
let token = self
@ -504,10 +490,9 @@ impl State {
let socket = match self.create_socket(dh, render_node, formats.clone().into_iter()) {
Ok(socket) => Some(socket),
Err(err) => {
slog_scope::warn!(
"Failed to initialize hardware-acceleration for clients on {}: {}",
render_node,
err
warn!(
?err,
"Failed to initialize hardware-acceleration for clients on {}.", render_node,
);
None
}
@ -548,7 +533,7 @@ impl State {
let mut renderer = match backend.api.single_renderer(&render_node) {
Ok(renderer) => renderer,
Err(err) => {
slog_scope::warn!("Failed to initialize output: {}", err);
warn!(?err, "Failed to initialize output.");
continue;
}
};
@ -563,7 +548,7 @@ impl State {
.w;
wl_outputs.push(output);
}
Err(err) => slog_scope::warn!("Failed to initialize output: {}", err),
Err(err) => warn!(?err, "Failed to initialize output."),
};
}
backend.devices.insert(drm_node, device);
@ -589,7 +574,7 @@ impl State {
}
fn init_vulkan(&mut self, drm_node: DrmNode, render_node: DrmNode) {
if let Ok(instance) = Instance::new(Version::VERSION_1_2, None, None) {
if let Ok(instance) = Instance::new(Version::VERSION_1_2, None) {
if let Some(physical_device) =
PhysicalDevice::enumerate(&instance)
.ok()
@ -621,7 +606,7 @@ impl State {
.allocator = Box::new(DmabufAllocator(allocator));
}
Err(err) => {
slog_scope::warn!("Failed to create vulkan allocator: {}", err);
warn!(?err, "Failed to create vulkan allocator.");
}
}
}
@ -654,7 +639,7 @@ impl State {
let mut renderer = match backend.api.single_renderer(&device.render_node) {
Ok(renderer) => renderer,
Err(err) => {
slog_scope::warn!("Failed to initialize output: {}", err);
warn!(?err, "Failed to initialize output.");
continue;
}
};
@ -669,7 +654,7 @@ impl State {
.w;
outputs_added.push(output);
}
Err(err) => slog_scope::warn!("Failed to initialize output: {}", err),
Err(err) => warn!(?err, "Failed to initialize output."),
};
}
}
@ -826,7 +811,6 @@ impl Device {
.map(|info| info.model.clone())
.unwrap_or_else(|_| String::from("Unknown")),
},
None,
);
for mode in conn_info.modes() {
let refresh_rate = drm_helpers::calculate_refresh_rate(*mode);
@ -1059,7 +1043,6 @@ impl KmsState {
GbmBufferFlags::RENDERING | GbmBufferFlags::SCANOUT,
),
device.formats.clone(),
None,
)
.with_context(|| {
format!(
@ -1094,10 +1077,10 @@ impl KmsState {
None
},
) {
slog_scope::crit!(
"Error scheduling event loop for output {}: {:?}",
error!(
?err,
"Error scheduling event loop for output {}.",
output.name(),
err
);
}
}
@ -1135,7 +1118,7 @@ impl KmsState {
render,
surface,
) {
slog_scope::debug!("Early import failed: {}", err);
debug!(?err, "Early import failed.");
}
}
@ -1247,7 +1230,7 @@ impl KmsState {
}
Err(err) => {
if backend.session.is_active() {
slog_scope::error!("Error rendering: {:?}", err);
error!(?err, "Error rendering.");
return TimeoutAction::ToDuration(Duration::from_secs_f64(
(1000.0 / surface.refresh_rate as f64) - 0.003,
));

14
src/backend/kms/socket.rs
View file

@ -14,6 +14,7 @@ use smithay::{
xwayland::XWaylandClientData,
};
use std::sync::Arc;
use tracing::{info, warn};
use crate::{
state::{ClientState, Data},
@ -61,7 +62,7 @@ impl State {
let dmabuf_global = self
.common
.dmabuf_state
.create_global_with_filter::<State, _, _>(dh, formats.clone(), filter, None);
.create_global_with_filter::<State, _>(dh, formats.clone(), filter);
let drm_global_id = self
.common
@ -81,8 +82,9 @@ impl State {
);
// add a special socket for the gpu
let listener = ListeningSocketSource::with_name(&socket_name, None)
let listener = ListeningSocketSource::with_name(&socket_name)
.with_context(|| format!("Failed to bind socket to {}", socket_name))?;
let socket_name_clone = socket_name.clone();
let token = self
.common
.event_loop_handle
@ -91,12 +93,16 @@ impl State {
client_stream,
Arc::new(data.state.new_client_state_with_node(render_node)),
) {
slog_scope::warn!("Error adding wayland client ({}): {}", render_node, err);
warn!(
socket_name = socket_name_clone,
?err,
"Error adding wayland client."
);
}
})
.context("Failed to add gpu-wayland socket to the event loop")?;
slog_scope::info!("Added socket at {} for gpu {}", socket_name, render_node,);
info!(socket_name, ?render_node, "Added gpu-specific socket.");
Ok(Socket {
token,

5
src/backend/mod.rs
View file

@ -3,6 +3,7 @@
use crate::state::{Data, State};
use anyhow::{Context, Result};
use smithay::reexports::{calloop::EventLoop, wayland_server::DisplayHandle};
use tracing::{info, warn};
pub mod render;
@ -29,8 +30,8 @@ pub fn init_backend_auto(
match x11::init_backend(dh, event_loop, state) {
Ok(_) => Ok(()),
Err(err) => {
slog_scope::warn!("X11 Backend failed with error: {}", err);
slog_scope::info!("Falling back to winit backend.");
warn!(?err, "Initializing X11 Backend failed.");
info!("Falling back to winit backend.");
winit::init_backend(dh, event_loop, state)
}
}

10
src/backend/render/cursor.rs
View file

@ -26,6 +26,7 @@ use std::{
sync::Mutex,
time::Duration,
};
use tracing::warn;
use xcursor::{
parser::{parse_xcursor, Image},
CursorTheme,
@ -51,9 +52,7 @@ impl Cursor {
let theme = CursorTheme::load(&name);
let icons = load_icon(&theme)
.map_err(|err| {
slog_scope::warn!("Unable to load xcursor: {}, using fallback cursor", err)
})
.map_err(|err| warn!(?err, "Unable to load xcursor, using fallback cursor"))
.unwrap_or_else(|_| {
vec![Image {
size: 32,
@ -160,7 +159,6 @@ where
surface,
position.to_physical_precise_round(scale),
scale,
slog_scope::logger(),
)
}
@ -175,7 +173,8 @@ where
<R as Renderer>::TextureId: 'static,
{
if get_role(&surface) != Some("dnd_icon") {
slog_scope::warn!(
warn!(
?surface,
"Trying to display as a dnd icon a surface that does not have the DndIcon role."
);
}
@ -185,7 +184,6 @@ where
surface,
location.into().to_physical_precise_round(scale),
scale,
slog_scope::logger(),
)
}

29
src/backend/render/element.rs
View file

@ -127,23 +127,19 @@ impl RenderElement<GlowRenderer> for CosmicElement<GlowRenderer> {
src: Rectangle<f64, BufferCoords>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>],
log: &slog::Logger,
) -> Result<(), <GlowRenderer as Renderer>::Error> {
match self {
CosmicElement::Workspace(elem) => elem.draw(frame, src, dst, damage, log),
CosmicElement::Cursor(elem) => elem.draw(frame, src, dst, damage, log),
CosmicElement::MoveGrab(elem) => elem.draw(frame, src, dst, damage, log),
CosmicElement::Workspace(elem) => elem.draw(frame, src, dst, damage),
CosmicElement::Cursor(elem) => elem.draw(frame, src, dst, damage),
CosmicElement::MoveGrab(elem) => elem.draw(frame, src, dst, damage),
#[cfg(feature = "debug")]
CosmicElement::Egui(elem) => {
RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage, log)
RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage)
}
}
}
fn underlying_storage(
&self,
renderer: &GlowRenderer,
) -> Option<UnderlyingStorage<'_, GlowRenderer>> {
fn underlying_storage(&self, renderer: &mut GlowRenderer) -> Option<UnderlyingStorage> {
match self {
CosmicElement::Workspace(elem) => elem.underlying_storage(renderer),
CosmicElement::Cursor(elem) => elem.underlying_storage(renderer),
@ -161,17 +157,16 @@ impl<'a, 'b> RenderElement<GlMultiRenderer<'a, 'b>> for CosmicElement<GlMultiRen
src: Rectangle<f64, BufferCoords>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>],
log: &slog::Logger,
) -> Result<(), <GlMultiRenderer<'a, 'b> as Renderer>::Error> {
match self {
CosmicElement::Workspace(elem) => elem.draw(frame, src, dst, damage, log),
CosmicElement::Cursor(elem) => elem.draw(frame, src, dst, damage, log),
CosmicElement::MoveGrab(elem) => elem.draw(frame, src, dst, damage, log),
CosmicElement::Workspace(elem) => elem.draw(frame, src, dst, damage),
CosmicElement::Cursor(elem) => elem.draw(frame, src, dst, damage),
CosmicElement::MoveGrab(elem) => elem.draw(frame, src, dst, damage),
#[cfg(feature = "debug")]
CosmicElement::Egui(elem) => {
let elem = {
let glow_frame = frame.glow_frame_mut();
RenderElement::<GlowRenderer>::draw(elem, glow_frame, src, dst, damage, log)
RenderElement::<GlowRenderer>::draw(elem, glow_frame, src, dst, damage)
.map_err(|err| MultiError::Render(err))
};
elem
@ -181,15 +176,15 @@ impl<'a, 'b> RenderElement<GlMultiRenderer<'a, 'b>> for CosmicElement<GlMultiRen
fn underlying_storage(
&self,
renderer: &GlMultiRenderer<'a, 'b>,
) -> Option<UnderlyingStorage<'_, GlMultiRenderer<'a, 'b>>> {
renderer: &mut GlMultiRenderer<'a, 'b>,
) -> Option<UnderlyingStorage> {
match self {
CosmicElement::Workspace(elem) => elem.underlying_storage(renderer),
CosmicElement::Cursor(elem) => elem.underlying_storage(renderer),
CosmicElement::MoveGrab(elem) => elem.underlying_storage(renderer),
#[cfg(feature = "debug")]
CosmicElement::Egui(elem) => {
let glow_renderer = renderer.glow_renderer();
let glow_renderer = renderer.glow_renderer_mut();
match elem.underlying_storage(glow_renderer) {
Some(UnderlyingStorage::Wayland(buffer)) => {
Some(UnderlyingStorage::Wayland(buffer))

7
src/backend/render/mod.rs
View file

@ -37,6 +37,7 @@ use smithay::{
utils::{Physical, Rectangle},
wayland::dmabuf::get_dmabuf,
};
use tracing::warn;
pub mod cursor;
use self::cursor::CursorRenderElement;
@ -268,7 +269,7 @@ where
}
renderer.bind(target).map_err(RenderError::Rendering)?;
let res = damage_tracker.render_output(renderer, age, &elements, CLEAR_COLOR, None);
let res = damage_tracker.render_output(renderer, age, &elements, CLEAR_COLOR);
if let Some(fps) = fps.as_mut() {
fps.render();
@ -284,7 +285,7 @@ where
params,
output.current_transform(),
|_node, buffer, renderer, dtr, age| {
let res = dtr.damage_output(age, &elements, slog_scope::logger())?;
let res = dtr.damage_output(age, &elements)?;
if let (Some(ref damage), _) = &res {
if let Ok(dmabuf) = get_dmabuf(buffer) {
@ -311,7 +312,7 @@ where
Ok(true) => {} // success
Ok(false) => state.still_pending(session.clone(), params.clone()),
Err(err) => {
slog_scope::warn!("Error rendering to screencopy session: {}", err);
warn!(?err, "Error rendering to screencopy session.");
session.failed(FailureReason::Unspec);
}
}

13
src/backend/winit.rs
View file

@ -27,6 +27,7 @@ use smithay::{
utils::Transform,
};
use std::cell::RefCell;
use tracing::{error, info, warn};
#[cfg(feature = "debug")]
use crate::state::Fps;
@ -145,7 +146,7 @@ pub fn init_backend(
state: &mut State,
) -> Result<()> {
let (mut backend, mut input) =
winit::init(None).map_err(|_| anyhow!("Failed to initilize winit backend"))?;
winit::init().map_err(|_| anyhow!("Failed to initilize winit backend"))?;
init_egl_client_side(dh, state, &mut backend)?;
@ -161,7 +162,7 @@ pub fn init_backend(
size: (size.physical_size.w as i32, size.physical_size.h as i32).into(),
refresh: 60_000,
};
let output = Output::new(name, props, None);
let output = Output::new(name, props);
output.add_mode(mode);
output.set_preferred(mode);
output.change_current_state(
@ -197,7 +198,7 @@ pub fn init_backend(
.winit()
.render_output(&mut data.state.common)
{
slog_scope::error!("Failed to render frame: {}", err);
error!(?err, "Failed to render frame.");
render_ping.ping();
}
})
@ -269,7 +270,7 @@ fn init_egl_client_side(
let bind_result = renderer.renderer().bind_wl_display(dh);
match bind_result {
Ok(_) => {
slog_scope::info!("EGL hardware-acceleration enabled");
info!("EGL hardware-acceleration enabled.");
let dmabuf_formats = renderer
.renderer()
.dmabuf_formats()
@ -278,9 +279,9 @@ fn init_egl_client_side(
state
.common
.dmabuf_state
.create_global::<State, _>(dh, dmabuf_formats, None);
.create_global::<State>(dh, dmabuf_formats);
}
Err(err) => slog_scope::warn!("Unable to initialize bind display to EGL: {}", err),
Err(err) => warn!(?err, "Unable to initialize bind display to EGL."),
};
Ok(())

37
src/backend/x11.rs
View file

@ -37,6 +37,7 @@ use smithay::{
utils::{DeviceFd, Transform},
};
use std::{cell::RefCell, os::unix::io::OwnedFd};
use tracing::{debug, error, info, warn};
#[cfg(feature = "debug")]
use crate::state::Fps;
@ -96,7 +97,7 @@ impl X11State {
size: (size.w as i32, size.h as i32).into(),
refresh: 60_000,
};
let output = Output::new(name, props, None);
let output = Output::new(name, props);
output.add_mode(mode);
output.set_preferred(mode);
output.change_current_state(
@ -126,7 +127,7 @@ impl X11State {
if let Err(err) =
surface.render_output(&mut x11_state.renderer, &mut data.state.common)
{
slog_scope::error!("Error rendering: {}", err);
error!(?err, "Error rendering.");
}
surface.dirty = false;
surface.pending = true;
@ -272,12 +273,12 @@ impl Surface {
}
fn try_vulkan_allocator(node: &DrmNode) -> Option<Allocator> {
let instance = match Instance::new(Version::VERSION_1_2, None, None) {
let instance = match Instance::new(Version::VERSION_1_2, None) {
Ok(instance) => instance,
Err(err) => {
slog_scope::warn!(
"Failed to instanciate vulkan, falling back to gbm allocator: {}",
err
warn!(
?err,
"Failed to instanciate vulkan, falling back to gbm allocator.",
);
return None;
}
@ -286,7 +287,7 @@ fn try_vulkan_allocator(node: &DrmNode) -> Option<Allocator> {
let devices = match PhysicalDevice::enumerate(&instance) {
Ok(devices) => devices,
Err(err) => {
slog_scope::debug!("No vulkan devices, falling back to gbm: {}", err);
debug!(?err, "No vulkan devices, falling back to gbm.");
return None;
}
};
@ -299,7 +300,7 @@ fn try_vulkan_allocator(node: &DrmNode) -> Option<Allocator> {
phd.primary_node().unwrap() == Some(*node) || phd.render_node().unwrap() == Some(*node)
})
else {
slog_scope::debug!("No vulkan device for node {:?}, falling back to gbm", node);
debug!(?node, "No vulkan device for node, falling back to gbm.");
return None;
};
@ -308,10 +309,10 @@ fn try_vulkan_allocator(node: &DrmNode) -> Option<Allocator> {
fn try_gbm_allocator(fd: OwnedFd) -> Option<Allocator> {
// Create the gbm device for buffer allocation.
let device = match GbmDevice::new(DrmDeviceFd::new(DeviceFd::from(fd), None)) {
let device = match GbmDevice::new(DrmDeviceFd::new(DeviceFd::from(fd))) {
Ok(gbm) => gbm,
Err(err) => {
slog_scope::error!("Failed to create GBM device: {}", err);
error!(?err, "Failed to create GBM device.");
return None;
}
};
@ -327,7 +328,7 @@ pub fn init_backend(
event_loop: &mut EventLoop<Data>,
state: &mut State,
) -> Result<()> {
let backend = X11Backend::new(None).with_context(|| "Failed to initilize X11 backend")?;
let backend = X11Backend::new().with_context(|| "Failed to initilize X11 backend")?;
let handle = backend.handle();
// Obtain the DRM node the X server uses for direct rendering.
@ -340,12 +341,12 @@ pub fn init_backend(
.find(|device| device.try_get_render_node().ok().flatten() == Some(drm_node))
.with_context(|| format!("Failed to find EGLDevice for node {}", drm_node))?;
// Initialize EGL
let egl = EGLDisplay::new(device, None).with_context(|| "Failed to create EGL display")?;
let egl = EGLDisplay::new(device).with_context(|| "Failed to create EGL display")?;
// Create the OpenGL context
let context = EGLContext::new(&egl, None).with_context(|| "Failed to create EGL context")?;
let context = EGLContext::new(&egl).with_context(|| "Failed to create EGL context")?;
// Create a renderer
let mut renderer = unsafe { GlowRenderer::new(context, None) }
.with_context(|| "Failed to initialize renderer")?;
let mut renderer =
unsafe { GlowRenderer::new(context) }.with_context(|| "Failed to initialize renderer")?;
init_egl_client_side(dh, state, &mut renderer)?;
@ -478,14 +479,14 @@ where
let bind_result = renderer.bind_wl_display(dh);
match bind_result {
Ok(_) => {
slog_scope::info!("EGL hardware-acceleration enabled");
info!("EGL hardware-acceleration enabled.");
let dmabuf_formats = renderer.dmabuf_formats().cloned().collect::<Vec<_>>();
state
.common
.dmabuf_state
.create_global::<State, _>(dh, dmabuf_formats, None);
.create_global::<State>(dh, dmabuf_formats);
}
Err(err) => slog_scope::warn!("Unable to initialize bind display to EGL: {}", err),
Err(err) => warn!(?err, "Unable to initialize bind display to EGL."),
};
Ok(())

131
src/config/mod.rs
View file

@ -21,6 +21,7 @@ pub use smithay::{
utils::{Logical, Physical, Point, Size, Transform},
};
use std::{cell::RefCell, collections::HashMap, fs::OpenOptions, path::PathBuf};
use tracing::{debug, error, info, warn};
mod types;
pub use self::types::*;
@ -207,9 +208,9 @@ impl Config {
locations.push(PathBuf::from("/etc/cosmic-comp.ron"));
for path in locations {
slog_scope::debug!("Trying config location: {}", path.display());
debug!("Trying config location: {}", path.display());
if path.exists() {
slog_scope::info!("Using config at {}", path.display());
info!("Using config at {}", path.display());
return ron::de::from_reader(OpenOptions::new().read(true).open(path).unwrap())
.expect("Malformed config file");
}
@ -243,9 +244,9 @@ impl Config {
match ron::de::from_reader(OpenOptions::new().read(true).open(path).unwrap()) {
Ok(config) => return config,
Err(err) => {
slog_scope::warn!("Failed to read output_config ({}), resetting..", err);
warn!(?err, "Failed to read output_config, resetting..");
if let Err(err) = std::fs::remove_file(path) {
slog_scope::error!("Failed to remove output_config {}", err);
error!(?err, "Failed to remove output_config.");
}
}
};
@ -263,9 +264,9 @@ impl Config {
match ron::de::from_reader(OpenOptions::new().read(true).open(path).unwrap()) {
Ok(config) => return config,
Err(err) => {
slog_scope::warn!("Failed to read input_config ({}), resetting..", err);
warn!(?err, "Failed to read input_config, resetting..");
if let Err(err) = std::fs::remove_file(path) {
slog_scope::error!("Failed to remove input_config {}", err);
error!(?err, "Failed to remove input_config.");
}
}
};
@ -324,10 +325,10 @@ impl Config {
seats.iter().cloned(),
loop_handle,
) {
slog_scope::warn!(
"Failed to set new config for output {}: {}",
warn!(
?err,
"Failed to set new config for output {}.",
output.name(),
err
);
reset = true;
break;
@ -359,11 +360,7 @@ impl Config {
seats.iter().cloned(),
loop_handle,
) {
slog_scope::error!(
"Failed to reset config for output {}: {}",
output.name(),
err
);
error!(?err, "Failed to reset config for output {}.", output.name());
} else {
if enabled {
output_state.enable_head(&output);
@ -385,10 +382,10 @@ impl Config {
seats.iter().cloned(),
loop_handle,
) {
slog_scope::warn!(
"Failed to set new config for output {}: {}",
warn!(
?err,
"Failed to set new config for output {}.",
output.name(),
err
);
} else {
if output
@ -456,158 +453,158 @@ impl Config {
DeviceState::DisabledOnExternalMouse => device
.config_send_events_set_mode(SendEventsMode::DISABLED_ON_EXTERNAL_MOUSE),
} {
slog_scope::warn!(
"Failed to apply mode {:?} for device {:?}: {:?}",
warn!(
?err,
"Failed to apply mode {:?} for device {:?}.",
config.state,
device.name(),
err
);
}
if let Some(accel) = config.acceleration.as_ref() {
if let Some(profile) = accel.profile {
if let Err(err) = device.config_accel_set_profile(profile) {
slog_scope::warn!(
"Failed to apply acceleration profile {:?} for device {:?}: {:?}",
warn!(
?err,
"Failed to apply acceleration profile {:?} for device {:?}.",
profile,
device.name(),
err
);
}
}
if let Err(err) = device.config_accel_set_speed(accel.speed) {
slog_scope::warn!(
"Failed to apply acceleration speed {:?} for device {:?}: {:?}",
warn!(
?err,
"Failed to apply acceleration speed {:?} for device {:?}.",
accel.speed,
device.name(),
err
);
}
}
if let Some(matrix) = config.calibration {
if let Err(err) = device.config_calibration_set_matrix(matrix) {
slog_scope::warn!(
"Failed to apply calibration matrix {:?} for device {:?}: {:?}",
warn!(
?err,
"Failed to apply calibration matrix {:?} for device {:?}.",
matrix,
device.name(),
err
);
}
}
if let Some(method) = config.click_method {
if let Err(err) = device.config_click_set_method(method) {
slog_scope::warn!(
"Failed to apply click method {:?} for device {:?}: {:?}",
warn!(
?err,
"Failed to apply click method {:?} for device {:?}.",
method,
device.name(),
err
);
}
}
if let Some(dwt) = config.disable_while_typing {
if let Err(err) = device.config_dwt_set_enabled(dwt) {
slog_scope::warn!(
"Failed to apply disable-while-typing {:?} for device {:?}: {:?}",
warn!(
?err,
"Failed to apply disable-while-typing {:?} for device {:?}.",
dwt,
device.name(),
err
);
}
}
if let Some(left) = config.left_handed {
if let Err(err) = device.config_left_handed_set(left) {
slog_scope::warn!(
"Failed to apply left-handed {:?} for device {:?}: {:?}",
warn!(
?err,
"Failed to apply left-handed {:?} for device {:?}.",
left,
device.name(),
err
);
}
}
if let Some(middle) = config.middle_button_emulation {
if let Err(err) = device.config_middle_emulation_set_enabled(middle) {
slog_scope::warn!(
"Failed to apply middle-button-emulation {:?} for device {:?}: {:?}",
warn!(
?err,
"Failed to apply middle-button-emulation {:?} for device {:?}.",
middle,
device.name(),
err
);
}
}
if let Some(angle) = config.rotation_angle {
if let Err(err) = device.config_rotation_set_angle(angle) {
slog_scope::warn!(
"Failed to apply rotation-angle {:?} for device {:?}: {:?}",
warn!(
?err,
"Failed to apply rotation-angle {:?} for device {:?}",
angle,
device.name(),
err
);
}
}
if let Some(scroll) = config.scroll_config.as_ref() {
if let Some(method) = scroll.method {
if let Err(err) = device.config_scroll_set_method(method) {
slog_scope::warn!(
"Failed to apply scroll method {:?} for device {:?}: {:?}",
warn!(
?err,
"Failed to apply scroll method {:?} for device {:?}.",
method,
device.name(),
err
);
}
}
if let Some(natural) = scroll.natural_scroll {
if let Err(err) = device.config_scroll_set_natural_scroll_enabled(natural) {
slog_scope::warn!(
"Failed to apply natural scrolling {:?} for device {:?}: {:?}",
warn!(
?err,
"Failed to apply natural scrolling {:?} for device {:?}.",
natural,
device.name(),
err
);
}
}
if let Some(button) = scroll.scroll_button {
if let Err(err) = device.config_scroll_set_button(button) {
slog_scope::warn!(
"Failed to apply scroll button {:?} for device {:?}: {:?}",
warn!(
?err,
"Failed to apply scroll button {:?} for device {:?}.",
button,
device.name(),
err
);
}
}
}
if let Some(tap) = config.tap_config.as_ref() {
if let Err(err) = device.config_tap_set_enabled(tap.enabled) {
slog_scope::warn!(
"Failed to apply tap-to-click {:?} for device {:?}: {:?}",
warn!(
?err,
"Failed to apply tap-to-click {:?} for device {:?}.",
tap.enabled,
device.name(),
err
);
}
if let Some(button_map) = tap.button_map {
if let Err(err) = device.config_tap_set_button_map(button_map) {
slog_scope::warn!(
"Failed to apply button map {:?} for device {:?}: {:?}",
warn!(
?err,
"Failed to apply button map {:?} for device {:?}.",
button_map,
device.name(),
err
);
}
}
if let Err(err) = device.config_tap_set_drag_enabled(tap.drag) {
slog_scope::warn!(
"Failed to apply tap-drag {:?} for device {:?}: {:?}",
warn!(
?err,
"Failed to apply tap-drag {:?} for device {:?}.",
tap.drag,
device.name(),
err
);
}
if let Err(err) = device.config_tap_set_drag_lock_enabled(tap.drag_lock) {
slog_scope::warn!(
"Failed to apply tap-drag-lock {:?} for device {:?}: {:?}",
warn!(
?err,
"Failed to apply tap-drag-lock {:?} for device {:?}.",
tap.drag_lock,
device.name(),
err
);
}
}
@ -717,12 +714,12 @@ impl<'a, T: Serialize> Drop for PersistenceGuard<'a, T> {
{
Ok(writer) => writer,
Err(err) => {
slog_scope::warn!("Failed to persist {}: {}", path.display(), err);
warn!(?err, "Failed to persist {}.", path.display());
return;
}
};
if let Err(err) = ron::ser::to_writer_pretty(writer, &self.1, Default::default()) {
slog_scope::warn!("Failed to persist {}: {}", path.display(), err);
warn!(?err, "Failed to persist {}", path.display());
}
}
}

3
src/config/types.rs
View file

@ -10,6 +10,7 @@ pub use smithay::{
reexports::input::{AccelProfile, ClickMethod, ScrollMethod, TapButtonMap},
utils::{Logical, Physical, Point, Size, Transform},
};
use tracing::warn;
use xkbcommon::xkb;
#[derive(Debug, Clone, Deserialize, Serialize)]
@ -247,7 +248,7 @@ where
&"One of the keysym names of xkbcommon.h without the 'KEY_' prefix",
)),
x => {
slog_scope::warn!(
warn!(
"Key-Binding '{}' only matched case insensitive for {:?}",
name,
xkb::keysym_get_name(x)

24
src/input/mod.rs
View file

@ -35,6 +35,9 @@ use smithay::{
},
xwayland::X11Surface,
};
#[cfg(not(feature = "debug"))]
use tracing::info;
use tracing::{error, trace, warn};
use std::{cell::RefCell, collections::HashMap};
use xkbcommon::xkb::KEY_XF86Switch_VT_12;
@ -117,7 +120,7 @@ pub fn add_seat(
config: &Config,
name: String,
) -> Seat<State> {
let mut seat = seat_state.new_wl_seat(dh, name, None);
let mut seat = seat_state.new_wl_seat(dh, name);
let userdata = seat.user_data();
userdata.insert_if_missing(SeatId::default);
userdata.insert_if_missing(Devices::default);
@ -137,9 +140,9 @@ pub fn add_seat(
// devices appear), we have to surrender to reality and just always expose a keyboard and pointer.
let conf = config.xkb_config();
if let Err(err) = seat.add_keyboard((&conf).into(), 200, 25) {
slog_scope::warn!(
"Failed to load provided xkb config: {}. Trying default...",
err
warn!(
?err,
"Failed to load provided xkb config. Trying default...",
);
seat.add_keyboard(XkbConfig::default(), 200, 25)
.expect("Failed to load xkb configuration files");
@ -204,7 +207,7 @@ impl State {
if devices.has_device(&device) {
let keycode = event.key_code();
let state = event.state();
slog_scope::trace!("key"; "keycode" => keycode, "state" => format!("{:?}", state));
trace!(?keycode, ?state, "key");
let serial = SERIAL_COUNTER.next_serial();
let time = Event::time_msec(&event);
@ -233,10 +236,7 @@ impl State {
+ 1)
as i32,
) {
slog_scope::error!(
"Failed switching virtual terminal: {}",
err
);
error!(?err, "Failed switching virtual terminal.");
}
userdata.get::<SupressedKeys>().unwrap().add(&handle);
return FilterResult::Intercept(None);
@ -574,7 +574,7 @@ impl State {
}
#[cfg(not(feature = "debug"))]
Action::Debug => {
slog_scope::info!("Debug overlay not included in this version")
info!("Debug overlay not included in this build.")
}
Action::Close => {
let current_output = seat.active_output();
@ -923,7 +923,7 @@ impl State {
Action::Spawn(command) => {
if let Err(err) = std::process::Command::new("/bin/sh")
.arg("-c")
.arg(command)
.arg(command.clone())
.env("WAYLAND_DISPLAY", &self.common.socket)
.env(
"DISPLAY",
@ -938,7 +938,7 @@ impl State {
.env_remove("COSMIC_SESSION_SOCK")
.spawn()
{
slog_scope::warn!("Failed to spawn: {}", err);
warn!(?err, "Failed to spawn \"{}\"", command);
}
}
}

87
src/logger/mod.rs
View file

@ -1,59 +1,60 @@
// SPDX-License-Identifier: GPL-3.0-only
use std::str::FromStr;
use anyhow::Result;
use slog::{Drain, Level};
pub struct LogState {
_guard: slog_scope::GlobalLoggerGuard,
}
use tracing::{debug, info, warn};
use tracing_journald as journald;
use tracing_subscriber::{filter::Directive, fmt, prelude::*, EnvFilter};
pub fn init_logger() -> Result<LogState> {
let decorator = slog_term::TermDecorator::new().stderr().build();
let term_drain = slog_term::CompactFormat::new(decorator)
.build()
.ignore_res();
let journald_drain = slog_journald::JournaldDrain.ignore_res();
let drain = slog::Duplicate::new(term_drain, journald_drain);
// usually we would not want to use a Mutex here, but this is usefull for a prototype,
// to make sure we do not miss any in-flight messages, when we crash.
let logger = slog::Logger::root(
std::sync::Mutex::new(drain.filter(|record| {
if record.module().starts_with("smithay") || record.module().starts_with("cosmic_comp")
{
return true;
}
if record.module().contains("cosmic_text") {
// cosmic-text is very chatty
return record.level().is_at_least(Level::Error);
}
if cfg!(debug_assertions) {
record.level().is_at_least(Level::Warning)
pub fn init_logger() -> Result<()> {
let filter = EnvFilter::try_from_default_env()
.unwrap_or_else(|_| {
EnvFilter::new(if cfg!(debug_assertions) {
"warning"
} else {
record.level().is_at_least(Level::Error)
}
}))
.fuse(),
slog::o!(),
);
"error"
})
})
.add_directive(Directive::from_str("cosmic_text=error").unwrap())
.add_directive(
Directive::from_str(&format!(
"smithay={level},cosmic_comp={level}",
level = if cfg!(debug_assertions) {
"debug"
} else {
"info"
}
))
.unwrap(),
);
let _guard = slog_scope::set_global_logger(logger);
slog_stdlog::init_with_level(if cfg!(debug_assertions) {
log::Level::Debug
} else {
log::Level::Info
})
.unwrap();
let fmt_layer = fmt::layer().compact();
match journald::layer() {
Ok(journald_layer) => tracing_subscriber::registry()
.with(fmt_layer)
.with(journald_layer)
.with(filter)
.init(),
Err(err) => {
tracing_subscriber::registry()
.with(fmt_layer)
.with(filter)
.init();
warn!(?err, "Failed to init journald logging.");
}
};
log_panics::init();
slog_scope::info!("Version: {}", std::env!("CARGO_PKG_VERSION"));
info!("Version: {}", std::env!("CARGO_PKG_VERSION"));
if cfg!(feature = "debug") {
slog_scope::debug!(
debug!(
"Debug build ({})",
std::option_env!("GIT_HASH").unwrap_or("Unknown")
);
}
Ok(LogState { _guard })
Ok(())
}

19
src/main.rs
View file

@ -10,6 +10,7 @@ use smithay::{
use anyhow::{Context, Result};
use std::{ffi::OsString, os::unix::prelude::AsRawFd, sync::Arc};
use tracing::{error, info, warn};
pub mod backend;
pub mod config;
@ -27,8 +28,8 @@ pub mod xwayland;
fn main() -> Result<()> {
// setup logger
let _log = logger::init_logger()?;
slog_scope::info!("Cosmic starting up!");
logger::init_logger()?;
info!("Cosmic starting up!");
// init event loop
let mut event_loop =
@ -56,7 +57,7 @@ fn main() -> Result<()> {
event_loop.run(None, &mut data, |data| {
// shall we shut down?
if data.state.common.shell.outputs().next().is_none() || data.state.common.should_stop {
slog_scope::info!("Shutting down");
info!("Shutting down");
data.state.common.event_loop_signal.stop();
data.state.common.event_loop_signal.wakeup();
return;
@ -82,9 +83,9 @@ fn init_wayland_display(
) -> Result<(Display<state::State>, OsString)> {
let mut display = Display::new().unwrap();
let source = ListeningSocketSource::new_auto(None).unwrap();
let source = ListeningSocketSource::new_auto().unwrap();
let socket_name = source.socket_name().to_os_string();
slog_scope::info!("Listening on {:?}", socket_name);
info!("Listening on {:?}", socket_name);
event_loop
.handle()
@ -97,7 +98,7 @@ fn init_wayland_display(
data.state.new_client_state()
}),
) {
slog_scope::warn!("Error adding wayland client: {}", err);
warn!(?err, "Error adding wayland client");
};
})
.with_context(|| "Failed to init the wayland socket source.")?;
@ -112,10 +113,10 @@ fn init_wayland_display(
move |_, _, data: &mut state::Data| match data.display.dispatch_clients(&mut data.state)
{
Ok(_) => Ok(PostAction::Continue),
Err(e) => {
slog_scope::error!("I/O error on the Wayland display: {}", e);
Err(err) => {
error!(?err, "I/O error on the Wayland display");
data.state.common.should_stop = true;
Err(e)
Err(err)
}
},
)

17
src/session.rs
View file

@ -17,6 +17,7 @@ use std::{
},
sync::Arc,
};
use tracing::{error, warn};
use crate::state::{Data, State};
@ -108,7 +109,7 @@ pub fn setup_socket(handle: LoopHandle<Data>, state: &State) -> Result<()> {
stream.buffer = vec![0; stream.size as usize];
},
Err(err) => {
slog_scope::warn!("Error reading from session socket: {}", err);
warn!(?err, "Error reading from session socket");
return Ok(PostAction::Remove);
}
}
@ -117,7 +118,7 @@ pub fn setup_socket(handle: LoopHandle<Data>, state: &State) -> Result<()> {
stream.read_bytes += match stream.stream.read(&mut stream.buffer) {
Ok(size) => size,
Err(err) => {
slog_scope::error!("Error reading from session socket: {}", err);
error!(?err, "Error reading from session socket");
return Ok(PostAction::Remove);
}
};
@ -137,22 +138,22 @@ pub fn setup_socket(handle: LoopHandle<Data>, state: &State) -> Result<()> {
for fd in fds.into_iter().take(received_count) {
let stream = unsafe { UnixStream::from_raw_fd(fd) };
if let Err(err) = data.display.handle().insert_client(stream, Arc::new(data.state.new_privileged_client_state())) {
slog_scope::warn!("Failed to add privileged client to display: {}", err);
warn!(?err, "Failed to add privileged client to display");
}
}
},
Err(err) => {
slog_scope::warn!("Failed to read file descriptors from session sock: {}", err);
warn!(?err, "Failed to read file descriptors from session sock");
}
}
},
Ok(Message::SetEnv { .. }) => slog_scope::warn!("Got SetEnv from session? What is this?"),
_ => slog_scope::warn!("Unknown session socket message, are you using incompatible cosmic-session and cosmic-comp versions?"),
Ok(Message::SetEnv { .. }) => warn!("Got SetEnv from session? What is this?"),
_ => warn!("Unknown session socket message, are you using incompatible cosmic-session and cosmic-comp versions?"),
};
Ok(PostAction::Continue)
},
Err(err) => {
slog_scope::warn!("Invalid message from session sock: {}", err);
warn!(?err, "Invalid message from session sock");
Ok(PostAction::Continue)
}
}
@ -162,7 +163,7 @@ pub fn setup_socket(handle: LoopHandle<Data>, state: &State) -> Result<()> {
},
).with_context(|| "Failed to init the cosmic session socket source")?;
} else {
slog_scope::error!("COSMIC_SESSION_SOCK is no valid RawFd: {}", fd_num);
error!(socket = fd_num, "COSMIC_SESSION_SOCK is no valid RawFd.");
}
};

20
src/shell/element/mod.rs
View file

@ -54,6 +54,8 @@ use egui::plot::{Corner, Legend, Plot, PlotPoints, Polygon};
use smithay::backend::renderer::{
element::texture::TextureRenderElement, gles2::Gles2Texture, multigpu::Error as MultiError,
};
#[cfg(feature = "debug")]
use tracing::debug;
use super::{focus::FocusDirection, layout::floating::ResizeState};
@ -750,14 +752,13 @@ impl RenderElement<GlowRenderer> for CosmicMappedRenderElement<GlowRenderer> {
src: Rectangle<f64, BufferCoords>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>],
log: &slog::Logger,
) -> Result<(), <GlowRenderer as Renderer>::Error> {
match self {
CosmicMappedRenderElement::Stack(elem) => elem.draw(frame, src, dst, damage, log),
CosmicMappedRenderElement::Window(elem) => elem.draw(frame, src, dst, damage, log),
CosmicMappedRenderElement::Stack(elem) => elem.draw(frame, src, dst, damage),
CosmicMappedRenderElement::Window(elem) => elem.draw(frame, src, dst, damage),
#[cfg(feature = "debug")]
CosmicMappedRenderElement::Egui(elem) => {
RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage, log)
RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage)
}
}
}
@ -781,15 +782,14 @@ impl<'a, 'b> RenderElement<GlMultiRenderer<'a, 'b>>
src: Rectangle<f64, BufferCoords>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>],
log: &slog::Logger,
) -> Result<(), <GlMultiRenderer<'a, 'b> as Renderer>::Error> {
match self {
CosmicMappedRenderElement::Stack(elem) => elem.draw(frame, src, dst, damage, log),
CosmicMappedRenderElement::Window(elem) => elem.draw(frame, src, dst, damage, log),
CosmicMappedRenderElement::Stack(elem) => elem.draw(frame, src, dst, damage),
CosmicMappedRenderElement::Window(elem) => elem.draw(frame, src, dst, damage),
#[cfg(feature = "debug")]
CosmicMappedRenderElement::Egui(elem) => {
let glow_frame = frame.glow_frame_mut();
RenderElement::<GlowRenderer>::draw(elem, glow_frame, src, dst, damage, log)
RenderElement::<GlowRenderer>::draw(elem, glow_frame, src, dst, damage)
.map_err(|err| MultiError::Render(err))
}
}
@ -804,7 +804,7 @@ impl<'a, 'b> RenderElement<GlMultiRenderer<'a, 'b>>
CosmicMappedRenderElement::Window(elem) => elem.underlying_storage(renderer),
#[cfg(feature = "debug")]
CosmicMappedRenderElement::Egui(elem) => {
let glow_renderer = renderer.glow_renderer();
let glow_renderer = renderer.glow_renderer_mut();
match elem.underlying_storage(glow_renderer) {
Some(UnderlyingStorage::Wayland(buffer)) => {
Some(UnderlyingStorage::Wayland(buffer))
@ -1015,7 +1015,7 @@ where
) {
Ok(element) => vec![element.into()],
Err(err) => {
slog_scope::debug!("Error rendering debug overlay: {}", err);
debug!(?err, "Error rendering debug overlay.");
Vec::new()
}
}

9
src/shell/focus/mod.rs
View file

@ -12,6 +12,7 @@ use smithay::{
utils::{IsAlive, Serial, SERIAL_COUNTER},
};
use std::cell::RefCell;
use tracing::{debug, info};
use self::target::{KeyboardFocusTarget, WindowGroup};
@ -100,7 +101,7 @@ impl Shell {
if let Some(workspace) = state.common.shell.space_for_mut(mapped) {
let mut focus_stack = workspace.focus_stack.get_mut(active_seat);
if Some(mapped) != focus_stack.last() {
slog_scope::debug!("Focusing window: {:?}", mapped);
debug!(?mapped, "Focusing window.");
focus_stack.append(mapped);
// also remove popup grabs, if we are switching focus
if let Some(mut popup_grab) = active_seat
@ -202,7 +203,7 @@ impl Common {
{
continue; // Focus is valid
} else {
slog_scope::debug!("Wrong Window, focus fixup");
debug!("Wrong Window, focus fixup");
}
}
KeyboardFocusTarget::LayerSurface(layer) => {
@ -223,7 +224,7 @@ impl Common {
} // Focus is valid
};
} else {
slog_scope::debug!("Surface dead, focus fixup");
debug!("Surface dead, focus fixup");
}
} else {
continue;
@ -262,7 +263,7 @@ impl Common {
.map(KeyboardFocusTarget::from)
});
if let Some(keyboard) = seat.get_keyboard() {
slog_scope::info!("restoring focus to: {:?}", target.as_ref());
info!("Restoring focus to {:?}", target.as_ref());
keyboard.set_focus(state, target.clone(), SERIAL_COUNTER.next_serial());
ActiveFocus::set(&seat, target);
}

10
src/shell/layout/floating/mod.rs
View file

@ -24,19 +24,11 @@ use crate::{
mod grabs;
pub use self::grabs::*;
#[derive(Debug)]
#[derive(Debug, Default)]
pub struct FloatingLayout {
pub(in crate::shell) space: Space<CosmicMapped>,
}
impl Default for FloatingLayout {
fn default() -> Self {
FloatingLayout {
space: Space::new(None),
}
}
}
impl FloatingLayout {
pub fn new() -> FloatingLayout {
Default::default()

5
src/shell/layout/tiling/mod.rs
View file

@ -31,6 +31,7 @@ use smithay::{
wayland::seat::WaylandFocus,
};
use std::{borrow::Borrow, collections::HashMap, hash::Hash, sync::Arc};
use tracing::debug;
mod grabs;
pub use self::grabs::*;
@ -420,7 +421,7 @@ impl TilingLayout {
});
// remove self
slog_scope::debug!("Remove window {:?}", mapped);
debug!(?mapped, "Remove window.");
let _ = tree.remove_node(node_id.clone(), RemoveBehavior::DropChildren);
// fixup parent node
@ -433,7 +434,7 @@ impl TilingLayout {
if group.len() > 2 {
group.remove_window(position);
} else {
slog_scope::debug!("Removing Group");
debug!("Removing Group");
let other_child =
tree.children_ids(&id).unwrap().cloned().next().unwrap();
let fork_pos = parent_parent_id.as_ref().and_then(|parent_id| {

9
src/shell/mod.rs
View file

@ -1,5 +1,6 @@
use serde::{Deserialize, Serialize};
use std::{cell::RefCell, collections::HashMap};
use tracing::warn;
use cosmic_protocols::workspace::v1::server::zcosmic_workspace_handle_v1::State as WState;
use smithay::{
@ -430,8 +431,8 @@ impl WorkspaceMode {
impl Shell {
pub fn new(config: &Config, dh: &DisplayHandle) -> Self {
// TODO: Privileged protocols
let layer_shell_state = WlrLayerShellState::new::<State, _>(dh, None);
let xdg_shell_state = XdgShellState::new::<State, _>(dh, None);
let layer_shell_state = WlrLayerShellState::new::<State>(dh);
let xdg_shell_state = XdgShellState::new::<State>(dh);
let toplevel_info_state = ToplevelInfoState::new(
dh,
//|client| client.get_data::<ClientState>().map_or(false, |s| s.privileged),
@ -461,7 +462,7 @@ impl Shell {
);
Shell {
popups: PopupManager::new(None),
popups: PopupManager::default(),
outputs: Vec::new(),
workspaces: mode,
tiling_enabled,
@ -1090,7 +1091,7 @@ impl Shell {
.find(|xwm| Some(xwm.id()) == surface.xwm_id())
{
if let Err(err) = xwm.update_stacking_order_downwards(workspace.mapped()) {
slog_scope::warn!("Failed to update Xwayland stacking order: {}", err);
warn!(?err, "Failed to update Xwayland stacking order.");
}
}
}

22
src/shell/workspace.rs
View file

@ -32,6 +32,7 @@ use smithay::{
xwayland::X11Surface,
};
use std::collections::HashMap;
use tracing::warn;
use super::{
element::CosmicMapped,
@ -498,10 +499,10 @@ impl Workspace {
if let Err(err) =
xwm.update_stacking_order_upwards(render_elements.iter().rev().map(|e| e.id()))
{
slog_scope::warn!(
"Failed to update Xwm ({:?}) stacking order: {}",
xwm.id(),
err
warn!(
wm_id = ?xwm.id(),
?err,
"Failed to update Xwm stacking order.",
);
}
}
@ -578,10 +579,10 @@ impl Workspace {
if let Err(err) =
xwm.update_stacking_order_upwards(render_elements.iter().rev().map(|e| e.id()))
{
slog_scope::warn!(
"Failed to update Xwm ({:?}) stacking order: {}",
xwm.id(),
err
warn!(
wm_id = ?xwm.id(),
?err,
"Failed to update Xwm stacking order.",
);
}
}
@ -711,11 +712,10 @@ where
src: Rectangle<f64, BufferCoords>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, smithay::utils::Physical>],
log: &slog::Logger,
) -> Result<(), <R as Renderer>::Error> {
match self {
WorkspaceRenderElement::Wayland(elem) => elem.draw(frame, src, dst, damage, log),
WorkspaceRenderElement::Window(elem) => elem.draw(frame, src, dst, damage, log),
WorkspaceRenderElement::Wayland(elem) => elem.draw(frame, src, dst, damage),
WorkspaceRenderElement::Window(elem) => elem.draw(frame, src, dst, damage),
}
}

22
src/state.rs
View file

@ -53,6 +53,7 @@ use smithay::{
viewporter::ViewporterState,
},
};
use tracing::error;
use std::{cell::RefCell, collections::HashMap, ffi::OsString, time::Duration};
use std::{collections::VecDeque, time::Instant};
@ -206,7 +207,7 @@ impl BackendData {
BackendData::X11(ref mut state) => state.schedule_render(output, screencopy),
BackendData::Kms(ref mut state) => {
if let Err(err) = state.schedule_render(loop_handle, output, None, screencopy) {
slog_scope::crit!("Failed to schedule event, are we shutting down? {:?}", err);
error!(?err, "Failed to schedule event, are we shutting down?");
}
}
_ => unreachable!("No backend was initialized"),
@ -223,29 +224,26 @@ impl State {
) -> State {
let clock = Clock::new().expect("Failed to initialize clock");
let config = Config::load();
let compositor_state = CompositorState::new::<Self, _>(dh, None);
let data_device_state = DataDeviceState::new::<Self, _>(dh, None);
let compositor_state = CompositorState::new::<Self>(dh);
let data_device_state = DataDeviceState::new::<Self>(dh);
let dmabuf_state = DmabufState::new();
let keyboard_shortcuts_inhibit_state = KeyboardShortcutsInhibitState::new::<Self>(dh);
let output_state = OutputManagerState::new_with_xdg_output::<Self>(dh);
let output_configuration_state = OutputConfigurationState::new(dh, |_| true);
let presentation_state = PresentationState::new::<Self>(dh, clock.id() as u32);
let primary_selection_state = PrimarySelectionState::new::<Self, _>(dh, None);
let primary_selection_state = PrimarySelectionState::new::<Self>(dh);
let screencopy_state = ScreencopyState::new::<Self, _, _>(
dh,
vec![CursorMode::Embedded, CursorMode::Hidden],
|_| true,
); // TODO: privileged
let shm_state = ShmState::new::<Self, _>(
dh,
vec![wl_shm::Format::Xbgr8888, wl_shm::Format::Abgr8888],
None,
);
let shm_state =
ShmState::new::<Self>(dh, vec![wl_shm::Format::Xbgr8888, wl_shm::Format::Abgr8888]);
let seat_state = SeatState::<Self>::new();
let viewporter_state = ViewporterState::new::<Self, _>(dh, None);
let viewporter_state = ViewporterState::new::<Self>(dh);
let wl_drm_state = WlDrmState;
let kde_decoration_state = KdeDecorationState::new::<Self, _>(&dh, Mode::Client, None);
let xdg_decoration_state = XdgDecorationState::new::<Self, _>(&dh, None);
let kde_decoration_state = KdeDecorationState::new::<Self>(&dh, Mode::Client);
let xdg_decoration_state = XdgDecorationState::new::<Self>(&dh);
let shell = Shell::new(&config, dh);

14
src/systemd.rs
View file

@ -3,6 +3,7 @@
use crate::state::State;
use libsystemd::daemon::{booted, notify, NotifyState};
use std::process::Command;
use tracing::{error, warn};
pub fn ready(state: &State) {
if booted() {
@ -22,18 +23,15 @@ pub fn ready(state: &State) {
.status()
{
Ok(x) if x.success() => {}
Ok(x) => slog_scope::warn!(
"Failed to import WAYLAND_DISPLAY/DISPLAY into systemd (exit code {:?})",
x.code()
),
Err(err) => slog_scope::error!(
"Failed to run systemctl although booted with systemd: {}",
err
Ok(x) => warn!(
exit_code = ?x.code(),
"Failed to import WAYLAND_DISPLAY/DISPLAY into systemd",
),
Err(err) => error!(?err, "Failed to run systemctl although booted with systemd",),
};
if let Err(err) = notify(false, &[NotifyState::Ready]) {
slog_scope::error!("Failed to notify systemd: {}", err);
error!(?err, "Failed to notify systemd");
}
}
}

1
src/utils/iced.rs
View file

@ -613,7 +613,6 @@ where
size.to_f64().to_logical(1.0, Transform::Normal),
)),
Some(internal_ref.size),
slog_scope::logger(),
) {
return vec![C::from(buffer)];
}

4
src/wayland/handlers/compositor.rs
View file

@ -128,9 +128,7 @@ impl CompositorHandler for State {
CosmicSurface::Wayland(ref wl_window) => {
let toplevel = wl_window.toplevel();
if self.toplevel_ensure_initial_configure(&toplevel)
&& with_renderer_surface_state(&surface, |state| {
state.wl_buffer().is_some()
})
&& with_renderer_surface_state(&surface, |state| state.buffer().is_some())
{
let output = seat.active_output();
Shell::map_window(self, &window, &output);

7
src/wayland/handlers/data_device.rs
View file

@ -13,6 +13,7 @@ use smithay::{
xwayland::xwm::{SelectionType, XwmId},
};
use std::{cell::RefCell, os::unix::io::OwnedFd};
use tracing::warn;
pub struct DnDIcon {
surface: RefCell<Option<WlSurface>>,
@ -66,10 +67,10 @@ impl DataDeviceHandler for State {
Some(metadata.mime_types.clone()),
)
}) {
slog_scope::warn!("Failed to set Xwayland clipboard selection: {}", err);
warn!(?err, "Failed to set Xwayland clipboard selection.");
}
} else if let Err(err) = xwm.new_selection(SelectionType::Clipboard, None) {
slog_scope::warn!("Failed to clear Xwayland clipboard selection: {}", err);
warn!(?err, "Failed to clear Xwayland clipboard selection.");
}
}
}
@ -94,7 +95,7 @@ impl DataDeviceHandler for State {
fd,
self.common.event_loop_handle.clone(),
) {
slog_scope::warn!("Failed to send clipboard (X11 -> Wayland): {}", err);
warn!(?err, "Failed to send clipboard (X11 -> Wayland).");
}
}
}

13
src/wayland/handlers/output_configuration.rs
View file

@ -1,6 +1,7 @@
// SPDX-License-Identifier: GPL-3.0-only
use smithay::output::Output;
use tracing::{error, warn};
use crate::{
config::OutputConfig,
@ -89,10 +90,10 @@ impl State {
seats.iter().cloned(),
&self.common.event_loop_handle,
) {
slog_scope::warn!(
"Failed to apply config to {}: {}. Resetting",
warn!(
?err,
"Failed to apply config to {}. Resetting",
output.name(),
err
);
for (output, backup) in backups {
{
@ -111,11 +112,7 @@ impl State {
seats.iter().cloned(),
&self.common.event_loop_handle,
) {
slog_scope::error!(
"Failed to reset output config for {}: {}",
output.name(),
err
);
error!(?err, "Failed to reset output config for {}.", output.name(),);
}
}
}

7
src/wayland/handlers/primary_selection.rs
View file

@ -5,6 +5,7 @@ use smithay::{
delegate_primary_selection,
wayland::primary_selection::{PrimarySelectionHandler, PrimarySelectionState, with_source_metadata}, xwayland::xwm::{XwmId, SelectionType}, reexports::wayland_protocols::wp::primary_selection::zv1::server::zwp_primary_selection_source_v1::ZwpPrimarySelectionSourceV1,
};
use tracing::warn;
use std::os::unix::io::OwnedFd;
@ -22,10 +23,10 @@ impl PrimarySelectionHandler for State {
if let Ok(Err(err)) = with_source_metadata(source, |metadata| {
xwm.new_selection(SelectionType::Primary, Some(metadata.mime_types.clone()))
}) {
slog_scope::warn!("Failed to set Xwayland primary selection: {}", err);
warn!(?err, "Failed to set Xwayland primary selection");
}
} else if let Err(err) = xwm.new_selection(SelectionType::Primary, None) {
slog_scope::warn!("Failed to clear Xwayland primary selection: {}", err);
warn!(?err, "Failed to clear Xwayland primary selection");
}
}
}
@ -50,7 +51,7 @@ impl PrimarySelectionHandler for State {
fd,
self.common.event_loop_handle.clone(),
) {
slog_scope::warn!("Failed to send primary selection (X11 -> Wayland): {}", err);
warn!(?err, "Failed to send primary selection (X11 -> Wayland).");
}
}
}

23
src/wayland/handlers/screencopy.rs
View file

@ -39,6 +39,7 @@ use smithay::{
},
xwayland::XWaylandClientData,
};
use tracing::warn;
use crate::{
backend::render::{
@ -250,7 +251,7 @@ impl ScreencopyHandler for State {
let buffer_size = match buffer_dimensions(&params.buffer) {
Some(size) => size.to_logical(1, Transform::Normal),
None => {
slog_scope::warn!("Error during screencopy session: Buffer has no size");
warn!("Error during screencopy session: Buffer has no size");
session.failed(FailureReason::InvalidBuffer);
return;
}
@ -260,7 +261,7 @@ impl ScreencopyHandler for State {
let mode = match output.current_mode() {
Some(mode) => mode,
None => {
slog_scope::warn!("Error during screencopy session: Output has no mode");
warn!("Error during screencopy session: Output has no mode");
session.failed(FailureReason::InvalidOutput);
return;
}
@ -268,7 +269,7 @@ impl ScreencopyHandler for State {
.size;
if buffer_size.to_physical(1) != mode {
slog_scope::warn!("Error during screencopy session: Buffer size doesn't match");
warn!("Error during screencopy session: Buffer size doesn't match");
session.failed(FailureReason::InvalidSize);
return;
}
@ -276,7 +277,7 @@ impl ScreencopyHandler for State {
SessionType::Window(window) => {
let geometry = window.geometry();
if buffer_size != geometry.size {
slog_scope::warn!("Error during screencopy session: Buffer size doesn't match");
warn!("Error during screencopy session: Buffer size doesn't match");
session.failed(FailureReason::InvalidSize);
return;
}
@ -288,7 +289,7 @@ impl ScreencopyHandler for State {
buffer_type(&params.buffer),
Some(BufferType::Shm) | Some(BufferType::Dma)
) {
slog_scope::warn!("Error during screencopy session: Buffer is neither shm or dma");
warn!("Error during screencopy session: Buffer is neither shm or dma");
session.failed(FailureReason::InvalidBuffer);
return;
}
@ -299,7 +300,7 @@ impl ScreencopyHandler for State {
})
.unwrap()
{
slog_scope::warn!("Error during screencopy session: Invalid shm buffer format");
warn!("Error during screencopy session: Invalid shm buffer format");
session.failed(FailureReason::InvalidBuffer);
return;
}
@ -368,8 +369,8 @@ impl ScreencopyHandler for State {
buffer.release();
}
Ok(true) => {} // success
Err((reason, error)) => {
slog_scope::warn!("Error during screencopy session: {}", error);
Err((reason, err)) => {
warn!(?err, "Error during screencopy session");
session.failed(reason);
}
}
@ -955,7 +956,7 @@ pub fn render_window_to_buffer(
.map_err(DamageTrackedRendererError::Rendering)?;
}
dtr.render_output(renderer, age, &elements, CLEAR_COLOR, None)
dtr.render_output(renderer, age, &elements, CLEAR_COLOR)
}
let node = node_from_params(&params, &mut state.backend, None);
@ -1134,7 +1135,7 @@ impl State {
Ok(false) => data.state.common.still_pending(session, params),
Ok(true) => {} // success
Err((reason, err)) => {
slog_scope::warn!("Screencopy session failed: {}", err);
warn!(?err, "Screencopy session failed");
session.failed(reason);
}
}
@ -1263,7 +1264,7 @@ pub fn schedule_offscreen_workspace_session(
}
Ok(true) => {}
Err((reason, err)) => {
slog_scope::warn!("Screencopy session failed: {}", err);
warn!(?err, "Screencopy session failed.");
session.failed(reason);
}
}

7
src/wayland/handlers/xdg_shell/mod.rs
View file

@ -22,6 +22,7 @@ use smithay::{
},
};
use std::cell::Cell;
use tracing::warn;
use super::screencopy::PendingScreencopyBuffers;
@ -125,9 +126,9 @@ impl XdgShellHandler for State {
self.common.shell.unconstrain_popup(&surface, &positioner);
surface.send_repositioned(token);
if let Err(err) = surface.send_configure() {
slog_scope::warn!(
"Client bug: Unable to re-configure repositioned popup: {}",
err
warn!(
?err,
"Client bug: Unable to re-configure repositioned popup.",
);
}
}

13
src/wayland/handlers/xdg_shell/popup.rs
View file

@ -24,6 +24,7 @@ use smithay::{
},
};
use std::sync::Mutex;
use tracing::{debug, warn};
impl Shell {
pub fn unconstrain_popup(&self, surface: &PopupSurface, positioner: &PositionerState) {
@ -86,9 +87,9 @@ pub fn update_reactive_popups<'a>(
{
unconstrain_xdg_popup(&surface, loc, rect);
if let Err(err) = surface.send_configure() {
slog_scope::warn!(
"Compositor bug: Unable to re-configure reactive popup: {}",
err
warn!(
?err,
"Compositor bug: Unable to re-configure reactive popup",
);
}
}
@ -103,7 +104,7 @@ fn unconstrain_xdg_popup_tile(surface: &PopupSurface, rect: Rectangle<i32, Logic
let offset = check_constrained(geometry, rect);
if offset.x != 0 || offset.y != 0 {
slog_scope::debug!("Unconstraining popup to tile: {:?}", surface);
debug!(?surface, "Unconstraining popup to tile.");
if !unconstrain_flip(&surface, rect) {
return unconstrain_slide(&surface, rect);
// don't try to resize for fitting to a tile
@ -123,7 +124,7 @@ fn unconstrain_xdg_popup(
let offset = check_constrained(geometry, relative);
if offset.x != 0 || offset.y != 0 {
slog_scope::debug!("Unconstraining popup: {:?}", surface);
debug!(?surface, "Unconstraining popup.");
if !unconstrain_flip(&surface, relative) {
if !unconstrain_slide(&surface, relative) {
unconstrain_resize(&surface, relative);
@ -143,7 +144,7 @@ fn unconstrain_layer_popup(surface: &PopupSurface, output: &Output, layer_surfac
let offset = check_constrained(geometry, relative);
if offset.x != 0 || offset.y != 0 {
slog_scope::debug!("Unconstraining popup: {:?}", surface);
debug!(?surface, "Unconstraining popup.");
if !unconstrain_flip(&surface, relative) {
if !unconstrain_slide(&surface, relative) {
unconstrain_resize(&surface, relative);

7
src/wayland/protocols/drm.rs
View file

@ -34,6 +34,7 @@ use smithay::{
dmabuf::{DmabufGlobal, DmabufHandler, ImportError},
},
};
use tracing::trace;
use std::{convert::TryFrom, path::PathBuf, sync::Arc};
@ -44,7 +45,6 @@ pub struct DrmGlobalData {
filter: Box<dyn for<'a> Fn(&'a Client) -> bool + Send + Sync>,
formats: Arc<Vec<Fourcc>>,
device_path: PathBuf,
_logger: slog::Logger,
dmabuf_global: DmabufGlobal,
}
@ -165,9 +165,7 @@ where
Ok(_) => {
// import was successful
data_init.init(id, dmabuf);
slog_scope::trace!(
"Created a new validated dma wl_buffer via wl_drm."
);
trace!("Created a new validated dma wl_buffer via wl_drm.");
}
Err(ImportError::InvalidFormat) => {
@ -246,7 +244,6 @@ impl WlDrmState {
formats,
device_path,
dmabuf_global: dmabuf_global.clone(),
_logger: slog_scope::logger().new(slog::o!("cosmic_module" => "wayland_drm")),
};
display.create_global::<D, wl_drm::WlDrm, _>(2, data)

5
src/wayland/protocols/screencopy.rs
View file

@ -24,6 +24,7 @@ use smithay::{
},
utils::{user_data::UserDataMap, Buffer, IsAlive, Physical, Point, Rectangle, Size, Transform},
};
use tracing::warn;
use wayland_backend::{
protocol::WEnum,
server::{GlobalId, ObjectId},
@ -540,7 +541,7 @@ fn check_cursor(
match cursor.into_result() {
Ok(mode) => {
if !supported.contains(&mode) {
slog_scope::warn!("Client did send unsupported cursor mode: {:?}", mode);
warn!(?mode, "Client did send unsupported cursor mode");
resource.post_error(
zcosmic_screencopy_manager_v1::Error::InvalidCursorMode,
"Unsupported cursor mode",
@ -550,7 +551,7 @@ fn check_cursor(
Some(mode)
}
Err(err) => {
slog_scope::warn!("Client did send unknown cursor mode: {}", err);
warn!(?err, "Client did send unknown cursor mode");
resource.post_error(
zcosmic_screencopy_manager_v1::Error::InvalidCursorMode,
"Unknown cursor mode, wrong protocol version?",

38
src/xwayland.rs
View file

@ -27,6 +27,7 @@ use smithay::{
X11Surface, X11Wm, XWayland, XWaylandEvent, XwmHandler,
},
};
use tracing::{error, info, warn};
pub struct XWaylandState {
pub xwm: Option<X11Wm>,
@ -41,7 +42,7 @@ impl State {
return;
}
let (xwayland, source) = XWayland::new(None, &self.common.display_handle);
let (xwayland, source) = XWayland::new(&self.common.display_handle);
let token =
match self
.common
@ -58,11 +59,10 @@ impl State {
data.state.common.display_handle.clone(),
connection,
client,
None,
) {
Ok(wm) => wm,
Err(err) => {
slog_scope::error!("Failed to start Xwayland WM: {}", err);
error!(?err, "Failed to start Xwayland WM");
return;
}
};
@ -74,10 +74,10 @@ impl State {
Size::from((image.width as u16, image.height as u16)),
Point::from((image.xhot as u16, image.yhot as u16)),
) {
slog_scope::warn!(
"Failed to set default cursor for Xwayland WM ({:?}): {}",
wm.id(),
err
warn!(
id = ?wm.id(),
?err,
"Failed to set default cursor for Xwayland WM",
);
}
@ -95,7 +95,7 @@ impl State {
}) {
Ok(token) => token,
Err(err) => {
slog_scope::error!("Failed to listen for Xwayland: {}", err);
error!(?err, "Failed to listen for Xwayland");
return;
}
};
@ -122,7 +122,7 @@ impl State {
);
}
Err(err) => {
slog_scope::error!("Failed to start Xwayland: {}", err);
error!(?err, "Failed to start Xwayland.");
self.common.event_loop_handle.remove(token);
}
}
@ -146,11 +146,7 @@ impl XwmHandler for Data {
fn map_window_request(&mut self, _xwm: XwmId, window: X11Surface) {
if let Err(err) = window.set_mapped(true) {
slog_scope::warn!(
"Failed to send Xwayland Mapped-Event (for window {:?}): {}",
window,
err
);
warn!(?window, ?err, "Failed to send Xwayland Mapped-Event",);
}
let surface = CosmicSurface::X11(window.clone());
@ -471,17 +467,17 @@ impl XwmHandler for Data {
match selection {
SelectionType::Clipboard => {
if let Err(err) = request_data_device_client_selection(seat, mime_type, fd) {
slog_scope::error!(
"Failed to request current wayland clipboard for Xwayland: {}",
err
error!(
?err,
"Failed to request current wayland clipboard for Xwayland.",
);
}
}
SelectionType::Primary => {
if let Err(err) = request_primary_client_selection(seat, mime_type, fd) {
slog_scope::error!(
"Failed to request current wayland primary selection for Xwayland: {}",
err
error!(
?err,
"Failed to request current wayland primary selection for Xwayland.",
);
}
}
@ -493,7 +489,7 @@ impl XwmHandler for Data {
}
fn new_selection(&mut self, xwm: XwmId, selection: SelectionType, mime_types: Vec<String>) {
slog_scope::info!("Got Selection {:?} from X11: {:?}", selection, mime_types);
info!(?selection, ?mime_types, "Got Selection from Xwayland",);
if self.state.common.is_x_focused(xwm) {
let seat = self.state.common.last_active_seat();