kossLAN/wry
1
0
Fork 0
forked from wry/wry
Code Pull requests Activity

all: warn on unsafe-op-in-unsafe-fn

Browse source
This commit is contained in:
Julian Orth 2024-10-20 18:39:11 +02:00
parent ce7488aa86
commit 73a6e0d5c2
25 changed files with 435 additions and 340 deletions
Download patch file Download diff file Expand all files Collapse all files

4
build/egl.rs
View file

@ -155,11 +155,13 @@ fn write_egl_procs<W: Write>(f: &mut W) -> anyhow::Result<()> {
writeln!(f, " if self.{}.is_null() {{", name)?;
writeln!(f, " panic!(\"Could not load `{}`\");", name)?;
writeln!(f, " }}")?;
writeln!(f, " unsafe {{")?;
writeln!(
f,
" ptr::read(&self.{} as *const *mut u8 as *const unsafe extern fn({}) -> {})({})",
" ptr::read(&self.{} as *const *mut u8 as *const unsafe extern fn({}) -> {})({})",
name, args_tys, ret, args_names
)?;
writeln!(f, " }}")?;
writeln!(f, " }}")?;
}
writeln!(f, "}}")?;

172
src/async_engine/ae_task.rs
View file

@ -49,27 +49,31 @@ impl<T: 'static, F: Future<Output = T>> SpawnedFutureVTableProxy<T, F> {
};
unsafe fn poll(data: *mut u8, ctx: &mut Context<'_>) -> Poll<T> {
let task = (data as *const Task<T, F>).deref();
if &task.state & COMPLETED == 0 {
task.waker.set(Some(ctx.waker().clone()));
Poll::Pending
} else if &task.state & EMPTIED == 0 {
task.state.or_assign(EMPTIED);
Poll::Ready(ptr::read(&*task.data.get().deref().result))
} else {
panic!("Future polled after it has already been emptied");
unsafe {
let task = (data as *const Task<T, F>).deref();
if &task.state & COMPLETED == 0 {
task.waker.set(Some(ctx.waker().clone()));
Poll::Pending
} else if &task.state & EMPTIED == 0 {
task.state.or_assign(EMPTIED);
Poll::Ready(ptr::read(&*task.data.get().deref().result))
} else {
panic!("Future polled after it has already been emptied");
}
}
}
unsafe fn drop(data: *mut u8) {
{
let task = (data as *const Task<T, F>).deref();
task.state.or_assign(CANCELLED);
if &task.state & RUNNING == 0 {
task.drop_data();
unsafe {
{
let task = (data as *const Task<T, F>).deref();
task.state.or_assign(CANCELLED);
if &task.state & RUNNING == 0 {
task.drop_data();
}
}
Task::<T, F>::dec_ref_count(data as _);
}
Task::<T, F>::dec_ref_count(data as _);
}
}
@ -160,27 +164,33 @@ impl<T, F: Future<Output = T>> Task<T, F> {
);
unsafe fn run_proxy(data: *const u8, run: bool) {
let task = data as *const Self;
if run {
task.deref().run();
} else {
Self::task_runnable_dropped(task);
unsafe {
let task = data as *const Self;
if run {
task.deref().run();
} else {
Self::task_runnable_dropped(task);
}
Self::dec_ref_count(task);
}
Self::dec_ref_count(task);
}
#[cold]
unsafe fn task_runnable_dropped(task: *const Self) {
let task = task.deref();
task.state.and_assign(!RUNNING);
if task.state.get() & CANCELLED != 0 {
task.drop_data();
unsafe {
let task = task.deref();
task.state.and_assign(!RUNNING);
if task.state.get() & CANCELLED != 0 {
task.drop_data();
}
}
}
unsafe fn dec_ref_count(slf: *const Self) {
if slf.deref().ref_count.fetch_sub(1) == 1 {
drop(Box::from_raw(slf as *mut Self));
unsafe {
if slf.deref().ref_count.fetch_sub(1) == 1 {
drop(Box::from_raw(slf as *mut Self));
}
}
}
@ -189,80 +199,92 @@ impl<T, F: Future<Output = T>> Task<T, F> {
}
unsafe fn waker_clone(data: *const ()) -> RawWaker {
let task = &mut *(data as *mut Self);
task.inc_ref_count();
RawWaker::new(data, Self::VTABLE)
unsafe {
let task = &mut *(data as *mut Self);
task.inc_ref_count();
RawWaker::new(data, Self::VTABLE)
}
}
unsafe fn waker_wake(data: *const ()) {
Self::waker_wake_by_ref(data);
Self::waker_drop(data);
unsafe {
Self::waker_wake_by_ref(data);
Self::waker_drop(data);
}
}
unsafe fn waker_wake_by_ref(data: *const ()) {
(data as *const Self).deref().schedule_run();
unsafe {
(data as *const Self).deref().schedule_run();
}
}
unsafe fn waker_drop(data: *const ()) {
Self::dec_ref_count(data as _)
unsafe { Self::dec_ref_count(data as _) }
}
unsafe fn schedule_run(&self) {
if &self.state & (COMPLETED | CANCELLED) == 0 {
if &self.state & RUNNING == 0 {
self.state.or_assign(RUNNING);
self.inc_ref_count();
let data = self as *const _ as _;
self.queue.push(
Runnable {
data,
run: Self::run_proxy,
},
self.phase,
);
} else {
self.state.or_assign(RUN_AGAIN);
unsafe {
if &self.state & (COMPLETED | CANCELLED) == 0 {
if &self.state & RUNNING == 0 {
self.state.or_assign(RUNNING);
self.inc_ref_count();
let data = self as *const _ as _;
self.queue.push(
Runnable {
data,
run: Self::run_proxy,
},
self.phase,
);
} else {
self.state.or_assign(RUN_AGAIN);
}
}
}
}
unsafe fn run(&self) {
if &self.state & CANCELLED == 0 {
let data = self.data.get().deref_mut();
self.inc_ref_count();
let raw_waker = RawWaker::new(self as *const _ as _, Self::VTABLE);
let waker = Waker::from_raw(raw_waker);
unsafe {
if &self.state & CANCELLED == 0 {
let data = self.data.get().deref_mut();
self.inc_ref_count();
let raw_waker = RawWaker::new(self as *const _ as _, Self::VTABLE);
let waker = Waker::from_raw(raw_waker);
let mut ctx = Context::from_waker(&waker);
let poll = {
dynamic_zone!(self.zone);
Pin::new_unchecked(&mut *data.future).poll(&mut ctx)
};
if let Poll::Ready(d) = poll {
ManuallyDrop::drop(&mut data.future);
ptr::write(&mut data.result, ManuallyDrop::new(d));
self.state.or_assign(COMPLETED);
if let Some(waker) = self.waker.take() {
waker.wake();
let mut ctx = Context::from_waker(&waker);
let poll = {
dynamic_zone!(self.zone);
Pin::new_unchecked(&mut *data.future).poll(&mut ctx)
};
if let Poll::Ready(d) = poll {
ManuallyDrop::drop(&mut data.future);
ptr::write(&mut data.result, ManuallyDrop::new(d));
self.state.or_assign(COMPLETED);
if let Some(waker) = self.waker.take() {
waker.wake();
}
}
}
}
self.state.and_assign(!RUNNING);
self.state.and_assign(!RUNNING);
if &self.state & CANCELLED != 0 {
self.drop_data();
} else if &self.state & RUN_AGAIN != 0 {
self.state.and_assign(!RUN_AGAIN);
self.schedule_run()
if &self.state & CANCELLED != 0 {
self.drop_data();
} else if &self.state & RUN_AGAIN != 0 {
self.state.and_assign(!RUN_AGAIN);
self.schedule_run()
}
}
}
unsafe fn drop_data(&self) {
if &self.state & COMPLETED == 0 {
ManuallyDrop::drop(&mut self.data.get().deref_mut().future);
} else if &self.state & EMPTIED == 0 {
ManuallyDrop::drop(&mut self.data.get().deref_mut().result);
unsafe {
if &self.state & COMPLETED == 0 {
ManuallyDrop::drop(&mut self.data.get().deref_mut().future);
} else if &self.state & EMPTIED == 0 {
ManuallyDrop::drop(&mut self.data.get().deref_mut().result);
}
}
}
}

58
src/clientmem.rs
View file

@ -194,39 +194,43 @@ thread_local! {
}
unsafe fn kill() -> ! {
c::signal(c::SIGBUS, c::SIG_DFL);
raise(c::SIGBUS);
unsafe {
c::signal(c::SIGBUS, c::SIG_DFL);
raise(c::SIGBUS);
}
unreachable!();
}
unsafe extern "C" fn sigbus(sig: i32, info: &c::siginfo_t, _ucontext: *mut c::c_void) {
assert_eq!(sig, c::SIGBUS);
let mut memr_ptr = MEM.get();
while !memr_ptr.is_null() {
let memr = &*memr_ptr;
let mem = &*memr.mem;
let lo = mem.data as *mut u8 as usize;
let hi = lo + mem.len();
let fault_addr = info.si_addr() as usize;
if fault_addr < lo || fault_addr >= hi {
memr_ptr = memr.outer;
continue;
unsafe {
assert_eq!(sig, c::SIGBUS);
let mut memr_ptr = MEM.get();
while !memr_ptr.is_null() {
let memr = &*memr_ptr;
let mem = &*memr.mem;
let lo = mem.data as *mut u8 as usize;
let hi = lo + mem.len();
let fault_addr = info.si_addr() as usize;
if fault_addr < lo || fault_addr >= hi {
memr_ptr = memr.outer;
continue;
}
let res = c::mmap64(
lo as _,
hi - lo,
c::PROT_WRITE | c::PROT_READ,
c::MAP_ANONYMOUS | c::MAP_PRIVATE | c::MAP_FIXED,
-1,
0,
);
if res == c::MAP_FAILED {
kill();
}
mem.failed.set(true);
return;
}
let res = c::mmap64(
lo as _,
hi - lo,
c::PROT_WRITE | c::PROT_READ,
c::MAP_ANONYMOUS | c::MAP_PRIVATE | c::MAP_FIXED,
-1,
0,
);
if res == c::MAP_FAILED {
kill();
}
mem.failed.set(true);
return;
kill();
}
kill();
}
pub fn init() -> Result<(), ClientMemError> {

28
src/config.rs
View file

@ -170,7 +170,9 @@ unsafe extern "C" fn default_client_init(
extern "C" fn configure() {
jay_toml_config::configure();
}
jay_config::_private::client::init(srv_data, srv_unref, srv_handler, msg, size, configure)
unsafe {
jay_config::_private::client::init(srv_data, srv_unref, srv_handler, msg, size, configure)
}
}
impl ConfigProxy {
@ -279,11 +281,11 @@ impl ConfigProxy {
return Err(ConfigError::CopyConfigFile(e));
}
let unlink = UnlinkOnDrop(&copy);
let lib = match Library::new(&copy) {
let lib = match unsafe { Library::new(&copy) } {
Ok(l) => l,
Err(e) => return Err(ConfigError::CouldNotLoadLibrary(e)),
};
let entry = lib.get::<&'static ConfigEntry>(b"JAY_CONFIG_ENTRY_V1\0");
let entry = unsafe { lib.get::<&'static ConfigEntry>(b"JAY_CONFIG_ENTRY_V1\0") };
let entry = match entry {
Ok(e) => *e,
Err(e) => return Err(ConfigError::LibraryDoesNotContainEntry(e)),
@ -295,18 +297,22 @@ impl ConfigProxy {
unsafe extern "C" fn unref(data: *const u8) {
let server = data as *const ConfigProxyHandler;
drop(Rc::from_raw(server));
unsafe {
drop(Rc::from_raw(server));
}
}
unsafe extern "C" fn handle_msg(data: *const u8, msg: *const u8, size: usize) {
let server = (data as *const ConfigProxyHandler).deref();
if server.dropped.get() {
return;
unsafe {
let server = (data as *const ConfigProxyHandler).deref();
if server.dropped.get() {
return;
}
let rc = Rc::from_raw(server);
let msg = std::slice::from_raw_parts(msg, size);
rc.handle_request(msg);
mem::forget(rc);
}
let rc = Rc::from_raw(server);
let msg = std::slice::from_raw_parts(msg, size);
rc.handle_request(msg);
mem::forget(rc);
}
pub struct InvokedShortcut {

4
src/gfx_apis/gl/egl.rs
View file

@ -83,12 +83,12 @@ unsafe extern "C" fn egl_log(
_ => Level::Warn,
};
let command = if !command.is_null() {
CStr::from_ptr(command).to_bytes()
unsafe { CStr::from_ptr(command).to_bytes() }
} else {
b"none"
};
let message = if !message.is_null() {
CStr::from_ptr(message).to_bytes()
unsafe { CStr::from_ptr(message).to_bytes() }
} else {
b"none"
};

42
src/gfx_apis/gl/egl/context.rs
View file

@ -76,24 +76,30 @@ impl EglContext {
&self,
f: F,
) -> Result<T, RenderError> {
if (self.dpy.egl.eglMakeCurrent)(
self.dpy.dpy,
EGLSurface::none(),
EGLSurface::none(),
self.ctx,
) == EGL_FALSE
{
return Err(RenderError::MakeCurrent);
unsafe {
if (self.dpy.egl.eglMakeCurrent)(
self.dpy.dpy,
EGLSurface::none(),
EGLSurface::none(),
self.ctx,
) == EGL_FALSE
{
return Err(RenderError::MakeCurrent);
}
let prev = CURRENT.get();
CURRENT.set(self.ctx);
let res = f();
if (self.dpy.egl.eglMakeCurrent)(
self.dpy.dpy,
EGLSurface::none(),
EGLSurface::none(),
prev,
) == EGL_FALSE
{
panic!("Could not restore EGLContext");
}
CURRENT.set(prev);
res
}
let prev = CURRENT.get();
CURRENT.set(self.ctx);
let res = f();
if (self.dpy.egl.eglMakeCurrent)(self.dpy.dpy, EGLSurface::none(), EGLSurface::none(), prev)
== EGL_FALSE
{
panic!("Could not restore EGLContext");
}
CURRENT.set(prev);
res
}
}

52
src/gfx_apis/gl/egl/display.rs
View file

@ -312,21 +312,23 @@ unsafe fn query_formats(
) -> Result<AHashMap<u32, EglFormat>, RenderError> {
let mut vec = vec![];
let mut num = 0;
let res = procs.eglQueryDmaBufFormatsEXT(dpy, num, ptr::null_mut(), &mut num);
let res = unsafe { procs.eglQueryDmaBufFormatsEXT(dpy, num, ptr::null_mut(), &mut num) };
if res != EGL_TRUE {
return Err(RenderError::QueryDmaBufFormats);
}
vec.reserve_exact(num as usize);
let res = procs.eglQueryDmaBufFormatsEXT(dpy, num, vec.as_mut_ptr(), &mut num);
let res = unsafe { procs.eglQueryDmaBufFormatsEXT(dpy, num, vec.as_mut_ptr(), &mut num) };
if res != EGL_TRUE {
return Err(RenderError::QueryDmaBufFormats);
}
vec.set_len(num as usize);
unsafe {
vec.set_len(num as usize);
}
let mut res = AHashMap::new();
let formats = formats();
for fmt in vec {
if let Some(format) = formats.get(&(fmt as u32)) {
let (modifiers, external_only) = query_modifiers(procs, dpy, fmt, format)?;
let (modifiers, external_only) = unsafe { query_modifiers(procs, dpy, fmt, format)? };
res.insert(
format.drm,
EglFormat {
@ -349,32 +351,38 @@ unsafe fn query_modifiers(
let mut mods = vec![];
let mut ext_only = vec![];
let mut num = 0;
let res = procs.eglQueryDmaBufModifiersEXT(
dpy,
gl_format,
num,
ptr::null_mut(),
ptr::null_mut(),
&mut num,
);
let res = unsafe {
procs.eglQueryDmaBufModifiersEXT(
dpy,
gl_format,
num,
ptr::null_mut(),
ptr::null_mut(),
&mut num,
)
};
if res != EGL_TRUE {
return Err(RenderError::QueryDmaBufModifiers);
}
mods.reserve_exact(num as usize);
ext_only.reserve_exact(num as usize);
let res = procs.eglQueryDmaBufModifiersEXT(
dpy,
gl_format,
num,
mods.as_mut_ptr(),
ext_only.as_mut_ptr(),
&mut num,
);
let res = unsafe {
procs.eglQueryDmaBufModifiersEXT(
dpy,
gl_format,
num,
mods.as_mut_ptr(),
ext_only.as_mut_ptr(),
&mut num,
)
};
if res != EGL_TRUE {
return Err(RenderError::QueryDmaBufModifiers);
}
mods.set_len(num as usize);
ext_only.set_len(num as usize);
unsafe {
mods.set_len(num as usize);
ext_only.set_len(num as usize);
}
let mut res = IndexMap::new();
for (modifier, ext_only) in mods.iter().copied().zip(ext_only.iter().copied()) {
res.insert(

10
src/gfx_apis/gl/ext.rs
View file

@ -19,7 +19,7 @@ unsafe fn get_extensions(ext: *const c::c_char) -> Option<AHashSet<String>> {
return None;
}
let mut res = AHashSet::new();
let ext = CStr::from_ptr(ext).to_bytes();
let ext = unsafe { CStr::from_ptr(ext).to_bytes() };
for part in ext.split_str(" ") {
let name = part.trim();
if name.len() > 0 {
@ -32,8 +32,10 @@ unsafe fn get_extensions(ext: *const c::c_char) -> Option<AHashSet<String>> {
}
unsafe fn get_dpy_extensions(dpy: EGLDisplay) -> Option<AHashSet<String>> {
let ext = (EGL.as_ref()?.eglQueryString)(dpy, EGL_EXTENSIONS);
get_extensions(ext)
unsafe {
let ext = (EGL.as_ref()?.eglQueryString)(dpy, EGL_EXTENSIONS);
get_extensions(ext)
}
}
fn get_typed_ext<T>(exts: &AHashSet<String>, mut base: T, map: &[(&str, T)]) -> T
@ -103,7 +105,7 @@ pub(crate) unsafe fn get_display_ext(dpy: EGLDisplay) -> DisplayExt {
("EGL_KHR_wait_sync", KHR_WAIT_SYNC),
("EGL_ANDROID_native_fence_sync", ANDROID_NATIVE_FENCE_SYNC),
];
match get_dpy_extensions(dpy) {
match unsafe { get_dpy_extensions(dpy) } {
Some(exts) => get_typed_ext(&exts, DisplayExt::none(), &map),
_ => DisplayExt::none(),
}

46
src/gfx_apis/gl/gl/program.rs
View file

@ -21,41 +21,45 @@ impl GlProgram {
vert: &str,
frag: &str,
) -> Result<Self, RenderError> {
let vert = GlShader::compile(ctx, GL_VERTEX_SHADER, vert)?;
let frag = GlShader::compile(ctx, GL_FRAGMENT_SHADER, frag)?;
Self::link(&vert, &frag)
unsafe {
let vert = GlShader::compile(ctx, GL_VERTEX_SHADER, vert)?;
let frag = GlShader::compile(ctx, GL_FRAGMENT_SHADER, frag)?;
Self::link(&vert, &frag)
}
}
pub(in crate::gfx_apis::gl) unsafe fn link(
vert: &GlShader,
frag: &GlShader,
) -> Result<Self, RenderError> {
let gles = vert.ctx.dpy.gles;
let res = GlProgram {
ctx: vert.ctx.clone(),
prog: (gles.glCreateProgram)(),
};
(gles.glAttachShader)(res.prog, vert.shader);
(gles.glAttachShader)(res.prog, frag.shader);
(gles.glLinkProgram)(res.prog);
(gles.glDetachShader)(res.prog, vert.shader);
(gles.glDetachShader)(res.prog, frag.shader);
unsafe {
let gles = vert.ctx.dpy.gles;
let res = GlProgram {
ctx: vert.ctx.clone(),
prog: (gles.glCreateProgram)(),
};
(gles.glAttachShader)(res.prog, vert.shader);
(gles.glAttachShader)(res.prog, frag.shader);
(gles.glLinkProgram)(res.prog);
(gles.glDetachShader)(res.prog, vert.shader);
(gles.glDetachShader)(res.prog, frag.shader);
let mut ok = 0;
(gles.glGetProgramiv)(res.prog, GL_LINK_STATUS, &mut ok);
if ok == GL_FALSE as GLint {
return Err(RenderError::ProgramLink);
let mut ok = 0;
(gles.glGetProgramiv)(res.prog, GL_LINK_STATUS, &mut ok);
if ok == GL_FALSE as GLint {
return Err(RenderError::ProgramLink);
}
Ok(res)
}
Ok(res)
}
pub unsafe fn get_uniform_location(&self, name: &CStr) -> GLint {
(self.ctx.dpy.gles.glGetUniformLocation)(self.prog, name.as_ptr() as _)
unsafe { (self.ctx.dpy.gles.glGetUniformLocation)(self.prog, name.as_ptr() as _) }
}
pub unsafe fn get_attrib_location(&self, name: &CStr) -> GLint {
(self.ctx.dpy.gles.glGetAttribLocation)(self.prog, name.as_ptr() as _)
unsafe { (self.ctx.dpy.gles.glGetAttribLocation)(self.prog, name.as_ptr() as _) }
}
}

73
src/gfx_apis/gl/gl/render_buffer.rs
View file

@ -39,10 +39,17 @@ impl GlRenderBuffer {
};
let gles = &ctx.dpy.gles;
let mut rbo = 0;
(gles.glGenRenderbuffers)(1, &mut rbo);
(gles.glBindRenderbuffer)(GL_RENDERBUFFER, rbo);
(gles.glRenderbufferStorage)(GL_RENDERBUFFER, shm_info.gl_internal_format, width, height);
(gles.glBindRenderbuffer)(GL_RENDERBUFFER, 0);
unsafe {
(gles.glGenRenderbuffers)(1, &mut rbo);
(gles.glBindRenderbuffer)(GL_RENDERBUFFER, rbo);
(gles.glRenderbufferStorage)(
GL_RENDERBUFFER,
shm_info.gl_internal_format,
width,
height,
);
(gles.glBindRenderbuffer)(GL_RENDERBUFFER, 0);
}
Ok(Rc::new(GlRenderBuffer {
_img: None,
ctx: ctx.clone(),
@ -63,12 +70,14 @@ impl GlRenderBuffer {
}
let gles = ctx.dpy.gles;
let mut rbo = 0;
(gles.glGenRenderbuffers)(1, &mut rbo);
(gles.glBindRenderbuffer)(GL_RENDERBUFFER, rbo);
ctx.dpy
.procs
.glEGLImageTargetRenderbufferStorageOES(GL_RENDERBUFFER, GLeglImageOES(img.img.0));
(gles.glBindRenderbuffer)(GL_RENDERBUFFER, 0);
unsafe {
(gles.glGenRenderbuffers)(1, &mut rbo);
(gles.glBindRenderbuffer)(GL_RENDERBUFFER, rbo);
ctx.dpy
.procs
.glEGLImageTargetRenderbufferStorageOES(GL_RENDERBUFFER, GLeglImageOES(img.img.0));
(gles.glBindRenderbuffer)(GL_RENDERBUFFER, 0);
}
Ok(Rc::new(GlRenderBuffer {
_img: Some(img.clone()),
ctx: ctx.clone(),
@ -85,28 +94,30 @@ impl GlRenderBuffer {
) -> Result<GlFrameBuffer, RenderError> {
let gles = self.ctx.dpy.gles;
let mut fbo = 0;
(gles.glGenFramebuffers)(1, &mut fbo);
(gles.glBindFramebuffer)(GL_FRAMEBUFFER, fbo);
(gles.glFramebufferRenderbuffer)(
GL_FRAMEBUFFER,
GL_COLOR_ATTACHMENT0,
GL_RENDERBUFFER,
self.rbo,
);
let status = (gles.glCheckFramebufferStatus)(GL_FRAMEBUFFER);
(gles.glBindFramebuffer)(GL_FRAMEBUFFER, 0);
let fb = GlFrameBuffer {
rb: self.clone(),
_tex: None,
ctx: self.ctx.clone(),
fbo,
width: self.width,
height: self.height,
};
if status != GL_FRAMEBUFFER_COMPLETE {
return Err(RenderError::CreateFramebuffer);
unsafe {
(gles.glGenFramebuffers)(1, &mut fbo);
(gles.glBindFramebuffer)(GL_FRAMEBUFFER, fbo);
(gles.glFramebufferRenderbuffer)(
GL_FRAMEBUFFER,
GL_COLOR_ATTACHMENT0,
GL_RENDERBUFFER,
self.rbo,
);
let status = (gles.glCheckFramebufferStatus)(GL_FRAMEBUFFER);
(gles.glBindFramebuffer)(GL_FRAMEBUFFER, 0);
let fb = GlFrameBuffer {
rb: self.clone(),
_tex: None,
ctx: self.ctx.clone(),
fbo,
width: self.width,
height: self.height,
};
if status != GL_FRAMEBUFFER_COMPLETE {
return Err(RenderError::CreateFramebuffer);
}
Ok(fb)
}
Ok(fb)
}
}

12
src/gfx_apis/gl/gl/shader.rs
View file

@ -20,17 +20,21 @@ impl GlShader {
src: &str,
) -> Result<Self, RenderError> {
let gles = ctx.dpy.gles;
let shader = (gles.glCreateShader)(ty);
let shader = unsafe { (gles.glCreateShader)(ty) };
let res = GlShader {
ctx: ctx.clone(),
shader,
};
let len = src.len() as _;
(gles.glShaderSource)(shader, 1, &(src.as_ptr() as _), &len);
(gles.glCompileShader)(shader);
unsafe {
(gles.glShaderSource)(shader, 1, &(src.as_ptr() as _), &len);
(gles.glCompileShader)(shader);
}
let mut ok = 0;
(gles.glGetShaderiv)(shader, GL_COMPILE_STATUS, &mut ok);
unsafe {
(gles.glGetShaderiv)(shader, GL_COMPILE_STATUS, &mut ok);
}
if ok == GL_FALSE as GLint {
return Err(RenderError::ShaderCompileFailed);
}

44
src/gfx_apis/gl/renderer/context.rs
View file

@ -44,16 +44,18 @@ pub(crate) struct TexProg {
impl TexProg {
unsafe fn from(prog: GlProgram, alpha_multiplier: bool) -> Self {
let alpha = match alpha_multiplier {
true => prog.get_uniform_location(c"alpha"),
false => 0,
};
Self {
pos: prog.get_attrib_location(c"pos"),
texcoord: prog.get_attrib_location(c"texcoord"),
tex: prog.get_uniform_location(c"tex"),
alpha,
prog,
unsafe {
let alpha = match alpha_multiplier {
true => prog.get_uniform_location(c"alpha"),
false => 0,
};
Self {
pos: prog.get_attrib_location(c"pos"),
texcoord: prog.get_attrib_location(c"texcoord"),
tex: prog.get_uniform_location(c"tex"),
alpha,
prog,
}
}
}
}
@ -129,8 +131,10 @@ impl GlRenderContext {
tex_frac_src.push_str("#define ALPHA\n");
}
tex_frac_src.push_str(tex_frag);
let prog = GlProgram::from_shaders(ctx, tex_vert, &tex_frac_src)?;
Ok::<_, RenderError>(TexProg::from(prog, alpha_multiplier))
unsafe {
let prog = GlProgram::from_shaders(ctx, tex_vert, &tex_frac_src)?;
Ok::<_, RenderError>(TexProg::from(prog, alpha_multiplier))
}
};
Ok::<_, RenderError>(enum_map! {
TexCopyType::Identity => enum_map! {
@ -149,11 +153,13 @@ impl GlRenderContext {
} else {
None
};
let fill_prog = GlProgram::from_shaders(
ctx,
include_str!("../shaders/fill.vert.glsl"),
include_str!("../shaders/fill.frag.glsl"),
)?;
let fill_prog = unsafe {
GlProgram::from_shaders(
ctx,
include_str!("../shaders/fill.vert.glsl"),
include_str!("../shaders/fill.frag.glsl"),
)?
};
Ok(Self {
ctx: ctx.clone(),
gbm: ctx.dpy.gbm.clone(),
@ -164,8 +170,8 @@ impl GlRenderContext {
tex_internal,
tex_external,
fill_prog_pos: fill_prog.get_attrib_location(c"pos"),
fill_prog_color: fill_prog.get_uniform_location(c"color"),
fill_prog_pos: unsafe { fill_prog.get_attrib_location(c"pos") },
fill_prog_color: unsafe { fill_prog.get_uniform_location(c"color") },
fill_prog,
gl_state: Default::default(),

16
src/gfx_apis/vulkan/allocator.rs
View file

@ -67,7 +67,9 @@ impl VulkanAllocation {
) {
allocator.total.fetch_sub(self.size);
let block = self.block.take().unwrap();
do_free(gpu, &device.device, block, self.mem);
unsafe {
do_free(gpu, &device.device, block, self.mem);
}
}
}
@ -363,12 +365,14 @@ unsafe fn do_free(
mut block: MemoryBlock<DeviceMemory>,
ptr: Option<*mut u8>,
) {
let device = AshMemoryDevice::wrap(device);
if let Some(_ptr) = ptr {
// log::info!("free = {:?} - {:?} ({})", ptr, ptr.add(block.size() as usize), block.size());
block.unmap(device);
unsafe {
let device = AshMemoryDevice::wrap(device);
if let Some(_ptr) = ptr {
// log::info!("free = {:?} - {:?} ({})", ptr, ptr.add(block.size() as usize), block.size());
block.unmap(device);
}
gpu.dealloc(device, block);
}
gpu.dealloc(device, block);
}
impl Drop for UnsyncAllocatorStorage {

2
src/gfx_apis/vulkan/bo_allocator.rs
View file

@ -671,7 +671,7 @@ impl Drop for VulkanBoMapping {
impl MappedBuffer for VulkanBoMapping {
unsafe fn data(&self) -> &[u8] {
&*self.data
unsafe { &*self.data }
}
fn data_ptr(&self) -> *mut u8 {

6
src/gfx_apis/vulkan/instance.rs
View file

@ -190,12 +190,12 @@ unsafe extern "system" fn debug_callback(
DebugUtilsMessageSeverityFlagsEXT::VERBOSE => Level::Trace,
_ => Level::Warn,
};
let data = &*p_callback_data;
let message = Ustr::from_ptr(data.p_message);
let data = unsafe { &*p_callback_data };
let message = unsafe { Ustr::from_ptr(data.p_message) };
let message_id_name = if data.p_message_id_name.is_null() {
ustr!("<null>")
} else {
Ustr::from_ptr(data.p_message_id_name)
unsafe { Ustr::from_ptr(data.p_message_id_name) }
};
log::log!(
Level::Info,

16
src/libinput.rs
View file

@ -41,12 +41,14 @@ unsafe extern "C" fn open_restricted(
_flags: c::c_int,
user_data: *mut c::c_void,
) -> c::c_int {
let ud = (user_data as *const UserData).deref();
match ud.adapter.open(CStr::from_ptr(path)) {
Ok(f) => f.unwrap(),
Err(e) => {
log::error!("Could not open device for libinput: {}", ErrorFmt(e));
-1
unsafe {
let ud = (user_data as *const UserData).deref();
match ud.adapter.open(CStr::from_ptr(path)) {
Ok(f) => f.unwrap(),
Err(e) => {
log::error!("Could not open device for libinput: {}", ErrorFmt(e));
-1
}
}
}
}
@ -173,7 +175,7 @@ unsafe extern "C" fn jay_libinput_log_handler(
line: *const c::c_char,
) {
assert!(line.is_not_null());
let str = CStr::from_ptr(line);
let str = unsafe { CStr::from_ptr(line) };
let priority = match LogPriority(priority as _) {
LIBINPUT_LOG_PRIORITY_DEBUG => log::Level::Debug,
LIBINPUT_LOG_PRIORITY_INFO => log::Level::Info,

2
src/main.rs
View file

@ -37,7 +37,7 @@
clippy::unnecessary_cast,
clippy::manual_flatten
)]
#![warn(clippy::allow_attributes)]
#![warn(clippy::allow_attributes, unsafe_op_in_unsafe_fn)]
#[macro_use]
mod macros;

18
src/pipewire/pw_mem.rs
View file

@ -88,21 +88,23 @@ impl PwMemMap {
#[expect(dead_code)]
pub unsafe fn read<T: Pod>(&self) -> &T {
self.check::<T>(0);
(self.map.ptr.cast::<u8>().add(self.range.start) as *const T).deref()
unsafe { (self.map.ptr.cast::<u8>().add(self.range.start) as *const T).deref() }
}
#[expect(dead_code)]
pub unsafe fn write<T: Pod>(&self) -> &mut T {
self.check::<T>(0);
(self.map.ptr.cast::<u8>().add(self.range.start) as *mut T).deref_mut()
unsafe { (self.map.ptr.cast::<u8>().add(self.range.start) as *mut T).deref_mut() }
}
#[expect(dead_code)]
pub unsafe fn bytes_mut(&self) -> &mut [u8] {
std::slice::from_raw_parts_mut(
self.map.ptr.cast::<u8>().add(self.range.start) as _,
self.range.len(),
)
unsafe {
std::slice::from_raw_parts_mut(
self.map.ptr.cast::<u8>().add(self.range.start) as _,
self.range.len(),
)
}
}
fn check<T>(&self, offset: usize) {
@ -136,11 +138,11 @@ impl PwMemMap {
impl<T: Pod> PwMemTyped<T> {
pub unsafe fn read(&self) -> &T {
(self.mem.map.ptr.cast::<u8>().add(self.offset) as *const T).deref()
unsafe { (self.mem.map.ptr.cast::<u8>().add(self.offset) as *const T).deref() }
}
pub unsafe fn write(&self) -> &mut T {
(self.mem.map.ptr.cast::<u8>().add(self.offset) as *mut T).deref_mut()
unsafe { (self.mem.map.ptr.cast::<u8>().add(self.offset) as *mut T).deref_mut() }
}
}

2
src/udmabuf.rs
View file

@ -241,7 +241,7 @@ impl Drop for UdmabufMap {
impl MappedBuffer for UdmabufMap {
unsafe fn data(&self) -> &[u8] {
&*self.data
unsafe { &*self.data }
}
fn data_ptr(&self) -> *mut u8 {

94
src/utils/linkedlist.rs
View file

@ -296,8 +296,10 @@ struct NodeData<T> {
}
unsafe fn dec_ref_count<T>(slf: NonNull<NodeData<T>>, n: usize) {
if slf.as_ref().rc.fetch_sub(n) == n {
drop(Box::from_raw(slf.as_ptr()));
unsafe {
if slf.as_ref().rc.fetch_sub(n) == n {
drop(Box::from_raw(slf.as_ptr()));
}
}
}
@ -337,55 +339,63 @@ impl<T> LinkedNode<T> {
}
unsafe fn prepend_existing<T>(data: NonNull<NodeData<T>>, t: &NodeRef<T>) {
let dref = data.as_ref();
let tref = t.data.as_ref();
if tref.rc.get() < LINKED_NODE_REF_COUNT {
log::error!("Trying to prepend a node whose linked node has already been dropped");
return;
unsafe {
let dref = data.as_ref();
let tref = t.data.as_ref();
if tref.rc.get() < LINKED_NODE_REF_COUNT {
log::error!("Trying to prepend a node whose linked node has already been dropped");
return;
}
t.detach();
tref.prev.set(dref.prev.get());
tref.next.set(data);
dref.prev.get().as_ref().next.set(t.data);
dref.prev.set(t.data);
}
t.detach();
tref.prev.set(dref.prev.get());
tref.next.set(data);
dref.prev.get().as_ref().next.set(t.data);
dref.prev.set(t.data);
}
unsafe fn prepend<T>(data: NonNull<NodeData<T>>, t: T) -> LinkedNode<T> {
let dref = data.as_ref();
let node = NonNull::new_unchecked(Box::into_raw(Box::new(NodeData {
rc: NumCell::new(LINKED_NODE_REF_COUNT),
prev: Cell::new(dref.prev.get()),
next: Cell::new(data),
data: Some(t),
})));
dref.prev.get().as_ref().next.set(node);
dref.prev.set(node);
LinkedNode { data: node }
unsafe {
let dref = data.as_ref();
let node = NonNull::new_unchecked(Box::into_raw(Box::new(NodeData {
rc: NumCell::new(LINKED_NODE_REF_COUNT),
prev: Cell::new(dref.prev.get()),
next: Cell::new(data),
data: Some(t),
})));
dref.prev.get().as_ref().next.set(node);
dref.prev.set(node);
LinkedNode { data: node }
}
}
unsafe fn append_existing<T>(data: NonNull<NodeData<T>>, t: &NodeRef<T>) {
let dref = data.as_ref();
let tref = t.data.as_ref();
if tref.rc.get() < LINKED_NODE_REF_COUNT {
log::error!("Trying to append a node whose linked node has already been dropped");
return;
unsafe {
let dref = data.as_ref();
let tref = t.data.as_ref();
if tref.rc.get() < LINKED_NODE_REF_COUNT {
log::error!("Trying to append a node whose linked node has already been dropped");
return;
}
t.detach();
tref.prev.set(data);
tref.next.set(dref.next.get());
dref.next.get().as_ref().prev.set(t.data);
dref.next.set(t.data);
}
t.detach();
tref.prev.set(data);
tref.next.set(dref.next.get());
dref.next.get().as_ref().prev.set(t.data);
dref.next.set(t.data);
}
unsafe fn append<T>(data: NonNull<NodeData<T>>, t: T) -> LinkedNode<T> {
let dref = data.as_ref();
let node = NonNull::new_unchecked(Box::into_raw(Box::new(NodeData {
rc: NumCell::new(LINKED_NODE_REF_COUNT),
prev: Cell::new(data),
next: Cell::new(dref.next.get()),
data: Some(t),
})));
dref.next.get().as_ref().prev.set(node);
dref.next.set(node);
LinkedNode { data: node }
unsafe {
let dref = data.as_ref();
let node = NonNull::new_unchecked(Box::into_raw(Box::new(NodeData {
rc: NumCell::new(LINKED_NODE_REF_COUNT),
prev: Cell::new(data),
next: Cell::new(dref.next.get()),
data: Some(t),
})));
dref.next.get().as_ref().prev.set(node);
dref.next.set(node);
LinkedNode { data: node }
}
}

6
src/utils/ptr_ext.rs
View file

@ -9,20 +9,20 @@ pub trait MutPtrExt<T: ?Sized> {
impl<T: ?Sized> PtrExt<T> for *const T {
#[inline(always)]
unsafe fn deref<'a>(self) -> &'a T {
&*self
unsafe { &*self }
}
}
impl<T: ?Sized> PtrExt<T> for *mut T {
#[inline(always)]
unsafe fn deref<'a>(self) -> &'a T {
&*self
unsafe { &*self }
}
}
impl<T: ?Sized> MutPtrExt<T> for *mut T {
#[inline(always)]
unsafe fn deref_mut<'a>(self) -> &'a mut T {
&mut *self
unsafe { &mut *self }
}
}

2
src/utils/vecstorage.rs
View file

@ -35,7 +35,7 @@ impl<T> VecStorage<T> {
}
unsafe fn to_vector<U>(&mut self) -> Vec<U> {
Vec::from_raw_parts(self.ptr as _, 0, self.cap)
unsafe { Vec::from_raw_parts(self.ptr as _, 0, self.cap) }
}
}

2
src/video/drm/sys.rs
View file

@ -23,7 +23,7 @@ use {
pub unsafe fn ioctl<T>(fd: c::c_int, request: c::c_ulong, t: &mut T) -> Result<c::c_int, OsError> {
let mut ret;
loop {
ret = c::ioctl(fd, request, &mut *t);
ret = unsafe { c::ioctl(fd, request, &mut *t) };
if ret != -1 {
return Ok(ret);
}

62
src/video/gbm.rs
View file

@ -158,7 +158,7 @@ pub struct GbmBoMap {
impl MappedBuffer for GbmBoMap {
unsafe fn data(&self) -> &[u8] {
&*self.data
unsafe { &*self.data }
}
fn data_ptr(&self) -> *mut u8 {
@ -171,36 +171,38 @@ impl MappedBuffer for GbmBoMap {
}
unsafe fn export_bo(dmabuf_ids: &DmaBufIds, bo: *mut Bo) -> Result<DmaBuf, GbmError> {
Ok(DmaBuf {
id: dmabuf_ids.next(),
width: gbm_bo_get_width(bo) as _,
height: gbm_bo_get_height(bo) as _,
modifier: gbm_bo_get_modifier(bo),
format: {
let format = gbm_bo_get_format(bo);
match formats().get(&format).copied() {
Some(f) => f,
_ => return Err(GbmError::UnknownFormat),
}
},
planes: {
let mut planes = PlaneVec::new();
for plane in 0..gbm_bo_get_plane_count(bo) {
let offset = gbm_bo_get_offset(bo, plane);
let stride = gbm_bo_get_stride_for_plane(bo, plane);
let fd = gbm_bo_get_fd_for_plane(bo, plane);
if fd < 0 {
return Err(GbmError::DrmFd);
unsafe {
Ok(DmaBuf {
id: dmabuf_ids.next(),
width: gbm_bo_get_width(bo) as _,
height: gbm_bo_get_height(bo) as _,
modifier: gbm_bo_get_modifier(bo),
format: {
let format = gbm_bo_get_format(bo);
match formats().get(&format).copied() {
Some(f) => f,
_ => return Err(GbmError::UnknownFormat),
}
planes.push(DmaBufPlane {
offset,
stride,
fd: Rc::new(OwnedFd::new(fd)),
})
}
planes
},
})
},
planes: {
let mut planes = PlaneVec::new();
for plane in 0..gbm_bo_get_plane_count(bo) {
let offset = gbm_bo_get_offset(bo, plane);
let stride = gbm_bo_get_stride_for_plane(bo, plane);
let fd = gbm_bo_get_fd_for_plane(bo, plane);
if fd < 0 {
return Err(GbmError::DrmFd);
}
planes.push(DmaBufPlane {
offset,
stride,
fd: Rc::new(OwnedFd::new(fd)),
})
}
planes
},
})
}
}
impl GbmDevice {

2
src/xkbcommon.rs
View file

@ -415,7 +415,7 @@ unsafe extern "C" fn jay_xkbcommon_log_handler(
line: *const c::c_char,
) {
assert!(line.is_not_null());
let buf = CStr::from_ptr(line);
let buf = unsafe { CStr::from_ptr(line) };
let level = match XkbLogLevel(level) {
XKB_LOG_LEVEL_CRITICAL | XKB_LOG_LEVEL_ERROR => log::Level::Error,
XKB_LOG_LEVEL_WARNING => log::Level::Warn,