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

Merge pull request #294 from mahkoh/jorth/tracy-upstream

Browse source 
all: remove unnecessary mem:: prefix
This commit is contained in:
mahkoh 2024-10-12 14:52:29 +02:00 • committed by GitHub
commit 437c6b0596
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
22 changed files with 61 additions and 76 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/client/objects.rs
View file

@ -43,7 +43,7 @@ use {
ZwpTabletToolV2Id,
},
},
std::{cell::RefCell, mem, rc::Rc},
std::{cell::RefCell, rc::Rc},
};
pub struct Objects {
@ -81,7 +81,7 @@ pub struct Objects {
}
pub const MIN_SERVER_ID: u32 = 0xff000000;
const SEG_SIZE: usize = 8 * mem::size_of::<usize>();
const SEG_SIZE: usize = usize::BITS as usize;
impl Objects {
pub fn new() -> Self {

8
src/dbus/parser.rs
View file

@ -4,7 +4,7 @@ use {
DbusError, DbusType, DynamicType, Parser,
},
bstr::ByteSlice,
std::{borrow::Cow, mem, rc::Rc},
std::{borrow::Cow, rc::Rc},
uapi::{OwnedFd, Pod},
};
@ -43,7 +43,7 @@ impl<'a> Parser<'a> {
self.align_to(T::ALIGNMENT)?;
match uapi::pod_read_init(&self.buf[self.pos..]) {
Ok(v) => {
self.pos += mem::size_of::<T>();
self.pos += size_of::<T>();
Ok(v)
}
_ => Err(DbusError::UnexpectedEof),
@ -95,13 +95,13 @@ impl<'a> Parser<'a> {
return Err(DbusError::UnexpectedEof);
}
if T::IS_POD {
if len % mem::size_of::<T>() != 0 {
if len % size_of::<T>() != 0 {
return Err(DbusError::PodArrayLength);
}
let slice = unsafe {
std::slice::from_raw_parts(
self.buf[self.pos..].as_ptr() as *const T,
len / mem::size_of::<T>(),
len / size_of::<T>(),
)
};
self.pos += len;

4
src/forker/io.rs
View file

@ -80,8 +80,8 @@ impl IoOut {
bincode_ops()
.serialize_into(&mut self.scratch, &msg)
.map_err(ForkerError::EncodeFailed)?;
let len = self.scratch.len() - mem::size_of_val(&0usize);
self.scratch[..mem::size_of_val(&len)].copy_from_slice(uapi::as_bytes(&len));
let len = self.scratch.len() - size_of_val(&0usize);
self.scratch[..size_of_val(&len)].copy_from_slice(uapi::as_bytes(&len));
let mut buf = self.scratch.borrow();
match self
.outgoing

4
src/gfx_apis/vulkan/pipeline.rs
View file

@ -20,7 +20,7 @@ use {
PrimitiveTopology, PushConstantRange, SampleCountFlags, ShaderStageFlags,
},
},
std::{mem, rc::Rc, slice},
std::{rc::Rc, slice},
};
pub(super) struct VulkanPipeline {
@ -45,7 +45,7 @@ impl VulkanDevice {
&self,
info: PipelineCreateInfo,
) -> Result<Rc<VulkanPipeline>, VulkanError> {
self.create_pipeline_(info, mem::size_of::<V>() as _, mem::size_of::<F>() as _)
self.create_pipeline_(info, size_of::<V>() as _, size_of::<F>() as _)
}
fn create_pipeline_(

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

@ -590,7 +590,7 @@ impl VulkanRenderer {
buf,
pipeline.pipeline_layout,
ShaderStageFlags::FRAGMENT,
mem::size_of_val(&vert) as _,
size_of_val(&vert) as _,
uapi::as_bytes(&frag),
);
}

6
src/io_uring.rs
View file

@ -36,7 +36,6 @@ use {
},
std::{
cell::{Cell, RefCell, UnsafeCell},
mem::{self},
rc::Rc,
sync::atomic::{
AtomicU32,
@ -119,7 +118,7 @@ impl IoUring {
Err(e) => return Err(IoUringError::MapSqRing(e)),
};
let sqesmap_map = mmap(
params.sq_entries as usize * mem::size_of::<io_uring_sqe>(),
params.sq_entries as usize * size_of::<io_uring_sqe>(),
c::PROT_READ | c::PROT_WRITE,
c::MAP_SHARED | c::MAP_POPULATE,
fd.raw(),
@ -130,8 +129,7 @@ impl IoUring {
Err(e) => return Err(IoUringError::MapSqEntries(e)),
};
let cqmap_map = mmap(
params.cq_off.cqes as usize
+ params.cq_entries as usize * mem::size_of::<io_uring_cqe>(),
params.cq_off.cqes as usize + params.cq_entries as usize * size_of::<io_uring_cqe>(),
c::PROT_READ | c::PROT_WRITE,
c::MAP_SHARED | c::MAP_POPULATE,
fd.raw(),

4
src/io_uring/ops/connect.rs
View file

@ -4,7 +4,7 @@ use {
sys::{io_uring_sqe, IORING_OP_CONNECT},
IoUring, IoUringData, IoUringError, IoUringTaskId, Task, TaskResultExt,
},
std::{mem, ptr, rc::Rc},
std::{ptr, rc::Rc},
uapi::{c, OwnedFd, SockAddr},
};
@ -20,7 +20,7 @@ impl IoUring {
unsafe {
ptr::copy_nonoverlapping(t, &mut pw.sockaddr as *mut _ as *mut _, 1);
}
pw.addrlen = mem::size_of::<T>() as _;
pw.addrlen = size_of::<T>() as _;
pw.data = Some(Data {
pr: pr.clone(),
_fd: fd.clone(),

8
src/io_uring/ops/sendmsg.rs
View file

@ -8,11 +8,7 @@ use {
time::Time,
utils::{buf::Buf, vec_ext::UninitVecExt},
},
std::{
mem::{self, MaybeUninit},
ptr,
rc::Rc,
},
std::{mem::MaybeUninit, ptr, rc::Rc},
uapi::{c, OwnedFd},
};
@ -44,7 +40,7 @@ impl IoUring {
let mut fd_ids = self.ring.fd_ids_scratch.borrow_mut();
fd_ids.clear();
fd_ids.extend(st.fds.iter().map(|f| f.raw()));
let space = uapi::cmsg_space(mem::size_of_val(&fd_ids[..]));
let space = uapi::cmsg_space(size_of_val(&fd_ids[..]));
st.cmsg.clear();
st.cmsg.reserve(space);
st.cmsg.set_len_safe(space);

8
src/leaks.rs
View file

@ -55,7 +55,7 @@ mod leaks {
any,
cell::Cell,
marker::PhantomData,
mem, ptr,
ptr,
},
uapi::c,
};
@ -115,7 +115,7 @@ mod leaks {
let slice = unsafe {
std::slice::from_raw_parts(
lo as *const *mut u8,
(hi - lo) / mem::size_of::<usize>(),
(hi - lo) / size_of::<usize>(),
)
};
for addr in slice {
@ -301,11 +301,11 @@ mod leaks {
IN_ALLOCATOR.set(IN_ALLOCATOR.get() + 1);
let mut res = vec![];
for allocation in ALLOCATIONS.get().deref().values() {
let num = allocation.len / mem::size_of::<usize>();
let num = allocation.len / size_of::<usize>();
let elements = std::slice::from_raw_parts(allocation.addr as *const *mut u8, num);
for (offset, pos) in elements.iter().enumerate() {
if *pos == addr {
res.push((allocation.clone(), offset * mem::size_of::<usize>()));
res.push((allocation.clone(), offset * size_of::<usize>()));
break;
}
}

6
src/macros.rs
View file

@ -372,7 +372,7 @@ macro_rules! assert_size_eq {
struct AssertEqSize<T, U>(std::marker::PhantomData<T>, std::marker::PhantomData<U>);
impl<T, U> AssertEqSize<T, U> {
const VAL: usize = {
if std::mem::size_of::<T>() != std::mem::size_of::<U>() {
if size_of::<T>() != size_of::<U>() {
panic!("Types have different size");
}
1
@ -388,7 +388,7 @@ macro_rules! assert_size_le {
struct AssertLeSize<T, U>(std::marker::PhantomData<T>, std::marker::PhantomData<U>);
impl<T, U> AssertLeSize<T, U> {
const VAL: usize = {
if std::mem::size_of::<T>() > std::mem::size_of::<U>() {
if size_of::<T>() > size_of::<U>() {
panic!("Left type has size larger than right type");
}
1
@ -403,7 +403,7 @@ macro_rules! assert_align_eq {
struct AssertEqAlign<T, U>(std::marker::PhantomData<T>, std::marker::PhantomData<U>);
impl<T, U> AssertEqAlign<T, U> {
const VAL: usize = {
if std::mem::align_of::<T>() != std::mem::align_of::<U>() {
if align_of::<T>() != align_of::<U>() {
panic!("Types have different alignment");
}
1

7
src/pipewire/pw_ifs/pw_client_node.rs
View file

@ -40,7 +40,6 @@ use {
},
std::{
cell::{Cell, RefCell},
mem,
rc::Rc,
sync::atomic::Ordering::{Relaxed, Release},
},
@ -326,13 +325,13 @@ impl PwClientNode {
let sm = port.supported_metas.get();
let mut metas = vec![];
if sm.contains(SUPPORTED_META_HEADER) {
metas.push((SPA_META_Header, mem::size_of::<spa_meta_header>()));
metas.push((SPA_META_Header, size_of::<spa_meta_header>()));
}
if sm.contains(SUPPORTED_META_BUSY) {
metas.push((SPA_META_Busy, mem::size_of::<spa_meta_busy>()));
metas.push((SPA_META_Busy, size_of::<spa_meta_busy>()));
}
if sm.contains(SUPPORTED_META_VIDEO_CROP) {
metas.push((SPA_META_VideoCrop, mem::size_of::<spa_meta_region>()));
metas.push((SPA_META_VideoCrop, size_of::<spa_meta_region>()));
}
let sf = &*port.supported_formats.borrow();
let num_formats = sf.formats.len() as u32;

6
src/pipewire/pw_mem.rs
View file

@ -6,7 +6,7 @@ use {
page_size::page_size,
ptr_ext::{MutPtrExt, PtrExt},
},
std::{marker::PhantomData, mem, ops::Range, rc::Rc},
std::{marker::PhantomData, ops::Range, rc::Rc},
thiserror::Error,
uapi::{c, OwnedFd, Pod},
};
@ -107,8 +107,8 @@ impl PwMemMap {
fn check<T>(&self, offset: usize) {
assert!(offset <= self.range.len());
assert!(mem::size_of::<T>() <= self.range.len() - offset);
assert_eq!((mem::align_of::<T>() - 1) & (self.range.start + offset), 0);
assert!(size_of::<T>() <= self.range.len() - offset);
assert_eq!((align_of::<T>() - 1) & (self.range.start + offset), 0);
}
pub fn typed<T: Pod>(self: &Rc<Self>) -> Rc<PwMemTyped<T>> {

10
src/pipewire/pw_parser.rs
View file

@ -12,11 +12,7 @@ use {
},
ahash::AHashMap,
bstr::{BStr, BString, ByteSlice},
std::{
fmt::Debug,
mem::{self, MaybeUninit},
rc::Rc,
},
std::{fmt::Debug, mem::MaybeUninit, rc::Rc},
thiserror::Error,
uapi::{OwnedFd, Pod},
};
@ -52,11 +48,11 @@ impl<'a> PwParser<'a> {
}
fn read_raw<T: Pod>(&mut self, offset: usize) -> Result<T, PwParserError> {
if self.pos + offset + mem::size_of::<T>() <= self.data.len() {
if self.pos + offset + size_of::<T>() <= self.data.len() {
unsafe {
let mut res = MaybeUninit::uninit();
let src = self.data[self.pos + offset..].as_ptr();
std::ptr::copy_nonoverlapping(src, res.as_mut_ptr() as _, mem::size_of::<T>());
std::ptr::copy_nonoverlapping(src, res.as_mut_ptr() as _, size_of::<T>());
Ok(res.assume_init())
}
} else {

4
src/utils/bitfield.rs
View file

@ -1,8 +1,6 @@
#![allow(dead_code)]
use std::mem;
const SEG_SIZE: usize = 8 * mem::size_of::<usize>();
const SEG_SIZE: usize = usize::BITS as usize;
#[derive(Default)]
pub struct Bitfield {

2
src/utils/buf.rs
View file

@ -313,7 +313,7 @@ pub struct TypedBuf<T: Pod> {
impl<T: Pod> TypedBuf<T> {
pub fn new() -> Self {
Self {
buf: Buf::new(mem::size_of::<T>()),
buf: Buf::new(size_of::<T>()),
_phantom: Default::default(),
}
}

2
src/utils/buffd/formatter.rs
View file

@ -101,7 +101,7 @@ impl<'a> MsgFormatter<'a> {
}
pub fn binary<T: ?Sized + Packed>(&mut self, t: &T) -> &mut Self {
self.uint(mem::size_of_val(t) as u32);
self.uint(size_of_val(t) as u32);
self.write(uapi::as_bytes(t));
let none = [0; 4];
self.write(&none[..self.meta.write_pos.wrapping_neg() & 3]);

14
src/utils/buffd/parser.rs
View file

@ -1,7 +1,7 @@
use {
crate::{fixed::Fixed, globals::GlobalName, object::ObjectId, utils::buffd::BufFdIn},
bstr::{BStr, ByteSlice},
std::{mem, ptr, rc::Rc},
std::{ptr, rc::Rc},
thiserror::Error,
uapi::{OwnedFd, Pod},
};
@ -122,30 +122,30 @@ impl<'a, 'b> MsgParser<'a, 'b> {
pub fn binary<T: Pod>(&mut self) -> Result<T, MsgParserError> {
let array = self.array()?;
if array.len() < mem::size_of::<T>() {
if array.len() < size_of::<T>() {
return Err(MsgParserError::UnexpectedEof);
}
if array.len() > mem::size_of::<T>() {
if array.len() > size_of::<T>() {
return Err(MsgParserError::BinaryArrayTooLarge);
}
unsafe { Ok(ptr::read_unaligned(array.as_ptr() as _)) }
}
pub fn binary_array<T: Pod>(&mut self) -> Result<&'b [T], MsgParserError> {
if std::mem::align_of::<T>() > 4 {
if align_of::<T>() > 4 {
panic!("Alignment of binary array element is too large");
};
if std::mem::size_of::<T>() == 0 {
if size_of::<T>() == 0 {
panic!("Size of binary array element is 0");
};
let array = self.array()?;
if array.len() % mem::size_of::<T>() != 0 {
if array.len() % size_of::<T>() != 0 {
return Err(MsgParserError::BinaryArraySize);
}
unsafe {
Ok(std::slice::from_raw_parts(
array.as_ptr() as _,
array.len() / mem::size_of::<T>(),
array.len() / size_of::<T>(),
))
}
}

3
src/utils/clone3.rs
View file

@ -1,6 +1,5 @@
use {
crate::forker::ForkerError,
std::mem,
uapi::{c, OwnedFd},
};
@ -41,7 +40,7 @@ pub fn fork_with_pidfd(pidfd_for_child: bool) -> Result<Forked, ForkerError> {
let pid = c::syscall(
c::SYS_clone3,
&mut args as *const _ as usize,
mem::size_of::<clone_args>(),
size_of::<clone_args>(),
);
if let Err(e) = uapi::map_err!(pid) {
return Err(ForkerError::Fork(e.into()));

14
src/video/drm.rs
View file

@ -457,26 +457,26 @@ impl DrmMaster {
let mut t = MaybeUninit::<T>::uninit();
match mode_getprobblob(self.raw(), blob.0, &mut t) {
Err(e) => Err(DrmError::GetPropBlob(e)),
Ok(n) if n != mem::size_of::<T>() => Err(DrmError::InvalidProbSize),
Ok(n) if n != size_of::<T>() => Err(DrmError::InvalidProbSize),
_ => unsafe { Ok(t.assume_init()) },
}
}
pub fn getblob_vec<T: Pod>(&self, blob: DrmBlob) -> Result<Vec<T>, DrmError> {
assert_ne!(mem::size_of::<T>(), 0);
assert_ne!(size_of::<T>(), 0);
let mut vec = vec![];
loop {
let (_, bytes) = vec.split_at_spare_mut_bytes_ext();
match mode_getprobblob(self.raw(), blob.0, bytes) {
Err(e) => return Err(DrmError::GetPropBlob(e)),
Ok(n) if n % mem::size_of::<T>() != 0 => return Err(DrmError::UnalignedPropSize),
Ok(n) if n % size_of::<T>() != 0 => return Err(DrmError::UnalignedPropSize),
Ok(n) if n <= bytes.len() => {
unsafe {
vec.set_len(n / mem::size_of::<T>());
vec.set_len(n / size_of::<T>());
}
return Ok(vec);
}
Ok(n) => vec.reserve_exact(n / mem::size_of::<T>()),
Ok(n) => vec.reserve_exact(n / size_of::<T>()),
}
}
}
@ -499,10 +499,10 @@ impl DrmMaster {
}
let formats_start = header.formats_offset as usize;
let formats_end = formats_start
.wrapping_add((header.count_formats as usize).wrapping_mul(mem::size_of::<u32>()));
.wrapping_add((header.count_formats as usize).wrapping_mul(size_of::<u32>()));
let modifiers_start = header.modifiers_offset as usize;
let modifiers_end = modifiers_start.wrapping_add(
(header.count_modifiers as usize).wrapping_mul(mem::size_of::<drm_format_modifier>()),
(header.count_modifiers as usize).wrapping_mul(size_of::<drm_format_modifier>()),
);
if blob.len() < formats_end || formats_end < formats_start {
log::error!("Formats of IN_FORMATS blob don't fit in the blob");

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

@ -16,7 +16,6 @@ use {
std::{
ffi::CString,
io::{BufRead, BufReader},
mem,
},
uapi::{c, pod_zeroed, OwnedFd, Pod, Ustring},
};
@ -921,7 +920,7 @@ const DRM_IOCTL_MODE_CREATEPROPBLOB: u64 = drm_iowr::<drm_mode_create_blob>(0xbd
pub fn mode_create_blob<T>(fd: c::c_int, t: &T) -> Result<DrmBlob, OsError> {
let mut res = drm_mode_create_blob {
data: t as *const T as _,
length: mem::size_of_val(t) as _,
length: size_of_val(t) as _,
blob_id: 0,
};
@ -1096,7 +1095,7 @@ pub fn mode_getprobblob<T: Pod + ?Sized>(
) -> Result<usize, OsError> {
let mut res = drm_mode_get_blob {
blob_id,
length: mem::size_of_val(t) as _,
length: size_of_val(t) as _,
data: t as *const T as *const u8 as _,
};
unsafe {

6
src/xcon.rs
View file

@ -597,7 +597,7 @@ impl Xcon {
long_offset: 0,
long_length: 128,
};
let format = mem::size_of::<T>() as u8 * 8;
let format = size_of::<T>() as u8 * 8;
loop {
let res = self.call(&gp).await?;
let res = res.get();
@ -611,10 +611,10 @@ impl Xcon {
if res.format != format {
return Err(XconError::InvalidPropertyFormat(format, res.format));
}
if res.data.len() % mem::size_of::<T>() != 0 {
if res.data.len() % size_of::<T>() != 0 {
return Err(XconError::IrregularPropertyLength);
}
let len = res.data.len() / mem::size_of::<T>();
let len = res.data.len() / size_of::<T>();
buf.reserve(len);
let (_, uninit) = buf.split_at_spare_mut_bytes_ext();
uninit[..res.data.len()].copy_from_slice(uapi::as_maybe_uninit_bytes(res.data));

10
src/xcon/parser.rs
View file

@ -4,7 +4,7 @@ use {
xcon::{wire_type::Message, XconError},
},
bstr::{BStr, ByteSlice},
std::{borrow::Cow, mem, rc::Rc},
std::{borrow::Cow, rc::Rc},
uapi::{OwnedFd, Pod},
};
@ -65,7 +65,7 @@ impl<'a> Parser<'a> {
pub fn read_pod<T: Pod>(&mut self) -> Result<T, XconError> {
match uapi::pod_read_init(&self.buf[self.pos..]) {
Ok(v) => {
self.pos += mem::size_of::<T>();
self.pos += size_of::<T>();
Ok(v)
}
_ => Err(XconError::UnexpectedEof),
@ -78,13 +78,13 @@ impl<'a> Parser<'a> {
) -> Result<&'a [T], XconError> {
let n = match n {
Some(n) => n,
_ => self.rem() / mem::size_of::<T>(),
_ => self.rem() / size_of::<T>(),
};
let len = mem::size_of::<T>() * n;
let len = size_of::<T>() * n;
if len > self.rem() {
return Err(XconError::UnexpectedEof);
}
if self.buf[self.pos..].as_ptr() as usize & (mem::align_of::<T>() - 1) != 0 {
if self.buf[self.pos..].as_ptr() as usize & (align_of::<T>() - 1) != 0 {
return Err(XconError::UnalignedSlice);
}
let res =