diff --git a/crates/drivers/bcm2835-aux-uart/src/device.rs b/crates/drivers/bcm2835-aux-uart/src/device.rs index ad712bc68..cb52c2c61 100644 --- a/crates/drivers/bcm2835-aux-uart/src/device.rs +++ b/crates/drivers/bcm2835-aux-uart/src/device.rs @@ -9,7 +9,10 @@ use core::ops::Deref; use tock_registers::{ - interfaces::{Readable, Writeable}, + interfaces::{ + Readable, + Writeable, + }, register_structs, registers::ReadWrite, }; diff --git a/crates/drivers/bcm2835-aux-uart/src/lib.rs b/crates/drivers/bcm2835-aux-uart/src/lib.rs index 68fa24754..25dc88e9c 100644 --- a/crates/drivers/bcm2835-aux-uart/src/lib.rs +++ b/crates/drivers/bcm2835-aux-uart/src/lib.rs @@ -8,8 +8,10 @@ use core::convert::Infallible; -use embedded_hal_nb::nb; -use embedded_hal_nb::serial; +use embedded_hal_nb::{ + nb, + serial, +}; // use sel4_driver_interfaces::HandleInterrupt; diff --git a/crates/drivers/pl011/src/device.rs b/crates/drivers/pl011/src/device.rs index 207ed729b..e01b0733f 100644 --- a/crates/drivers/pl011/src/device.rs +++ b/crates/drivers/pl011/src/device.rs @@ -6,9 +6,19 @@ use core::ops::Deref; -use tock_registers::interfaces::{Readable, Writeable}; -use tock_registers::registers::{ReadOnly, ReadWrite, WriteOnly}; -use tock_registers::{register_bitfields, register_structs}; +use tock_registers::{ + interfaces::{ + Readable, + Writeable, + }, + register_bitfields, + register_structs, + registers::{ + ReadOnly, + ReadWrite, + WriteOnly, + }, +}; register_structs! { #[allow(non_snake_case)] diff --git a/crates/drivers/pl011/src/lib.rs b/crates/drivers/pl011/src/lib.rs index 5daff3edc..459ffc8b4 100644 --- a/crates/drivers/pl011/src/lib.rs +++ b/crates/drivers/pl011/src/lib.rs @@ -8,8 +8,10 @@ use core::convert::Infallible; -use embedded_hal_nb::nb; -use embedded_hal_nb::serial; +use embedded_hal_nb::{ + nb, + serial, +}; use sel4_driver_interfaces::HandleInterrupt; diff --git a/crates/drivers/pl031/src/device.rs b/crates/drivers/pl031/src/device.rs index 6b52bcdaf..3eaf7b5e3 100644 --- a/crates/drivers/pl031/src/device.rs +++ b/crates/drivers/pl031/src/device.rs @@ -8,9 +8,16 @@ use core::ops::Deref; -use tock_registers::interfaces::Readable; -use tock_registers::registers::{ReadOnly, ReadWrite, WriteOnly}; -use tock_registers::{register_bitfields, register_structs}; +use tock_registers::{ + interfaces::Readable, + register_bitfields, + register_structs, + registers::{ + ReadOnly, + ReadWrite, + WriteOnly, + }, +}; register_structs! { #[allow(non_snake_case)] diff --git a/crates/drivers/pl031/src/lib.rs b/crates/drivers/pl031/src/lib.rs index c100b87d1..e703ac0ae 100644 --- a/crates/drivers/pl031/src/lib.rs +++ b/crates/drivers/pl031/src/lib.rs @@ -6,7 +6,11 @@ #![no_std] -use rtcc::{DateTime, DateTimeAccess, NaiveDateTime}; +use rtcc::{ + DateTime, + DateTimeAccess, + NaiveDateTime, +}; mod device; diff --git a/crates/drivers/sp804/src/device.rs b/crates/drivers/sp804/src/device.rs index a383b9810..9f05c911b 100644 --- a/crates/drivers/sp804/src/device.rs +++ b/crates/drivers/sp804/src/device.rs @@ -8,9 +8,20 @@ use core::ops::Deref; -use tock_registers::interfaces::{ReadWriteable, Readable, Writeable}; -use tock_registers::registers::{ReadOnly, ReadWrite, WriteOnly}; -use tock_registers::{register_bitfields, register_structs}; +use tock_registers::{ + interfaces::{ + ReadWriteable, + Readable, + Writeable, + }, + register_bitfields, + register_structs, + registers::{ + ReadOnly, + ReadWrite, + WriteOnly, + }, +}; register_structs! { #[allow(non_snake_case)] diff --git a/crates/drivers/sp804/src/lib.rs b/crates/drivers/sp804/src/lib.rs index 642900447..4714557d4 100644 --- a/crates/drivers/sp804/src/lib.rs +++ b/crates/drivers/sp804/src/lib.rs @@ -6,16 +6,28 @@ #![no_std] -use core::convert::Infallible; -use core::time::Duration; +use core::{ + convert::Infallible, + time::Duration, +}; use tock_registers::interfaces::ReadWriteable; -use sel4_driver_interfaces::HandleInterrupt; -use sel4_driver_interfaces::timer::{Clock, ErrorType, Timer as TimerTrait}; +use sel4_driver_interfaces::{ + HandleInterrupt, + timer::{ + Clock, + ErrorType, + Timer as TimerTrait, + }, +}; mod device; -use device::{Control, Device, Timer}; +use device::{ + Control, + Device, + Timer, +}; pub struct Driver { device: Device, diff --git a/crates/drivers/virtio/blk/src/lib.rs b/crates/drivers/virtio/blk/src/lib.rs index 04831f989..da8edaeb6 100644 --- a/crates/drivers/virtio/blk/src/lib.rs +++ b/crates/drivers/virtio/blk/src/lib.rs @@ -6,12 +6,20 @@ #![no_std] -use core::convert::Infallible; -use core::ops::Deref; +use core::{ + convert::Infallible, + ops::Deref, +}; use sel4_driver_interfaces::block::GetBlockDeviceLayout; -use virtio_drivers::device::blk::{SECTOR_SIZE, VirtIOBlk}; -use virtio_drivers::{Hal, transport::Transport}; +use virtio_drivers::{ + Hal, + device::blk::{ + SECTOR_SIZE, + VirtIOBlk, + }, + transport::Transport, +}; pub struct GetBlockDeviceLayoutWrapper(pub T); diff --git a/crates/drivers/virtio/hal-impl/src/lib.rs b/crates/drivers/virtio/hal-impl/src/lib.rs index 9c74bf43d..f69586ba4 100644 --- a/crates/drivers/virtio/hal-impl/src/lib.rs +++ b/crates/drivers/virtio/hal-impl/src/lib.rs @@ -6,14 +6,27 @@ #![no_std] -use core::alloc::Layout; -use core::ptr::{self, NonNull}; +use core::{ + alloc::Layout, + ptr::{ + self, + NonNull, + }, +}; use one_shot_mutex::sync::OneShotMutex; -use virtio_drivers::{BufferDirection, Hal, PAGE_SIZE, PhysAddr}; - -use sel4_abstract_allocator::basic::BasicAllocator; -use sel4_abstract_allocator::{ByRange, WithAlignmentBound}; +use virtio_drivers::{ + BufferDirection, + Hal, + PAGE_SIZE, + PhysAddr, +}; + +use sel4_abstract_allocator::{ + ByRange, + WithAlignmentBound, + basic::BasicAllocator, +}; use sel4_immediate_sync_once_cell::ImmediateSyncOnceCell; use sel4_shared_memory::SharedMemoryRef; diff --git a/crates/drivers/virtio/net/src/lib.rs b/crates/drivers/virtio/net/src/lib.rs index 5faf56afc..d987b256d 100644 --- a/crates/drivers/virtio/net/src/lib.rs +++ b/crates/drivers/virtio/net/src/lib.rs @@ -10,16 +10,38 @@ extern crate alloc; use alloc::rc::Rc; -use core::cell::RefCell; -use core::convert::Infallible; +use core::{ + cell::RefCell, + convert::Infallible, +}; use log::trace; -use sel4_driver_interfaces::HandleInterrupt; -use sel4_driver_interfaces::net::{GetNetDeviceMeta, MacAddress}; -use smoltcp::phy::{Device, DeviceCapabilities, Medium, RxToken, TxToken}; -use smoltcp::time::Instant; -use virtio_drivers::device::net::{RxBuffer, VirtIONet}; -use virtio_drivers::{Error, Hal, transport::Transport}; +use sel4_driver_interfaces::{ + HandleInterrupt, + net::{ + GetNetDeviceMeta, + MacAddress, + }, +}; +use smoltcp::{ + phy::{ + Device, + DeviceCapabilities, + Medium, + RxToken, + TxToken, + }, + time::Instant, +}; +use virtio_drivers::{ + Error, + Hal, + device::net::{ + RxBuffer, + VirtIONet, + }, + transport::Transport, +}; pub const NET_QUEUE_SIZE: usize = 16; diff --git a/crates/examples/lionsos/serial/components/client/src/main.rs b/crates/examples/lionsos/serial/components/client/src/main.rs index a65024dff..10fd6be99 100644 --- a/crates/examples/lionsos/serial/components/client/src/main.rs +++ b/crates/examples/lionsos/serial/components/client/src/main.rs @@ -7,7 +7,12 @@ #![no_std] #![no_main] -use sel4_microkit::{Handler, Infallible, debug_println, protection_domain}; +use sel4_microkit::{ + Handler, + Infallible, + debug_println, + protection_domain, +}; #[protection_domain] fn init() -> HandlerImpl { diff --git a/crates/examples/microkit/banscii/pds/artist/build.rs b/crates/examples/microkit/banscii/pds/artist/build.rs index ad9332543..e820a6bfd 100644 --- a/crates/examples/microkit/banscii/pds/artist/build.rs +++ b/crates/examples/microkit/banscii/pds/artist/build.rs @@ -4,9 +4,11 @@ // SPDX-License-Identifier: BSD-2-Clause // -use std::env; -use std::fs; -use std::path::PathBuf; +use std::{ + env, + fs, + path::PathBuf, +}; use rsa::pkcs1::EncodeRsaPrivateKey; diff --git a/crates/examples/microkit/banscii/pds/artist/interface-types/src/lib.rs b/crates/examples/microkit/banscii/pds/artist/interface-types/src/lib.rs index f97ff534f..66c2873a3 100644 --- a/crates/examples/microkit/banscii/pds/artist/interface-types/src/lib.rs +++ b/crates/examples/microkit/banscii/pds/artist/interface-types/src/lib.rs @@ -6,7 +6,10 @@ #![no_std] -use serde::{Deserialize, Serialize}; +use serde::{ + Deserialize, + Serialize, +}; #[derive(Debug, Serialize, Deserialize)] pub struct Request { diff --git a/crates/examples/microkit/banscii/pds/artist/src/cryptographic_secrets.rs b/crates/examples/microkit/banscii/pds/artist/src/cryptographic_secrets.rs index c30b8c453..b3bdde8ae 100644 --- a/crates/examples/microkit/banscii/pds/artist/src/cryptographic_secrets.rs +++ b/crates/examples/microkit/banscii/pds/artist/src/cryptographic_secrets.rs @@ -4,11 +4,16 @@ // SPDX-License-Identifier: BSD-2-Clause // -use rsa::RsaPrivateKey; -use rsa::pkcs1::DecodeRsaPrivateKey; -use rsa::pkcs1v15::{Signature, SigningKey}; -use rsa::sha2::Sha256; -use rsa::signature::Signer; +use rsa::{ + RsaPrivateKey, + pkcs1::DecodeRsaPrivateKey, + pkcs1v15::{ + Signature, + SigningKey, + }, + sha2::Sha256, + signature::Signer, +}; const PRIV_KEY_PEM: &str = include_str!(concat!(env!("OUT_DIR"), "/priv.pem")); diff --git a/crates/examples/microkit/banscii/pds/artist/src/main.rs b/crates/examples/microkit/banscii/pds/artist/src/main.rs index 18879a058..462643a37 100644 --- a/crates/examples/microkit/banscii/pds/artist/src/main.rs +++ b/crates/examples/microkit/banscii/pds/artist/src/main.rs @@ -14,12 +14,21 @@ use alloc::vec; use rsa::signature::SignatureEncoding; use sel4_microkit::{ - Channel, Handler, Infallible, MessageInfo, memory_region_symbol, protection_domain, var, + Channel, + Handler, + Infallible, + MessageInfo, + memory_region_symbol, + protection_domain, + var, }; use sel4_microkit_simple_ipc as simple_ipc; use sel4_shared_memory::{ SharedMemoryRef, - access::{ReadOnly, ReadWrite}, + access::{ + ReadOnly, + ReadWrite, + }, }; use banscii_artist_interface_types::*; diff --git a/crates/examples/microkit/banscii/pds/assistant/core/src/lib.rs b/crates/examples/microkit/banscii/pds/assistant/core/src/lib.rs index f20b389db..84047e00b 100644 --- a/crates/examples/microkit/banscii/pds/assistant/core/src/lib.rs +++ b/crates/examples/microkit/banscii/pds/assistant/core/src/lib.rs @@ -8,10 +8,20 @@ extern crate alloc; -use alloc::vec; -use alloc::vec::Vec; - -use ab_glyph::{Font, FontRef, Glyph, Point, PxScale, ScaleFont, point}; +use alloc::{ + vec, + vec::Vec, +}; + +use ab_glyph::{ + Font, + FontRef, + Glyph, + Point, + PxScale, + ScaleFont, + point, +}; #[allow(unused_imports)] use num_traits::Float; diff --git a/crates/examples/microkit/banscii/pds/assistant/src/main.rs b/crates/examples/microkit/banscii/pds/assistant/src/main.rs index cf7725b97..2a297b280 100644 --- a/crates/examples/microkit/banscii/pds/assistant/src/main.rs +++ b/crates/examples/microkit/banscii/pds/assistant/src/main.rs @@ -9,24 +9,42 @@ extern crate alloc; -use alloc::vec; -use alloc::vec::Vec; -use core::fmt::Write; -use core::mem; -use core::str; +use alloc::{ + vec, + vec::Vec, +}; +use core::{ + fmt::Write, + mem, + str, +}; -use embedded_hal_nb::serial::{self, Read as _, Write as _}; +use embedded_hal_nb::serial::{ + self, + Read as _, + Write as _, +}; use sel4_microkit::{ - Channel, ChannelSet, Handler, Infallible, memory_region_symbol, protection_domain, var, + Channel, + ChannelSet, + Handler, + Infallible, + memory_region_symbol, + protection_domain, + var, }; use sel4_microkit_driver_adapters::serial::client::{ - Client as SerialClient, Error as SerialClientError, + Client as SerialClient, + Error as SerialClientError, }; use sel4_microkit_simple_ipc as simple_ipc; use sel4_shared_memory::{ SharedMemoryRef, - access::{ReadOnly, ReadWrite}, + access::{ + ReadOnly, + ReadWrite, + }, }; use banscii_artist_interface_types as artist; diff --git a/crates/examples/microkit/banscii/pds/serial-driver/src/main.rs b/crates/examples/microkit/banscii/pds/serial-driver/src/main.rs index ec70159b1..7d3803094 100644 --- a/crates/examples/microkit/banscii/pds/serial-driver/src/main.rs +++ b/crates/examples/microkit/banscii/pds/serial-driver/src/main.rs @@ -7,7 +7,13 @@ #![no_std] #![no_main] -use sel4_microkit::{Channel, Handler, memory_region_symbol, protection_domain, var}; +use sel4_microkit::{ + Channel, + Handler, + memory_region_symbol, + protection_domain, + var, +}; use sel4_microkit_driver_adapters::serial::driver::HandlerImpl; #[cfg(feature = "board-qemu_virt_aarch64")] diff --git a/crates/examples/microkit/hello/pds/hello/src/main.rs b/crates/examples/microkit/hello/pds/hello/src/main.rs index 5f44e5aee..78ba38b99 100644 --- a/crates/examples/microkit/hello/pds/hello/src/main.rs +++ b/crates/examples/microkit/hello/pds/hello/src/main.rs @@ -7,7 +7,12 @@ #![no_std] #![no_main] -use sel4_microkit::{Handler, Infallible, debug_println, protection_domain}; +use sel4_microkit::{ + Handler, + Infallible, + debug_println, + protection_domain, +}; #[protection_domain] fn init() -> HandlerImpl { diff --git a/crates/examples/microkit/http-server/pds/pl031-driver/src/main.rs b/crates/examples/microkit/http-server/pds/pl031-driver/src/main.rs index 6eac6955c..7f4fd2aad 100644 --- a/crates/examples/microkit/http-server/pds/pl031-driver/src/main.rs +++ b/crates/examples/microkit/http-server/pds/pl031-driver/src/main.rs @@ -7,7 +7,12 @@ #![no_std] #![no_main] -use sel4_microkit::{Channel, Handler, memory_region_symbol, protection_domain}; +use sel4_microkit::{ + Channel, + Handler, + memory_region_symbol, + protection_domain, +}; use sel4_microkit_driver_adapters::rtc::driver::HandlerImpl; use sel4_pl031_driver::Driver; diff --git a/crates/examples/microkit/http-server/pds/server/build.rs b/crates/examples/microkit/http-server/pds/server/build.rs index 73d9eabf1..f39397bca 100644 --- a/crates/examples/microkit/http-server/pds/server/build.rs +++ b/crates/examples/microkit/http-server/pds/server/build.rs @@ -4,9 +4,11 @@ // SPDX-License-Identifier: BSD-2-Clause // -use std::env; -use std::fs; -use std::path::PathBuf; +use std::{ + env, + fs, + path::PathBuf, +}; use rcgen::generate_simple_self_signed; diff --git a/crates/examples/microkit/http-server/pds/server/core/src/lib.rs b/crates/examples/microkit/http-server/pds/server/core/src/lib.rs index edfaca78a..14da50ec7 100644 --- a/crates/examples/microkit/http-server/pds/server/core/src/lib.rs +++ b/crates/examples/microkit/http-server/pds/server/core/src/lib.rs @@ -8,27 +8,53 @@ extern crate alloc; -use alloc::boxed::Box; -use alloc::rc::Rc; -use alloc::sync::Arc; -use alloc::vec; +use alloc::{ + boxed::Box, + rc::Rc, + sync::Arc, + vec, +}; use core::time::Duration; use embedded_io_async::ReadExactError; -use futures::future::{self, LocalBoxFuture}; -use futures::task::LocalSpawnExt; -use rustls::ServerConfig; -use rustls::pki_types::{PrivateKeyDer, UnixTime}; -use rustls::version::TLS12; - -use sel4_async_block_io::{BlockIO, access::ReadOnly, constant_block_sizes}; +use futures::{ + future::{ + self, + LocalBoxFuture, + }, + task::LocalSpawnExt, +}; +use rustls::{ + ServerConfig, + pki_types::{ + PrivateKeyDer, + UnixTime, + }, + version::TLS12, +}; + +use sel4_async_block_io::{ + BlockIO, + access::ReadOnly, + constant_block_sizes, +}; use sel4_async_block_io_fat as fat; use sel4_async_io::EmbeddedIOAsyncAdapter; -use sel4_async_network::{ManagedInterface, TcpSocket, TcpSocketError}; -use sel4_async_network_rustls::{Error as AsyncRustlsError, ServerConnector}; +use sel4_async_network::{ + ManagedInterface, + TcpSocket, + TcpSocketError, +}; +use sel4_async_network_rustls::{ + Error as AsyncRustlsError, + ServerConnector, +}; use sel4_async_network_rustls_utils::TimeProviderImpl; use sel4_async_single_threaded_executor::LocalSpawner; -use sel4_async_time::{Instant, TimerManager}; +use sel4_async_time::{ + Instant, + TimerManager, +}; mod mime; mod server; diff --git a/crates/examples/microkit/http-server/pds/server/core/src/server.rs b/crates/examples/microkit/http-server/pds/server/core/src/server.rs index c8af7effe..888aea5fc 100644 --- a/crates/examples/microkit/http-server/pds/server/core/src/server.rs +++ b/crates/examples/microkit/http-server/pds/server/core/src/server.rs @@ -4,13 +4,22 @@ // SPDX-License-Identifier: BSD-2-Clause // -use alloc::borrow::ToOwned; -use alloc::format; -use alloc::rc::Rc; -use alloc::string::{String, ToString}; -use alloc::vec; +use alloc::{ + borrow::ToOwned, + format, + rc::Rc, + string::{ + String, + ToString, + }, + vec, +}; -use embedded_io_async::{Read, ReadExactError, Write}; +use embedded_io_async::{ + Read, + ReadExactError, + Write, +}; use sel4_async_block_io_fat as fat; use sel4_async_unsync::Mutex; diff --git a/crates/examples/microkit/http-server/pds/server/src/handler.rs b/crates/examples/microkit/http-server/pds/server/src/handler.rs index 400613721..3ed0c0a47 100644 --- a/crates/examples/microkit/http-server/pds/server/src/handler.rs +++ b/crates/examples/microkit/http-server/pds/server/src/handler.rs @@ -4,25 +4,53 @@ // SPDX-License-Identifier: BSD-2-Clause // -use alloc::boxed::Box; -use alloc::sync::Arc; -use core::future::Future; -use core::pin::Pin; -use core::time::Duration; +use alloc::{ + boxed::Box, + sync::Arc, +}; +use core::{ + future::Future, + pin::Pin, + time::Duration, +}; use futures::future::LocalBoxFuture; use one_shot_mutex::sync::OneShotMutex; -use smoltcp::iface::Config; -use smoltcp::time::Instant as SmoltcpInstant; - -use sel4_abstract_allocator::WithAlignmentBound; -use sel4_abstract_allocator::basic::BasicAllocator; -use sel4_async_block_io::{access::ReadOnly, constant_block_sizes::BlockSize512}; -use sel4_async_network::{DhcpOverrides, ManagedInterface}; -use sel4_async_single_threaded_executor::{LocalPool, LocalSpawner}; -use sel4_async_time::{Instant, TimerManager}; -use sel4_driver_interfaces::timer::{Clock, DefaultTimer, Timer}; -use sel4_microkit::{ChannelSet, Handler, Infallible}; +use smoltcp::{ + iface::Config, + time::Instant as SmoltcpInstant, +}; + +use sel4_abstract_allocator::{ + WithAlignmentBound, + basic::BasicAllocator, +}; +use sel4_async_block_io::{ + access::ReadOnly, + constant_block_sizes::BlockSize512, +}; +use sel4_async_network::{ + DhcpOverrides, + ManagedInterface, +}; +use sel4_async_single_threaded_executor::{ + LocalPool, + LocalSpawner, +}; +use sel4_async_time::{ + Instant, + TimerManager, +}; +use sel4_driver_interfaces::timer::{ + Clock, + DefaultTimer, + Timer, +}; +use sel4_microkit::{ + ChannelSet, + Handler, + Infallible, +}; use sel4_microkit_driver_adapters::timer::client::Client as TimerClient; use sel4_shared_ring_buffer_block_io::SharedRingBufferBlockIO; diff --git a/crates/examples/microkit/http-server/pds/server/src/main.rs b/crates/examples/microkit/http-server/pds/server/src/main.rs index d9e5731ff..c226becd2 100644 --- a/crates/examples/microkit/http-server/pds/server/src/main.rs +++ b/crates/examples/microkit/http-server/pds/server/src/main.rs @@ -9,31 +9,63 @@ extern crate alloc; -use alloc::rc::Rc; -use alloc::sync::Arc; +use alloc::{ + rc::Rc, + sync::Arc, +}; use core::time::Duration; use one_shot_mutex::sync::OneShotMutex; use rtcc::DateTimeAccess; -use smoltcp::iface::Config; -use smoltcp::phy::{Device, DeviceCapabilities, Medium}; -use smoltcp::wire::{EthernetAddress, HardwareAddress}; +use smoltcp::{ + iface::Config, + phy::{ + Device, + DeviceCapabilities, + Medium, + }, + wire::{ + EthernetAddress, + HardwareAddress, + }, +}; -use sel4_abstract_allocator::WithAlignmentBound; -use sel4_abstract_allocator::basic::BasicAllocator; +use sel4_abstract_allocator::{ + WithAlignmentBound, + basic::BasicAllocator, +}; use sel4_async_block_io::{ - BlockSize, CachedBlockIO, ConstantBlockSize, constant_block_sizes::BlockSize512, disk::Disk, + BlockSize, + CachedBlockIO, + ConstantBlockSize, + constant_block_sizes::BlockSize512, + disk::Disk, }; use sel4_async_time::Instant; -use sel4_driver_interfaces::block::GetBlockDeviceLayout; -use sel4_driver_interfaces::net::GetNetDeviceMeta; -use sel4_driver_interfaces::timer::{Clock, DefaultTimer}; -use sel4_logging::{LevelFilter, Logger, LoggerBuilder}; -use sel4_microkit::{Handler, memory_region_symbol, protection_domain}; -use sel4_microkit_driver_adapters::block::client::Client as BlockClient; -use sel4_microkit_driver_adapters::net::client::Client as NetClient; -use sel4_microkit_driver_adapters::rtc::client::Client as RtcClient; -use sel4_microkit_driver_adapters::timer::client::Client as TimerClient; +use sel4_driver_interfaces::{ + block::GetBlockDeviceLayout, + net::GetNetDeviceMeta, + timer::{ + Clock, + DefaultTimer, + }, +}; +use sel4_logging::{ + LevelFilter, + Logger, + LoggerBuilder, +}; +use sel4_microkit::{ + Handler, + memory_region_symbol, + protection_domain, +}; +use sel4_microkit_driver_adapters::{ + block::client::Client as BlockClient, + net::client::Client as NetClient, + rtc::client::Client as RtcClient, + timer::client::Client as TimerClient, +}; use sel4_newlib as _; use sel4_shared_memory::SharedMemoryRef; use sel4_shared_ring_buffer::RingBuffers; diff --git a/crates/examples/microkit/http-server/pds/sp804-driver/src/main.rs b/crates/examples/microkit/http-server/pds/sp804-driver/src/main.rs index e1426d1a9..0d6f1e0c3 100644 --- a/crates/examples/microkit/http-server/pds/sp804-driver/src/main.rs +++ b/crates/examples/microkit/http-server/pds/sp804-driver/src/main.rs @@ -8,7 +8,12 @@ #![no_main] use sel4_driver_interfaces::timer::SingleTimer; -use sel4_microkit::{Channel, Handler, memory_region_symbol, protection_domain}; +use sel4_microkit::{ + Channel, + Handler, + memory_region_symbol, + protection_domain, +}; use sel4_microkit_driver_adapters::timer::driver::HandlerImpl; use sel4_sp804_driver::Driver; diff --git a/crates/examples/microkit/http-server/pds/virtio-blk-driver/src/main.rs b/crates/examples/microkit/http-server/pds/virtio-blk-driver/src/main.rs index a303519f9..1af8cf5dc 100644 --- a/crates/examples/microkit/http-server/pds/virtio-blk-driver/src/main.rs +++ b/crates/examples/microkit/http-server/pds/virtio-blk-driver/src/main.rs @@ -9,28 +9,47 @@ extern crate alloc; -use alloc::boxed::Box; -use alloc::collections::BTreeMap; -use core::pin::Pin; -use core::ptr::NonNull; +use alloc::{ + boxed::Box, + collections::BTreeMap, +}; +use core::{ + pin::Pin, + ptr::NonNull, +}; use virtio_drivers::{ device::blk::*, transport::{ - DeviceType, Transport, - mmio::{MmioTransport, VirtIOHeader}, + DeviceType, + Transport, + mmio::{ + MmioTransport, + VirtIOHeader, + }, }, }; use sel4_microkit::{ - Channel, ChannelSet, Handler, Infallible, MessageInfo, memory_region_symbol, protection_domain, + Channel, + ChannelSet, + Handler, + Infallible, + MessageInfo, + memory_region_symbol, + protection_domain, var, }; use sel4_microkit_driver_adapters::block::driver::handle_client_request; use sel4_shared_memory::SharedMemoryRef; -use sel4_shared_ring_buffer::{RingBuffers, roles::Use}; +use sel4_shared_ring_buffer::{ + RingBuffers, + roles::Use, +}; use sel4_shared_ring_buffer_block_io_types::{ - BlockIORequest, BlockIORequestStatus, BlockIORequestType, + BlockIORequest, + BlockIORequestStatus, + BlockIORequestType, }; use sel4_virtio_blk::GetBlockDeviceLayoutWrapper; use sel4_virtio_hal_impl::HalImpl; diff --git a/crates/examples/microkit/http-server/pds/virtio-net-driver/src/main.rs b/crates/examples/microkit/http-server/pds/virtio-net-driver/src/main.rs index a1d01310e..9c20310a0 100644 --- a/crates/examples/microkit/http-server/pds/virtio-net-driver/src/main.rs +++ b/crates/examples/microkit/http-server/pds/virtio-net-driver/src/main.rs @@ -12,15 +12,26 @@ use core::ptr::NonNull; use virtio_drivers::{ device::net::*, transport::{ - DeviceType, Transport, - mmio::{MmioTransport, VirtIOHeader}, + DeviceType, + Transport, + mmio::{ + MmioTransport, + VirtIOHeader, + }, }, }; -use sel4_microkit::{memory_region_symbol, protection_domain, var}; +use sel4_microkit::{ + memory_region_symbol, + protection_domain, + var, +}; use sel4_microkit_driver_adapters::net::driver::HandlerImpl; use sel4_shared_memory::SharedMemoryRef; -use sel4_shared_ring_buffer::{RingBuffers, roles::Use}; +use sel4_shared_ring_buffer::{ + RingBuffers, + roles::Use, +}; use sel4_virtio_hal_impl::HalImpl; use sel4_virtio_net::DeviceWrapper; diff --git a/crates/examples/root-task/example-root-task/src/main.rs b/crates/examples/root-task/example-root-task/src/main.rs index 84c96ab2c..308738cd5 100644 --- a/crates/examples/root-task/example-root-task/src/main.rs +++ b/crates/examples/root-task/example-root-task/src/main.rs @@ -7,7 +7,10 @@ #![no_std] #![no_main] -use sel4_root_task::{Never, root_task}; +use sel4_root_task::{ + Never, + root_task, +}; #[root_task] fn main(bootinfo: &sel4::BootInfoPtr) -> sel4::Result { diff --git a/crates/examples/root-task/serial-device/src/device.rs b/crates/examples/root-task/serial-device/src/device.rs index ce6f80e52..397b37f8f 100644 --- a/crates/examples/root-task/serial-device/src/device.rs +++ b/crates/examples/root-task/serial-device/src/device.rs @@ -6,9 +6,19 @@ use core::ops::Deref; -use tock_registers::interfaces::{Readable, Writeable}; -use tock_registers::registers::{ReadOnly, ReadWrite, WriteOnly}; -use tock_registers::{register_bitfields, register_structs}; +use tock_registers::{ + interfaces::{ + Readable, + Writeable, + }, + register_bitfields, + register_structs, + registers::{ + ReadOnly, + ReadWrite, + WriteOnly, + }, +}; register_structs! { #[allow(non_snake_case)] diff --git a/crates/examples/root-task/serial-device/src/main.rs b/crates/examples/root-task/serial-device/src/main.rs index c1af03c0f..ff948a8ff 100644 --- a/crates/examples/root-task/serial-device/src/main.rs +++ b/crates/examples/root-task/serial-device/src/main.rs @@ -10,11 +10,17 @@ use core::ptr; use sel4::CapTypeForObjectOfFixedSize; -use sel4_root_task::{Never, root_task}; +use sel4_root_task::{ + Never, + root_task, +}; mod device; -use device::{Device, RegisterBlock}; +use device::{ + Device, + RegisterBlock, +}; const SERIAL_DEVICE_IRQ: usize = 33; diff --git a/crates/examples/root-task/spawn-task/child/src/runtime.rs b/crates/examples/root-task/spawn-task/child/src/runtime.rs index 5199bd995..9520b20c7 100644 --- a/crates/examples/root-task/spawn-task/child/src/runtime.rs +++ b/crates/examples/root-task/spawn-task/child/src/runtime.rs @@ -9,7 +9,10 @@ use core::ptr; use one_shot_mutex::sync::RawOneShotMutex; use sel4::CapTypeForFrameObjectOfFixedSize; -use sel4_dlmalloc::{StaticDlmalloc, StaticHeap}; +use sel4_dlmalloc::{ + StaticDlmalloc, + StaticHeap, +}; use sel4_panicking::catch_unwind; use sel4_panicking_env::abort; diff --git a/crates/examples/root-task/spawn-task/src/child_vspace.rs b/crates/examples/root-task/spawn-task/src/child_vspace.rs index 0dac78347..eb7f80730 100644 --- a/crates/examples/root-task/spawn-task/src/child_vspace.rs +++ b/crates/examples/root-task/spawn-task/src/child_vspace.rs @@ -8,8 +8,14 @@ use alloc::vec::Vec; use core::ops::Range; use object::{ - Object, ObjectSegment, SegmentFlags, - elf::{PF_R, PF_W, PF_X}, + Object, + ObjectSegment, + SegmentFlags, + elf::{ + PF_R, + PF_W, + PF_X, + }, }; use crate::ObjectAllocator; diff --git a/crates/examples/root-task/spawn-task/src/main.rs b/crates/examples/root-task/spawn-task/src/main.rs index 3eb6c3a41..2ba0b265d 100644 --- a/crates/examples/root-task/spawn-task/src/main.rs +++ b/crates/examples/root-task/spawn-task/src/main.rs @@ -12,9 +12,15 @@ extern crate alloc; use core::ptr; -use object::{File, Object}; - -use sel4_root_task::{Never, root_task}; +use object::{ + File, + Object, +}; + +use sel4_root_task::{ + Never, + root_task, +}; mod child_vspace; mod object_allocator; diff --git a/crates/examples/root-task/spawn-thread/src/main.rs b/crates/examples/root-task/spawn-thread/src/main.rs index 89723dfba..68065915e 100644 --- a/crates/examples/root-task/spawn-thread/src/main.rs +++ b/crates/examples/root-task/spawn-thread/src/main.rs @@ -11,18 +11,30 @@ extern crate alloc; use alloc::boxed::Box; -use core::cell::UnsafeCell; -use core::mem; -use core::ops::Range; -use core::panic::UnwindSafe; -use core::ptr; +use core::{ + cell::UnsafeCell, + mem, + ops::Range, + panic::UnwindSafe, + ptr, +}; use cfg_if::cfg_if; -use sel4_initialize_tls::{TlsImage, UncheckedTlsImage}; -use sel4_phdrs::{PT_TLS, locate_phdrs}; +use sel4_initialize_tls::{ + TlsImage, + UncheckedTlsImage, +}; +use sel4_phdrs::{ + PT_TLS, + locate_phdrs, +}; use sel4_root_task::{ - Never, abort, panicking::catch_unwind, root_task, set_global_allocator_mutex_notification, + Never, + abort, + panicking::catch_unwind, + root_task, + set_global_allocator_mutex_notification, }; use sel4_stack::Stack; diff --git a/crates/experimental/lionsos/sys/build.rs b/crates/experimental/lionsos/sys/build.rs index c9545869a..953807f28 100644 --- a/crates/experimental/lionsos/sys/build.rs +++ b/crates/experimental/lionsos/sys/build.rs @@ -4,9 +4,14 @@ // SPDX-License-Identifier: BSD-2-Clause // -use std::env::{self, VarError}; -use std::fs; -use std::path::PathBuf; +use std::{ + env::{ + self, + VarError, + }, + fs, + path::PathBuf, +}; pub const SEL4_INCLUDE_DIRS_ENV: &str = "SEL4_INCLUDE_DIRS"; pub const SDDF_INCLUDE_DIRS_ENV: &str = "SDDF_INCLUDE_DIRS"; diff --git a/crates/experimental/sddf/ipc-types/src/empty_message.rs b/crates/experimental/sddf/ipc-types/src/empty_message.rs index 2990b7335..e64c40a23 100644 --- a/crates/experimental/sddf/ipc-types/src/empty_message.rs +++ b/crates/experimental/sddf/ipc-types/src/empty_message.rs @@ -7,8 +7,13 @@ use core::convert::Infallible; use crate::{ - MessagParseError, MessageBuilder, MessageLabel, MessageParser, MessageRegisterValue, - MessageWriter, ReadFromMessage, + MessagParseError, + MessageBuilder, + MessageLabel, + MessageParser, + MessageRegisterValue, + MessageWriter, + ReadFromMessage, }; #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] diff --git a/crates/experimental/sddf/ipc-types/src/lib.rs b/crates/experimental/sddf/ipc-types/src/lib.rs index 892183789..d27fbf7b6 100644 --- a/crates/experimental/sddf/ipc-types/src/lib.rs +++ b/crates/experimental/sddf/ipc-types/src/lib.rs @@ -6,9 +6,11 @@ #![no_std] -use core::convert::Infallible; -use core::error::Error; -use core::fmt; +use core::{ + convert::Infallible, + error::Error, + fmt, +}; // // // @@ -17,8 +19,15 @@ mod message_builder; mod message_parser; pub use empty_message::EmptyMessage; -pub use message_builder::{IntoMessageRegisterValue, MessageBuilder}; -pub use message_parser::{MessagParseError, MessageParser, TryFromMessageRegisterValue}; +pub use message_builder::{ + IntoMessageRegisterValue, + MessageBuilder, +}; +pub use message_parser::{ + MessagParseError, + MessageParser, + TryFromMessageRegisterValue, +}; #[cfg(feature = "sel4-microkit-base")] mod when_microkit; diff --git a/crates/experimental/sddf/ipc-types/src/message_builder.rs b/crates/experimental/sddf/ipc-types/src/message_builder.rs index 696b840d0..a287c2627 100644 --- a/crates/experimental/sddf/ipc-types/src/message_builder.rs +++ b/crates/experimental/sddf/ipc-types/src/message_builder.rs @@ -4,7 +4,10 @@ // SPDX-License-Identifier: BSD-2-Clause // -use crate::{MessageLabel, MessageRegisterValue}; +use crate::{ + MessageLabel, + MessageRegisterValue, +}; pub struct MessageBuilder<'a> { label: MessageLabel, diff --git a/crates/experimental/sddf/ipc-types/src/message_parser.rs b/crates/experimental/sddf/ipc-types/src/message_parser.rs index 160c2d66f..ab0199bf4 100644 --- a/crates/experimental/sddf/ipc-types/src/message_parser.rs +++ b/crates/experimental/sddf/ipc-types/src/message_parser.rs @@ -4,10 +4,15 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::error::Error; -use core::fmt; +use core::{ + error::Error, + fmt, +}; -use crate::{MessageLabel, MessageRegisterValue}; +use crate::{ + MessageLabel, + MessageRegisterValue, +}; pub struct MessageParser<'a> { label: MessageLabel, diff --git a/crates/experimental/sddf/ipc-types/src/when_microkit.rs b/crates/experimental/sddf/ipc-types/src/when_microkit.rs index a7deedcba..639e48237 100644 --- a/crates/experimental/sddf/ipc-types/src/when_microkit.rs +++ b/crates/experimental/sddf/ipc-types/src/when_microkit.rs @@ -4,9 +4,19 @@ // SPDX-License-Identifier: BSD-2-Clause // -use sel4_microkit_base::{Channel, MessageInfo, with_msg_regs, with_msg_regs_mut}; +use sel4_microkit_base::{ + Channel, + MessageInfo, + with_msg_regs, + with_msg_regs_mut, +}; -use crate::{CallError, CallTarget, MessageReader, MessageWriter}; +use crate::{ + CallError, + CallTarget, + MessageReader, + MessageWriter, +}; impl CallTarget for Channel { fn call>( diff --git a/crates/experimental/sddf/sys/build.rs b/crates/experimental/sddf/sys/build.rs index 5cb3f35fd..8f2f591dc 100644 --- a/crates/experimental/sddf/sys/build.rs +++ b/crates/experimental/sddf/sys/build.rs @@ -4,9 +4,14 @@ // SPDX-License-Identifier: BSD-2-Clause // -use std::env::{self, VarError}; -use std::fs; -use std::path::PathBuf; +use std::{ + env::{ + self, + VarError, + }, + fs, + path::PathBuf, +}; const SEL4_INCLUDE_DIRS_ENV: &str = "SEL4_INCLUDE_DIRS"; const SDDF_INCLUDE_DIRS_ENV: &str = "SDDF_INCLUDE_DIRS"; diff --git a/crates/experimental/sel4-abstract-allocator/offset-allocator/src/lib.rs b/crates/experimental/sel4-abstract-allocator/offset-allocator/src/lib.rs index 7c055f801..75e2886f3 100644 --- a/crates/experimental/sel4-abstract-allocator/offset-allocator/src/lib.rs +++ b/crates/experimental/sel4-abstract-allocator/offset-allocator/src/lib.rs @@ -6,12 +6,17 @@ #![no_std] -use core::alloc::Layout; -use core::ops::Range; +use core::{ + alloc::Layout, + ops::Range, +}; use offset_allocator::NodeIndex; -use sel4_abstract_allocator::{AbstractAllocator, AbstractAllocatorAllocation}; +use sel4_abstract_allocator::{ + AbstractAllocator, + AbstractAllocatorAllocation, +}; pub struct OffsetAllocator { inner: offset_allocator::Allocator, diff --git a/crates/experimental/sel4-abstract-allocator/src/basic.rs b/crates/experimental/sel4-abstract-allocator/src/basic.rs index 64ee82e33..ae8ae381c 100644 --- a/crates/experimental/sel4-abstract-allocator/src/basic.rs +++ b/crates/experimental/sel4-abstract-allocator/src/basic.rs @@ -5,10 +5,15 @@ // use alloc::collections::BTreeMap; -use core::alloc::Layout; -use core::ops::Range; - -use crate::{AbstractAllocator, AbstractAllocatorAllocation}; +use core::{ + alloc::Layout, + ops::Range, +}; + +use crate::{ + AbstractAllocator, + AbstractAllocatorAllocation, +}; // TODO // This is basically just a free list. Should use a more efficient implementation. diff --git a/crates/experimental/sel4-abstract-allocator/src/bump.rs b/crates/experimental/sel4-abstract-allocator/src/bump.rs index 95e898604..65da499fd 100644 --- a/crates/experimental/sel4-abstract-allocator/src/bump.rs +++ b/crates/experimental/sel4-abstract-allocator/src/bump.rs @@ -4,10 +4,15 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::alloc::Layout; -use core::ops::Range; +use core::{ + alloc::Layout, + ops::Range, +}; -use crate::{AbstractAllocator, AbstractAllocatorAllocation}; +use crate::{ + AbstractAllocator, + AbstractAllocatorAllocation, +}; pub struct BumpAllocator { watermark: usize, diff --git a/crates/experimental/sel4-abstract-allocator/src/by_range.rs b/crates/experimental/sel4-abstract-allocator/src/by_range.rs index 8c9779978..7e4e357ca 100644 --- a/crates/experimental/sel4-abstract-allocator/src/by_range.rs +++ b/crates/experimental/sel4-abstract-allocator/src/by_range.rs @@ -5,10 +5,15 @@ // use alloc::collections::BTreeMap; -use core::alloc::Layout; -use core::ops::Range; +use core::{ + alloc::Layout, + ops::Range, +}; -use crate::{AbstractAllocator, AbstractAllocatorAllocation}; +use crate::{ + AbstractAllocator, + AbstractAllocatorAllocation, +}; pub struct ByRange { inner: A, diff --git a/crates/experimental/sel4-abstract-allocator/src/lib.rs b/crates/experimental/sel4-abstract-allocator/src/lib.rs index f044428d8..325b4917e 100644 --- a/crates/experimental/sel4-abstract-allocator/src/lib.rs +++ b/crates/experimental/sel4-abstract-allocator/src/lib.rs @@ -9,9 +9,11 @@ #[cfg(feature = "alloc")] extern crate alloc; -use core::alloc::Layout; -use core::fmt; -use core::ops::Range; +use core::{ + alloc::Layout, + fmt, + ops::Range, +}; pub mod bump; diff --git a/crates/experimental/sel4-abstract-rc/src/lib.rs b/crates/experimental/sel4-abstract-rc/src/lib.rs index d1790edfe..8ead392c0 100644 --- a/crates/experimental/sel4-abstract-rc/src/lib.rs +++ b/crates/experimental/sel4-abstract-rc/src/lib.rs @@ -8,8 +8,10 @@ extern crate alloc; -use alloc::rc::Rc; -use alloc::sync::Arc; +use alloc::{ + rc::Rc, + sync::Arc, +}; use core::ops::Deref; pub trait AbstractRcT { diff --git a/crates/experimental/sel4-async/block-io/fat/src/block_io_wrapper.rs b/crates/experimental/sel4-async/block-io/fat/src/block_io_wrapper.rs index 960ac4837..17f320d91 100644 --- a/crates/experimental/sel4-async/block-io/fat/src/block_io_wrapper.rs +++ b/crates/experimental/sel4-async/block-io/fat/src/block_io_wrapper.rs @@ -4,14 +4,20 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::convert::Infallible; -use core::marker::PhantomData; +use core::{ + convert::Infallible, + marker::PhantomData, +}; use futures::future; use sel4_async_block_io::{ - BlockIO, Operation, - access::{Access, Witness}, + BlockIO, + Operation, + access::{ + Access, + Witness, + }, constant_block_sizes, }; diff --git a/crates/experimental/sel4-async/block-io/src/access.rs b/crates/experimental/sel4-async/block-io/src/access.rs index 3b5e337f4..4030da588 100644 --- a/crates/experimental/sel4-async/block-io/src/access.rs +++ b/crates/experimental/sel4-async/block-io/src/access.rs @@ -41,7 +41,11 @@ pub trait WriteAccess: Access { use sealing::AccessSealed; mod sealing { - use super::{ReadOnly, ReadWrite, WriteOnly}; + use super::{ + ReadOnly, + ReadWrite, + WriteOnly, + }; pub trait AccessSealed {} diff --git a/crates/experimental/sel4-async/block-io/src/disk.rs b/crates/experimental/sel4-async/block-io/src/disk.rs index f8a88a7b4..8c09fb288 100644 --- a/crates/experimental/sel4-async/block-io/src/disk.rs +++ b/crates/experimental/sel4-async/block-io/src/disk.rs @@ -4,13 +4,27 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::mem; -use core::ops::Range; - -use gpt_disk_types::{GptHeader, MasterBootRecord, MbrPartitionRecord}; -use num_enum::{IntoPrimitive, TryFromPrimitive}; - -use crate::{BlockIO, Partition, access::ReadOnly, read_bytes}; +use core::{ + mem, + ops::Range, +}; + +use gpt_disk_types::{ + GptHeader, + MasterBootRecord, + MbrPartitionRecord, +}; +use num_enum::{ + IntoPrimitive, + TryFromPrimitive, +}; + +use crate::{ + BlockIO, + Partition, + access::ReadOnly, + read_bytes, +}; pub struct Disk { io: T, diff --git a/crates/experimental/sel4-async/block-io/src/lib.rs b/crates/experimental/sel4-async/block-io/src/lib.rs index 049b2eaa0..afe8d7c08 100644 --- a/crates/experimental/sel4-async/block-io/src/lib.rs +++ b/crates/experimental/sel4-async/block-io/src/lib.rs @@ -9,10 +9,12 @@ #[cfg(feature = "alloc")] extern crate alloc; -use core::cell::RefCell; -use core::convert::Infallible; -use core::fmt; -use core::ops::Range; +use core::{ + cell::RefCell, + convert::Infallible, + fmt, + ops::Range, +}; use futures::future; @@ -21,15 +23,27 @@ pub mod disk; mod operation; -pub use operation::{Operation, OperationType}; +pub use operation::{ + Operation, + OperationType, +}; -use access::{Access, ReadAccess, ReadOnly, ReadWrite, WriteAccess}; +use access::{ + Access, + ReadAccess, + ReadOnly, + ReadWrite, + WriteAccess, +}; #[cfg(feature = "alloc")] mod when_alloc; #[cfg(feature = "alloc")] -pub use when_alloc::{CachedBlockIO, DynamicBlockSize}; +pub use when_alloc::{ + CachedBlockIO, + DynamicBlockSize, +}; pub trait BlockIOLayout { type Error: fmt::Debug; @@ -107,7 +121,12 @@ pub trait HasPrevBlockSize: ConstantBlockSize { } pub mod constant_block_sizes { - use super::{BlockSize, ConstantBlockSize, HasNextBlockSize, HasPrevBlockSize}; + use super::{ + BlockSize, + ConstantBlockSize, + HasNextBlockSize, + HasPrevBlockSize, + }; macro_rules! declare_block_size { ($ident:ident, $n:literal) => { diff --git a/crates/experimental/sel4-async/block-io/src/operation.rs b/crates/experimental/sel4-async/block-io/src/operation.rs index 039294b16..2388f40fa 100644 --- a/crates/experimental/sel4-async/block-io/src/operation.rs +++ b/crates/experimental/sel4-async/block-io/src/operation.rs @@ -4,10 +4,21 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::ops::Range; -use core::slice::{Chunks, ChunksMut}; - -use crate::access::{Access, ReadAccess, ReadOnly, WriteAccess, WriteOnly}; +use core::{ + ops::Range, + slice::{ + Chunks, + ChunksMut, + }, +}; + +use crate::access::{ + Access, + ReadAccess, + ReadOnly, + WriteAccess, + WriteOnly, +}; pub enum Operation<'a, A: Access> { Read { diff --git a/crates/experimental/sel4-async/block-io/src/when_alloc.rs b/crates/experimental/sel4-async/block-io/src/when_alloc.rs index 61be6e031..7e582a830 100644 --- a/crates/experimental/sel4-async/block-io/src/when_alloc.rs +++ b/crates/experimental/sel4-async/block-io/src/when_alloc.rs @@ -4,17 +4,28 @@ // SPDX-License-Identifier: BSD-2-Clause // -use alloc::rc::Rc; -use alloc::vec; -use alloc::vec::Vec; -use core::cell::RefCell; -use core::num::NonZeroUsize; -use core::ops::Deref; +use alloc::{ + rc::Rc, + vec, + vec::Vec, +}; +use core::{ + cell::RefCell, + num::NonZeroUsize, + ops::Deref, +}; use futures::future; use lru::LruCache; -use crate::{Access, BlockIO, BlockIOLayout, BlockSize, Operation, wrapper_methods}; +use crate::{ + Access, + BlockIO, + BlockIOLayout, + BlockSize, + Operation, + wrapper_methods, +}; pub struct DynamicBlockSize { bits: usize, diff --git a/crates/experimental/sel4-async/io/src/lib.rs b/crates/experimental/sel4-async/io/src/lib.rs index 529a2dbe6..e1748fb39 100644 --- a/crates/experimental/sel4-async/io/src/lib.rs +++ b/crates/experimental/sel4-async/io/src/lib.rs @@ -9,13 +9,28 @@ #![no_std] -use core::future::{Future, poll_fn}; -use core::pin::{Pin, pin}; -use core::task::{Context, Poll}; +use core::{ + future::{ + Future, + poll_fn, + }, + pin::{ + Pin, + pin, + }, + task::{ + Context, + Poll, + }, +}; use embedded_io_async as eio; -pub use embedded_io_async::{Error, ErrorKind, ErrorType}; +pub use embedded_io_async::{ + Error, + ErrorKind, + ErrorType, +}; pub trait Read: ErrorType { fn poll_read( diff --git a/crates/experimental/sel4-async/network/rustls/src/conn.rs b/crates/experimental/sel4-async/network/rustls/src/conn.rs index 141242b03..22acba9a6 100644 --- a/crates/experimental/sel4-async/network/rustls/src/conn.rs +++ b/crates/experimental/sel4-async/network/rustls/src/conn.rs @@ -6,28 +6,58 @@ // Derived from https://github.com/rustls/rustls/pull/1648 by https://github.com/japaric -use core::future::Future; -use core::marker::PhantomData; -use core::mem; -use core::ops::DerefMut; -use core::pin::Pin; -use core::task::{self, Poll}; +use core::{ + future::Future, + marker::PhantomData, + mem, + ops::DerefMut, + pin::Pin, + task::{ + self, + Poll, + }, +}; use alloc::sync::Arc; -use rustls::client::{ClientConnectionData, UnbufferedClientConnection}; -use rustls::pki_types::ServerName; -use rustls::server::{ServerConnectionData, UnbufferedServerConnection}; -use rustls::unbuffered::{ - AppDataRecord, ConnectionState, EncodeError, EncryptError, UnbufferedStatus, +use rustls::{ + ClientConfig, + ServerConfig, + SideData, + client::{ + ClientConnectionData, + UnbufferedClientConnection, + }, + pki_types::ServerName, + server::{ + ServerConnectionData, + UnbufferedServerConnection, + }, + unbuffered::{ + AppDataRecord, + ConnectionState, + EncodeError, + EncryptError, + UnbufferedConnectionCommon, + UnbufferedStatus, + }, }; -use rustls::{ClientConfig, ServerConfig, SideData, unbuffered::UnbufferedConnectionCommon}; -use sel4_async_io::{ErrorType, Read, Write}; +use sel4_async_io::{ + ErrorType, + Read, + Write, +}; use crate::{ Error, - utils::{Buffer, WriteCursor, poll_read, poll_write, try_or_resize_and_retry}, + utils::{ + Buffer, + WriteCursor, + poll_read, + poll_write, + try_or_resize_and_retry, + }, }; pub struct ClientConnector { diff --git a/crates/experimental/sel4-async/network/rustls/src/error.rs b/crates/experimental/sel4-async/network/rustls/src/error.rs index 2825ccf18..32030c16e 100644 --- a/crates/experimental/sel4-async/network/rustls/src/error.rs +++ b/crates/experimental/sel4-async/network/rustls/src/error.rs @@ -6,11 +6,19 @@ use core::fmt::Debug; -use rustls::Error as TlsError; -use rustls::unbuffered::{EncodeError, EncryptError}; +use rustls::{ + Error as TlsError, + unbuffered::{ + EncodeError, + EncryptError, + }, +}; use thiserror::Error; -use sel4_async_io::{Error as AsyncIOError, ErrorKind}; +use sel4_async_io::{ + Error as AsyncIOError, + ErrorKind, +}; #[derive(Debug, Error)] pub enum Error { diff --git a/crates/experimental/sel4-async/network/rustls/src/lib.rs b/crates/experimental/sel4-async/network/rustls/src/lib.rs index aed51b464..ddf3f896d 100644 --- a/crates/experimental/sel4-async/network/rustls/src/lib.rs +++ b/crates/experimental/sel4-async/network/rustls/src/lib.rs @@ -12,5 +12,9 @@ mod conn; mod error; mod utils; -pub use conn::{ClientConnector, ServerConnector, TlsStream}; +pub use conn::{ + ClientConnector, + ServerConnector, + TlsStream, +}; pub use error::Error; diff --git a/crates/experimental/sel4-async/network/rustls/src/utils.rs b/crates/experimental/sel4-async/network/rustls/src/utils.rs index 44d1eed50..7a19bdba4 100644 --- a/crates/experimental/sel4-async/network/rustls/src/utils.rs +++ b/crates/experimental/sel4-async/network/rustls/src/utils.rs @@ -7,12 +7,20 @@ // Derived from https://github.com/rustls/rustls/pull/1648 by https://github.com/japaric use alloc::vec::Vec; -use core::pin::Pin; -use core::task::{self, Poll}; +use core::{ + pin::Pin, + task::{ + self, + Poll, + }, +}; use rustls::unbuffered::InsufficientSizeError; -use sel4_async_io::{Read, Write}; +use sel4_async_io::{ + Read, + Write, +}; use crate::Error; diff --git a/crates/experimental/sel4-async/network/rustls/utils/src/dummy_custom_getrandom.rs b/crates/experimental/sel4-async/network/rustls/utils/src/dummy_custom_getrandom.rs index 58ca88586..73965e530 100644 --- a/crates/experimental/sel4-async/network/rustls/utils/src/dummy_custom_getrandom.rs +++ b/crates/experimental/sel4-async/network/rustls/utils/src/dummy_custom_getrandom.rs @@ -6,8 +6,11 @@ use core::cell::RefCell; -use rand::rngs::SmallRng; -use rand::{Rng, SeedableRng}; +use rand::{ + Rng, + SeedableRng, + rngs::SmallRng, +}; #[cfg(not(target_thread_local))] compile_error!(""); diff --git a/crates/experimental/sel4-async/network/rustls/utils/src/no_server_cert_verifier.rs b/crates/experimental/sel4-async/network/rustls/utils/src/no_server_cert_verifier.rs index 9a78afc09..4bfb32963 100644 --- a/crates/experimental/sel4-async/network/rustls/utils/src/no_server_cert_verifier.rs +++ b/crates/experimental/sel4-async/network/rustls/utils/src/no_server_cert_verifier.rs @@ -6,9 +6,21 @@ use alloc::vec::Vec; -use rustls::client::danger::{HandshakeSignatureValid, ServerCertVerified, ServerCertVerifier}; -use rustls::pki_types::{CertificateDer, ServerName, UnixTime}; -use rustls::{DigitallySignedStruct, Error, SignatureScheme}; +use rustls::{ + DigitallySignedStruct, + Error, + SignatureScheme, + client::danger::{ + HandshakeSignatureValid, + ServerCertVerified, + ServerCertVerifier, + }, + pki_types::{ + CertificateDer, + ServerName, + UnixTime, + }, +}; #[derive(Debug)] pub struct NoServerCertVerifier; diff --git a/crates/experimental/sel4-async/network/rustls/utils/src/time_provider_impl.rs b/crates/experimental/sel4-async/network/rustls/utils/src/time_provider_impl.rs index c17710e23..729369d00 100644 --- a/crates/experimental/sel4-async/network/rustls/utils/src/time_provider_impl.rs +++ b/crates/experimental/sel4-async/network/rustls/utils/src/time_provider_impl.rs @@ -4,11 +4,15 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::fmt; -use core::time::Duration; +use core::{ + fmt, + time::Duration, +}; -use rustls::pki_types::UnixTime; -use rustls::time_provider::TimeProvider; +use rustls::{ + pki_types::UnixTime, + time_provider::TimeProvider, +}; use sel4_async_time::Instant; diff --git a/crates/experimental/sel4-async/network/src/lib.rs b/crates/experimental/sel4-async/network/src/lib.rs index 9775eb6cb..208cb099a 100644 --- a/crates/experimental/sel4-async/network/src/lib.rs +++ b/crates/experimental/sel4-async/network/src/lib.rs @@ -11,27 +11,63 @@ extern crate alloc; -use alloc::rc::Rc; -use alloc::vec; -use alloc::vec::Vec; -use core::cell::RefCell; -use core::future::poll_fn; -use core::marker::PhantomData; -use core::pin::Pin; -use core::task::{self, Poll}; +use alloc::{ + rc::Rc, + vec, + vec::Vec, +}; +use core::{ + cell::RefCell, + future::poll_fn, + marker::PhantomData, + pin::Pin, + task::{ + self, + Poll, + }, +}; use thiserror::Error; use log::info; use smoltcp::{ - iface::{Config, Context, Interface, PollResult, SocketHandle, SocketSet}, + iface::{ + Config, + Context, + Interface, + PollResult, + SocketHandle, + SocketSet, + }, phy::Device, - socket::{AnySocket, dhcpv4, dns, tcp}, - time::{Duration, Instant}, - wire::{DnsQueryType, IpAddress, IpCidr, IpEndpoint, IpListenEndpoint, Ipv4Address, Ipv4Cidr}, + socket::{ + AnySocket, + dhcpv4, + dns, + tcp, + }, + time::{ + Duration, + Instant, + }, + wire::{ + DnsQueryType, + IpAddress, + IpCidr, + IpEndpoint, + IpListenEndpoint, + Ipv4Address, + Ipv4Cidr, + }, }; -use sel4_async_io::{Error as AsyncIOError, ErrorKind, ErrorType, Read, Write}; +use sel4_async_io::{ + Error as AsyncIOError, + ErrorKind, + ErrorType, + Read, + Write, +}; pub(crate) const DEFAULT_KEEP_ALIVE_INTERVAL: u64 = 75000; pub(crate) const DEFAULT_TCP_SOCKET_BUFFER_SIZE: usize = 65535; diff --git a/crates/experimental/sel4-async/single-threaded-executor/src/enter.rs b/crates/experimental/sel4-async/single-threaded-executor/src/enter.rs index 101f6460d..cc1f3b372 100644 --- a/crates/experimental/sel4-async/single-threaded-executor/src/enter.rs +++ b/crates/experimental/sel4-async/single-threaded-executor/src/enter.rs @@ -6,8 +6,10 @@ // SPDX-License-Identifier: MIT OR Apache-2.0 // -use core::cell::Cell; -use core::fmt; +use core::{ + cell::Cell, + fmt, +}; #[thread_local] static ENTERED: Cell = Cell::new(false); diff --git a/crates/experimental/sel4-async/single-threaded-executor/src/lib.rs b/crates/experimental/sel4-async/single-threaded-executor/src/lib.rs index 0647567e6..c7ac1f10c 100644 --- a/crates/experimental/sel4-async/single-threaded-executor/src/lib.rs +++ b/crates/experimental/sel4-async/single-threaded-executor/src/lib.rs @@ -11,19 +11,44 @@ extern crate alloc; -use alloc::rc::{Rc, Weak}; -use alloc::sync::Arc; -use alloc::vec::Vec; -use core::cell::{OnceCell, RefCell}; -use core::pin::Pin; -use core::sync::atomic::{AtomicBool, Ordering}; - -use futures::future::Future; -use futures::stream::FuturesUnordered; -use futures::stream::StreamExt; -use futures::task::{ArcWake, waker_ref}; -use futures::task::{Context, Poll}; -use futures::task::{FutureObj, LocalFutureObj, LocalSpawn, Spawn, SpawnError}; +use alloc::{ + rc::{ + Rc, + Weak, + }, + sync::Arc, + vec::Vec, +}; +use core::{ + cell::{ + OnceCell, + RefCell, + }, + pin::Pin, + sync::atomic::{ + AtomicBool, + Ordering, + }, +}; + +use futures::{ + future::Future, + stream::{ + FuturesUnordered, + StreamExt, + }, + task::{ + ArcWake, + Context, + FutureObj, + LocalFutureObj, + LocalSpawn, + Poll, + Spawn, + SpawnError, + waker_ref, + }, +}; mod enter; diff --git a/crates/experimental/sel4-async/time/src/instant.rs b/crates/experimental/sel4-async/time/src/instant.rs index 042bd217f..f6ec9ea07 100644 --- a/crates/experimental/sel4-async/time/src/instant.rs +++ b/crates/experimental/sel4-async/time/src/instant.rs @@ -4,8 +4,15 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::ops::{Add, AddAssign, Sub, SubAssign}; -use core::time::Duration; +use core::{ + ops::{ + Add, + AddAssign, + Sub, + SubAssign, + }, + time::Duration, +}; #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct Instant { diff --git a/crates/experimental/sel4-async/time/src/lib.rs b/crates/experimental/sel4-async/time/src/lib.rs index 822d75874..1aad6fa5a 100644 --- a/crates/experimental/sel4-async/time/src/lib.rs +++ b/crates/experimental/sel4-async/time/src/lib.rs @@ -9,11 +9,17 @@ extern crate alloc; use alloc::rc::Rc; -use core::cell::RefCell; -use core::fmt; -use core::future::Future; -use core::pin::Pin; -use core::task::{Context, Poll, Waker}; +use core::{ + cell::RefCell, + fmt, + future::Future, + pin::Pin, + task::{ + Context, + Poll, + Waker, + }, +}; use pin_project::pin_project; @@ -22,7 +28,10 @@ mod sub_key; mod timer_queue; use sub_key::SubKey; -use timer_queue::{Key, TimerQueue}; +use timer_queue::{ + Key, + TimerQueue, +}; pub use instant::Instant; diff --git a/crates/experimental/sel4-async/time/src/timer_queue.rs b/crates/experimental/sel4-async/time/src/timer_queue.rs index d510daafc..79bb30b5d 100644 --- a/crates/experimental/sel4-async/time/src/timer_queue.rs +++ b/crates/experimental/sel4-async/time/src/timer_queue.rs @@ -4,7 +4,10 @@ // SPDX-License-Identifier: BSD-2-Clause // -use alloc::collections::btree_map::{BTreeMap, Entry}; +use alloc::collections::btree_map::{ + BTreeMap, + Entry, +}; use crate::SubKey; diff --git a/crates/experimental/sel4-async/unsync/src/mutex.rs b/crates/experimental/sel4-async/unsync/src/mutex.rs index 8918ea132..13979156e 100644 --- a/crates/experimental/sel4-async/unsync/src/mutex.rs +++ b/crates/experimental/sel4-async/unsync/src/mutex.rs @@ -4,10 +4,21 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::cell::{RefCell, RefMut}; -use core::ops::{Deref, DerefMut}; +use core::{ + cell::{ + RefCell, + RefMut, + }, + ops::{ + Deref, + DerefMut, + }, +}; -use async_unsync::semaphore::{Permit, Semaphore}; +use async_unsync::semaphore::{ + Permit, + Semaphore, +}; pub struct Mutex { data: RefCell, // remove need for unsafe diff --git a/crates/experimental/sel4-backtrace/addr2line-context-helper/src/lib.rs b/crates/experimental/sel4-backtrace/addr2line-context-helper/src/lib.rs index 0dfe68a72..581e5a33e 100644 --- a/crates/experimental/sel4-backtrace/addr2line-context-helper/src/lib.rs +++ b/crates/experimental/sel4-backtrace/addr2line-context-helper/src/lib.rs @@ -11,7 +11,10 @@ extern crate alloc; use alloc::rc::Rc; use addr2line::Context as AbstractContext; -use object::{Object, ObjectSection}; +use object::{ + Object, + ObjectSection, +}; pub type Context = AbstractContext>; diff --git a/crates/experimental/sel4-backtrace/embedded-debug-info/cli/src/bin/sel4-embed-debug-info.rs b/crates/experimental/sel4-backtrace/embedded-debug-info/cli/src/bin/sel4-embed-debug-info.rs index 6a2730fbf..70fdca409 100644 --- a/crates/experimental/sel4-backtrace/embedded-debug-info/cli/src/bin/sel4-embed-debug-info.rs +++ b/crates/experimental/sel4-backtrace/embedded-debug-info/cli/src/bin/sel4-embed-debug-info.rs @@ -4,13 +4,18 @@ // SPDX-License-Identifier: BSD-2-Clause // -use std::fs; -use std::io; +use std::{ + fs, + io, +}; use clap::Parser; use object::read::elf::ElfFile; -use sel4_patch_elf::{FileHeaderExt, Patching}; +use sel4_patch_elf::{ + FileHeaderExt, + Patching, +}; use sel4_phdrs_constants::PT_SEL4_EMBEDDED_DEBUG_INFO; #[derive(Parser, Debug)] diff --git a/crates/experimental/sel4-backtrace/embedded-debug-info/src/lib.rs b/crates/experimental/sel4-backtrace/embedded-debug-info/src/lib.rs index 468647857..f1df91ee3 100644 --- a/crates/experimental/sel4-backtrace/embedded-debug-info/src/lib.rs +++ b/crates/experimental/sel4-backtrace/embedded-debug-info/src/lib.rs @@ -6,8 +6,15 @@ #![no_std] -use sel4_backtrace_addr2line_context_helper::{Context, Error, new_context}; -use sel4_phdrs::{PT_SEL4_EMBEDDED_DEBUG_INFO, locate_phdrs}; +use sel4_backtrace_addr2line_context_helper::{ + Context, + Error, + new_context, +}; +use sel4_phdrs::{ + PT_SEL4_EMBEDDED_DEBUG_INFO, + locate_phdrs, +}; use sel4_phdrs_patched as _; diff --git a/crates/experimental/sel4-backtrace/simple/src/lib.rs b/crates/experimental/sel4-backtrace/simple/src/lib.rs index 4d433a0b3..952cd1de0 100644 --- a/crates/experimental/sel4-backtrace/simple/src/lib.rs +++ b/crates/experimental/sel4-backtrace/simple/src/lib.rs @@ -8,8 +8,14 @@ use core::convert::Infallible; -use sel4_backtrace::{BacktraceSendWithToken, BacktraceSendWithoutToken}; -use sel4_panicking_env::{debug_print, debug_println}; +use sel4_backtrace::{ + BacktraceSendWithToken, + BacktraceSendWithoutToken, +}; +use sel4_panicking_env::{ + debug_print, + debug_println, +}; #[cfg(feature = "alloc")] use sel4_backtrace::Backtrace; diff --git a/crates/experimental/sel4-backtrace/src/lib.rs b/crates/experimental/sel4-backtrace/src/lib.rs index 270eb8c3c..3dc0ea5fa 100644 --- a/crates/experimental/sel4-backtrace/src/lib.rs +++ b/crates/experimental/sel4-backtrace/src/lib.rs @@ -11,7 +11,10 @@ use core::convert::Infallible; #[cfg(feature = "postcard")] use serde::Serialize; -use sel4_backtrace_types::{Entry, Error as BacktraceError}; +use sel4_backtrace_types::{ + Entry, + Error as BacktraceError, +}; cfg_if::cfg_if! { if #[cfg(all(feature = "unwinding", panic = "unwind"))] { diff --git a/crates/experimental/sel4-backtrace/symbolize/src/lib.rs b/crates/experimental/sel4-backtrace/symbolize/src/lib.rs index dab7eaa16..0fd2624dc 100644 --- a/crates/experimental/sel4-backtrace/symbolize/src/lib.rs +++ b/crates/experimental/sel4-backtrace/symbolize/src/lib.rs @@ -15,9 +15,12 @@ extern crate alloc; use alloc::borrow::Cow; use core::fmt; -use addr2line::fallible_iterator::FallibleIterator; -use addr2line::gimli; -use addr2line::{Context, Location}; +use addr2line::{ + Context, + Location, + fallible_iterator::FallibleIterator, + gimli, +}; fn print_loc(w: &mut impl fmt::Write, loc: Option<&Location<'_>>) -> Result<(), fmt::Error> { if let Some(loc) = loc { diff --git a/crates/experimental/sel4-backtrace/types/src/lib.rs b/crates/experimental/sel4-backtrace/types/src/lib.rs index a3db6b902..d51b97af1 100644 --- a/crates/experimental/sel4-backtrace/types/src/lib.rs +++ b/crates/experimental/sel4-backtrace/types/src/lib.rs @@ -10,7 +10,10 @@ extern crate alloc; #[cfg(feature = "serde")] -use serde::{Deserialize, Serialize}; +use serde::{ + Deserialize, + Serialize, +}; cfg_if::cfg_if! { if #[cfg(feature = "alloc")] { diff --git a/crates/experimental/sel4-backtrace/types/src/with_alloc.rs b/crates/experimental/sel4-backtrace/types/src/with_alloc.rs index 24db6074f..69dcd2602 100644 --- a/crates/experimental/sel4-backtrace/types/src/with_alloc.rs +++ b/crates/experimental/sel4-backtrace/types/src/with_alloc.rs @@ -4,15 +4,20 @@ // SPDX-License-Identifier: MIT // -use alloc::vec; -use alloc::vec::Vec; +use alloc::{ + vec, + vec::Vec, +}; use core::convert::Infallible; #[cfg(feature = "postcard")] use core::fmt; #[cfg(feature = "serde")] -use serde::{Deserialize, Serialize}; +use serde::{ + Deserialize, + Serialize, +}; use crate::*; @@ -139,8 +144,10 @@ impl fmt::Display for DisplayHex<'_, T> { mod test { extern crate std; - use alloc::borrow::ToOwned; - use alloc::string::String; + use alloc::{ + borrow::ToOwned, + string::String, + }; use super::*; diff --git a/crates/experimental/sel4-backtrace/types/src/with_postcard.rs b/crates/experimental/sel4-backtrace/types/src/with_postcard.rs index 136b49888..210811cca 100644 --- a/crates/experimental/sel4-backtrace/types/src/with_postcard.rs +++ b/crates/experimental/sel4-backtrace/types/src/with_postcard.rs @@ -7,7 +7,11 @@ use postcard::ser_flavors::Flavor; use serde::Serialize; -use crate::{Entry, Postamble, Preamble}; +use crate::{ + Entry, + Postamble, + Preamble, +}; struct LameFlavor { send_byte: F, diff --git a/crates/experimental/sel4-backtrace/types/src/with_symbolize.rs b/crates/experimental/sel4-backtrace/types/src/with_symbolize.rs index 1efac6964..977fe96b2 100644 --- a/crates/experimental/sel4-backtrace/types/src/with_symbolize.rs +++ b/crates/experimental/sel4-backtrace/types/src/with_symbolize.rs @@ -9,9 +9,13 @@ use core::fmt; -use addr2line::Context; -use addr2line::gimli::Error; -use addr2line::gimli::read::Reader; +use addr2line::{ + Context, + gimli::{ + Error, + read::Reader, + }, +}; use sel4_backtrace_symbolize::symbolize; diff --git a/crates/experimental/sel4-driver-interfaces/src/block.rs b/crates/experimental/sel4-driver-interfaces/src/block.rs index ffb3c27f0..468b26e80 100644 --- a/crates/experimental/sel4-driver-interfaces/src/block.rs +++ b/crates/experimental/sel4-driver-interfaces/src/block.rs @@ -4,14 +4,26 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::cell::RefCell; -use core::fmt; -use core::ops::Deref; +use core::{ + cell::RefCell, + fmt, + ops::Deref, +}; -use lock_api::{Mutex, RawMutex}; -use serde::{Deserialize, Serialize}; +use lock_api::{ + Mutex, + RawMutex, +}; +use serde::{ + Deserialize, + Serialize, +}; -use crate::{WrappedMutex, WrappedRefCell, WrappedRefCellError}; +use crate::{ + WrappedMutex, + WrappedRefCell, + WrappedRefCellError, +}; #[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] pub struct MacAddress(pub [u8; 6]); diff --git a/crates/experimental/sel4-driver-interfaces/src/lib.rs b/crates/experimental/sel4-driver-interfaces/src/lib.rs index 775959f5c..a620399b5 100644 --- a/crates/experimental/sel4-driver-interfaces/src/lib.rs +++ b/crates/experimental/sel4-driver-interfaces/src/lib.rs @@ -6,11 +6,22 @@ #![no_std] -use core::cell::{RefCell, RefMut}; -use core::fmt; -use core::ops::{Deref, DerefMut}; +use core::{ + cell::{ + RefCell, + RefMut, + }, + fmt, + ops::{ + Deref, + DerefMut, + }, +}; -use lock_api::{Mutex, RawMutex}; +use lock_api::{ + Mutex, + RawMutex, +}; pub mod block; pub mod net; diff --git a/crates/experimental/sel4-driver-interfaces/src/net.rs b/crates/experimental/sel4-driver-interfaces/src/net.rs index 736407826..4e0ea369b 100644 --- a/crates/experimental/sel4-driver-interfaces/src/net.rs +++ b/crates/experimental/sel4-driver-interfaces/src/net.rs @@ -4,14 +4,26 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::cell::RefCell; -use core::fmt; -use core::ops::Deref; - -use lock_api::{Mutex, RawMutex}; -use serde::{Deserialize, Serialize}; - -use crate::{WrappedMutex, WrappedRefCell, WrappedRefCellError}; +use core::{ + cell::RefCell, + fmt, + ops::Deref, +}; + +use lock_api::{ + Mutex, + RawMutex, +}; +use serde::{ + Deserialize, + Serialize, +}; + +use crate::{ + WrappedMutex, + WrappedRefCell, + WrappedRefCellError, +}; #[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] pub struct MacAddress(pub [u8; 6]); diff --git a/crates/experimental/sel4-driver-interfaces/src/rtc.rs b/crates/experimental/sel4-driver-interfaces/src/rtc.rs index 525a61ca2..2954e625f 100644 --- a/crates/experimental/sel4-driver-interfaces/src/rtc.rs +++ b/crates/experimental/sel4-driver-interfaces/src/rtc.rs @@ -4,14 +4,31 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::cell::RefCell; -use core::ops::Deref; - -use lock_api::{Mutex, RawMutex}; - -use crate::{WrappedMutex, WrappedRefCell, WrappedRefCellError}; - -pub use rtcc::{DateTime, DateTimeAccess, Datelike, NaiveDate, NaiveDateTime, NaiveTime, Timelike}; +use core::{ + cell::RefCell, + ops::Deref, +}; + +use lock_api::{ + Mutex, + RawMutex, +}; + +use crate::{ + WrappedMutex, + WrappedRefCell, + WrappedRefCellError, +}; + +pub use rtcc::{ + DateTime, + DateTimeAccess, + Datelike, + NaiveDate, + NaiveDateTime, + NaiveTime, + Timelike, +}; impl>, U: DateTimeAccess> DateTimeAccess for &WrappedRefCell { type Error = WrappedRefCellError; diff --git a/crates/experimental/sel4-driver-interfaces/src/serial/mod.rs b/crates/experimental/sel4-driver-interfaces/src/serial/mod.rs index 6ac446c08..ddb6e73ac 100644 --- a/crates/experimental/sel4-driver-interfaces/src/serial/mod.rs +++ b/crates/experimental/sel4-driver-interfaces/src/serial/mod.rs @@ -4,15 +4,32 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::cell::RefCell; -use core::ops::Deref; - -use lock_api::{Mutex, RawMutex}; - -use crate::{WrappedMutex, WrappedRefCell, WrappedRefCellError}; - -pub use embedded_hal_nb::nb; -pub use embedded_hal_nb::serial::{Error, ErrorKind, ErrorType, Read, Write}; +use core::{ + cell::RefCell, + ops::Deref, +}; + +use lock_api::{ + Mutex, + RawMutex, +}; + +use crate::{ + WrappedMutex, + WrappedRefCell, + WrappedRefCellError, +}; + +pub use embedded_hal_nb::{ + nb, + serial::{ + Error, + ErrorKind, + ErrorType, + Read, + Write, + }, +}; mod write_buffered; diff --git a/crates/experimental/sel4-driver-interfaces/src/serial/write_buffered.rs b/crates/experimental/sel4-driver-interfaces/src/serial/write_buffered.rs index 63a168df6..726d70701 100644 --- a/crates/experimental/sel4-driver-interfaces/src/serial/write_buffered.rs +++ b/crates/experimental/sel4-driver-interfaces/src/serial/write_buffered.rs @@ -4,8 +4,10 @@ // SPDX-License-Identifier: BSD-2-Clause // -use embedded_hal_nb::nb; -use embedded_hal_nb::serial; +use embedded_hal_nb::{ + nb, + serial, +}; use heapless::Deque; #[derive(Debug, Clone)] diff --git a/crates/experimental/sel4-driver-interfaces/src/timer.rs b/crates/experimental/sel4-driver-interfaces/src/timer.rs index 18b39729d..4d8694812 100644 --- a/crates/experimental/sel4-driver-interfaces/src/timer.rs +++ b/crates/experimental/sel4-driver-interfaces/src/timer.rs @@ -4,14 +4,24 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::cell::RefCell; -use core::fmt; -use core::ops::Deref; -use core::time::Duration; - -use lock_api::{Mutex, RawMutex}; - -use crate::{HandleInterrupt, WrappedMutex, WrappedRefCell, WrappedRefCellError}; +use core::{ + cell::RefCell, + fmt, + ops::Deref, + time::Duration, +}; + +use lock_api::{ + Mutex, + RawMutex, +}; + +use crate::{ + HandleInterrupt, + WrappedMutex, + WrappedRefCell, + WrappedRefCellError, +}; pub trait ErrorType { type Error: fmt::Debug; diff --git a/crates/experimental/sel4-linux-syscall-types/src/lib.rs b/crates/experimental/sel4-linux-syscall-types/src/lib.rs index c7da8b964..728b31576 100644 --- a/crates/experimental/sel4-linux-syscall-types/src/lib.rs +++ b/crates/experimental/sel4-linux-syscall-types/src/lib.rs @@ -9,14 +9,22 @@ #![no_std] #![feature(c_variadic)] -use core::ffi::{c_char, c_int, c_void}; +use core::ffi::{ + c_char, + c_int, + c_void, +}; mod arch; mod syscall_registers; pub use arch::*; pub use syscall_registers::{ - IteratorAsSyscallArgs, SyscallArg, SyscallArgs, SyscallWordArg, VaListAsSyscallArgs, + IteratorAsSyscallArgs, + SyscallArg, + SyscallArgs, + SyscallWordArg, + VaListAsSyscallArgs, }; pub type SyscallNumber = isize; diff --git a/crates/experimental/sel4-microkit/driver-adapters/src/block/message_types.rs b/crates/experimental/sel4-microkit/driver-adapters/src/block/message_types.rs index a2530d618..493a37bff 100644 --- a/crates/experimental/sel4-microkit/driver-adapters/src/block/message_types.rs +++ b/crates/experimental/sel4-microkit/driver-adapters/src/block/message_types.rs @@ -4,7 +4,10 @@ // SPDX-License-Identifier: BSD-2-Clause // -use serde::{Deserialize, Serialize}; +use serde::{ + Deserialize, + Serialize, +}; #[derive(Debug, Serialize, Deserialize)] pub(crate) enum Request { diff --git a/crates/experimental/sel4-microkit/driver-adapters/src/net/client.rs b/crates/experimental/sel4-microkit/driver-adapters/src/net/client.rs index 591e97e8d..51e008dcb 100644 --- a/crates/experimental/sel4-microkit/driver-adapters/src/net/client.rs +++ b/crates/experimental/sel4-microkit/driver-adapters/src/net/client.rs @@ -5,7 +5,10 @@ // SPDX-License-Identifier: BSD-2-Clause // -use sel4_driver_interfaces::net::{GetNetDeviceMeta, MacAddress}; +use sel4_driver_interfaces::net::{ + GetNetDeviceMeta, + MacAddress, +}; use sel4_microkit::Channel; use sel4_microkit_simple_ipc as simple_ipc; diff --git a/crates/experimental/sel4-microkit/driver-adapters/src/net/driver.rs b/crates/experimental/sel4-microkit/driver-adapters/src/net/driver.rs index 5e4d149b4..e24bddb46 100644 --- a/crates/experimental/sel4-microkit/driver-adapters/src/net/driver.rs +++ b/crates/experimental/sel4-microkit/driver-adapters/src/net/driver.rs @@ -8,16 +8,31 @@ //! A generic microkit handler for implementors of [`smoltcp::phy::Device`]. use smoltcp::{ - phy::{self, RxToken, TxToken}, + phy::{ + self, + RxToken, + TxToken, + }, time::Instant, }; -use sel4_driver_interfaces::HandleInterrupt; -use sel4_driver_interfaces::net::GetNetDeviceMeta; -use sel4_microkit::{Channel, ChannelSet, Handler, Infallible, MessageInfo}; +use sel4_driver_interfaces::{ + HandleInterrupt, + net::GetNetDeviceMeta, +}; +use sel4_microkit::{ + Channel, + ChannelSet, + Handler, + Infallible, + MessageInfo, +}; use sel4_microkit_simple_ipc as simple_ipc; use sel4_shared_memory::SharedMemoryRef; -use sel4_shared_ring_buffer::{RingBuffers, roles::Use}; +use sel4_shared_ring_buffer::{ + RingBuffers, + roles::Use, +}; use super::message_types::*; diff --git a/crates/experimental/sel4-microkit/driver-adapters/src/net/message_types.rs b/crates/experimental/sel4-microkit/driver-adapters/src/net/message_types.rs index 14a7f2833..0ec8a9851 100644 --- a/crates/experimental/sel4-microkit/driver-adapters/src/net/message_types.rs +++ b/crates/experimental/sel4-microkit/driver-adapters/src/net/message_types.rs @@ -5,7 +5,10 @@ // SPDX-License-Identifier: BSD-2-Clause // -use serde::{Deserialize, Serialize}; +use serde::{ + Deserialize, + Serialize, +}; use sel4_driver_interfaces::net::MacAddress; diff --git a/crates/experimental/sel4-microkit/driver-adapters/src/rtc/client.rs b/crates/experimental/sel4-microkit/driver-adapters/src/rtc/client.rs index ea27dce39..0b44b2854 100644 --- a/crates/experimental/sel4-microkit/driver-adapters/src/rtc/client.rs +++ b/crates/experimental/sel4-microkit/driver-adapters/src/rtc/client.rs @@ -4,7 +4,10 @@ // SPDX-License-Identifier: BSD-2-Clause // -use rtcc::{DateTimeAccess, NaiveDateTime}; +use rtcc::{ + DateTimeAccess, + NaiveDateTime, +}; use sel4_microkit::Channel; use sel4_microkit_simple_ipc as simple_ipc; diff --git a/crates/experimental/sel4-microkit/driver-adapters/src/rtc/driver.rs b/crates/experimental/sel4-microkit/driver-adapters/src/rtc/driver.rs index d48ee2280..9c1a99474 100644 --- a/crates/experimental/sel4-microkit/driver-adapters/src/rtc/driver.rs +++ b/crates/experimental/sel4-microkit/driver-adapters/src/rtc/driver.rs @@ -8,7 +8,11 @@ use core::convert::Infallible; use rtcc::DateTimeAccess; -use sel4_microkit::{Channel, Handler, MessageInfo}; +use sel4_microkit::{ + Channel, + Handler, + MessageInfo, +}; use sel4_microkit_simple_ipc as simple_ipc; use super::message_types::*; diff --git a/crates/experimental/sel4-microkit/driver-adapters/src/rtc/message_types.rs b/crates/experimental/sel4-microkit/driver-adapters/src/rtc/message_types.rs index 54ff539fa..7b03d253f 100644 --- a/crates/experimental/sel4-microkit/driver-adapters/src/rtc/message_types.rs +++ b/crates/experimental/sel4-microkit/driver-adapters/src/rtc/message_types.rs @@ -5,7 +5,10 @@ // use rtcc::NaiveDateTime; -use serde::{Deserialize, Serialize}; +use serde::{ + Deserialize, + Serialize, +}; #[derive(Debug, Serialize, Deserialize)] pub(crate) enum Request { diff --git a/crates/experimental/sel4-microkit/driver-adapters/src/serial/client.rs b/crates/experimental/sel4-microkit/driver-adapters/src/serial/client.rs index d4a83e3c9..f5d8b4ac8 100644 --- a/crates/experimental/sel4-microkit/driver-adapters/src/serial/client.rs +++ b/crates/experimental/sel4-microkit/driver-adapters/src/serial/client.rs @@ -5,8 +5,10 @@ // SPDX-License-Identifier: BSD-2-Clause // -use embedded_hal_nb::nb; -use embedded_hal_nb::serial; +use embedded_hal_nb::{ + nb, + serial, +}; use sel4_microkit::Channel; use sel4_microkit_simple_ipc as simple_ipc; diff --git a/crates/experimental/sel4-microkit/driver-adapters/src/serial/driver.rs b/crates/experimental/sel4-microkit/driver-adapters/src/serial/driver.rs index 01693592f..eaa18ee1e 100644 --- a/crates/experimental/sel4-microkit/driver-adapters/src/serial/driver.rs +++ b/crates/experimental/sel4-microkit/driver-adapters/src/serial/driver.rs @@ -7,12 +7,19 @@ use core::convert::Infallible; -use embedded_hal_nb::nb; -use embedded_hal_nb::serial; +use embedded_hal_nb::{ + nb, + serial, +}; use heapless::Deque; use sel4_driver_interfaces::HandleInterrupt; -use sel4_microkit::{Channel, ChannelSet, Handler, MessageInfo}; +use sel4_microkit::{ + Channel, + ChannelSet, + Handler, + MessageInfo, +}; use sel4_microkit_simple_ipc as simple_ipc; use super::message_types::*; diff --git a/crates/experimental/sel4-microkit/driver-adapters/src/serial/message_types.rs b/crates/experimental/sel4-microkit/driver-adapters/src/serial/message_types.rs index cd93f094d..90d47f405 100644 --- a/crates/experimental/sel4-microkit/driver-adapters/src/serial/message_types.rs +++ b/crates/experimental/sel4-microkit/driver-adapters/src/serial/message_types.rs @@ -6,7 +6,10 @@ // use embedded_hal_nb::nb; -use serde::{Deserialize, Serialize}; +use serde::{ + Deserialize, + Serialize, +}; #[derive(Debug, Serialize, Deserialize)] pub(crate) enum NonBlocking { diff --git a/crates/experimental/sel4-microkit/driver-adapters/src/timer/client.rs b/crates/experimental/sel4-microkit/driver-adapters/src/timer/client.rs index f52b56ee1..9b997c75f 100644 --- a/crates/experimental/sel4-microkit/driver-adapters/src/timer/client.rs +++ b/crates/experimental/sel4-microkit/driver-adapters/src/timer/client.rs @@ -6,7 +6,12 @@ use core::time::Duration; -use sel4_driver_interfaces::timer::{Clock, ErrorType, NumTimers, Timers}; +use sel4_driver_interfaces::timer::{ + Clock, + ErrorType, + NumTimers, + Timers, +}; use sel4_microkit::Channel; use sel4_microkit_simple_ipc as simple_ipc; diff --git a/crates/experimental/sel4-microkit/driver-adapters/src/timer/driver.rs b/crates/experimental/sel4-microkit/driver-adapters/src/timer/driver.rs index 77f3731b8..ef55a61b5 100644 --- a/crates/experimental/sel4-microkit/driver-adapters/src/timer/driver.rs +++ b/crates/experimental/sel4-microkit/driver-adapters/src/timer/driver.rs @@ -6,9 +6,19 @@ use core::convert::Infallible; -use sel4_driver_interfaces::HandleInterrupt; -use sel4_driver_interfaces::timer::{NumTimers, Timers}; -use sel4_microkit::{Channel, ChannelSet, Handler, MessageInfo}; +use sel4_driver_interfaces::{ + HandleInterrupt, + timer::{ + NumTimers, + Timers, + }, +}; +use sel4_microkit::{ + Channel, + ChannelSet, + Handler, + MessageInfo, +}; use sel4_microkit_simple_ipc as simple_ipc; use super::message_types::*; diff --git a/crates/experimental/sel4-microkit/driver-adapters/src/timer/message_types.rs b/crates/experimental/sel4-microkit/driver-adapters/src/timer/message_types.rs index 7323143f5..1b6bcbdfa 100644 --- a/crates/experimental/sel4-microkit/driver-adapters/src/timer/message_types.rs +++ b/crates/experimental/sel4-microkit/driver-adapters/src/timer/message_types.rs @@ -5,7 +5,10 @@ // use core::time::Duration; -use serde::{Deserialize, Serialize}; +use serde::{ + Deserialize, + Serialize, +}; #[derive(Debug, Serialize, Deserialize)] pub(crate) enum Request { diff --git a/crates/experimental/sel4-microkit/simple-ipc/src/lib.rs b/crates/experimental/sel4-microkit/simple-ipc/src/lib.rs index a0a150189..633ada4c7 100644 --- a/crates/experimental/sel4-microkit/simple-ipc/src/lib.rs +++ b/crates/experimental/sel4-microkit/simple-ipc/src/lib.rs @@ -6,14 +6,24 @@ #![no_std] -use core::error::Error; -use core::fmt; +use core::{ + error::Error, + fmt, +}; -use serde::{Deserialize, Serialize}; +use serde::{ + Deserialize, + Serialize, +}; use zerocopy::IntoBytes; use sel4_microkit_base::{ - Channel, MessageInfo, MessageLabel, MessageRegisterValue, with_msg_regs, with_msg_regs_mut, + Channel, + MessageInfo, + MessageLabel, + MessageRegisterValue, + with_msg_regs, + with_msg_regs_mut, }; const MAX_MESSAGE_LABEL: MessageLabel = diff --git a/crates/experimental/sel4-musl/src/lib.rs b/crates/experimental/sel4-musl/src/lib.rs index c69b60c91..eb33a2036 100644 --- a/crates/experimental/sel4-musl/src/lib.rs +++ b/crates/experimental/sel4-musl/src/lib.rs @@ -7,12 +7,18 @@ #![no_std] #![feature(c_variadic)] -use core::ffi::{CStr, c_char}; +use core::ffi::{ + CStr, + c_char, +}; use sel4_immediate_sync_once_cell::ImmediateSyncOnceCell; pub use sel4_linux_syscall_types::{ - ParseSyscallError, Syscall, SyscallReturnValue, VaListAsSyscallArgs, + ParseSyscallError, + Syscall, + SyscallReturnValue, + VaListAsSyscallArgs, }; // TODO: support the `struct __libc __libc;` state? diff --git a/crates/experimental/sel4-newlib/build.rs b/crates/experimental/sel4-newlib/build.rs index c8b3b7aa8..c2b345e4c 100644 --- a/crates/experimental/sel4-newlib/build.rs +++ b/crates/experimental/sel4-newlib/build.rs @@ -5,7 +5,11 @@ // #[cfg(feature = "detect-libc")] -use std::{path::Path, process::Stdio, str}; +use std::{ + path::Path, + process::Stdio, + str, +}; fn main() { if cfg!(feature = "link-libc") { diff --git a/crates/experimental/sel4-newlib/src/heap.rs b/crates/experimental/sel4-newlib/src/heap.rs index b02e782e2..2fa48e091 100644 --- a/crates/experimental/sel4-newlib/src/heap.rs +++ b/crates/experimental/sel4-newlib/src/heap.rs @@ -4,9 +4,17 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::cell::UnsafeCell; -use core::ffi::{c_int, c_void}; -use core::sync::atomic::{AtomicIsize, Ordering}; +use core::{ + cell::UnsafeCell, + ffi::{ + c_int, + c_void, + }, + sync::atomic::{ + AtomicIsize, + Ordering, + }, +}; use sel4_panicking_env::abort; diff --git a/crates/experimental/sel4-newlib/src/lib.rs b/crates/experimental/sel4-newlib/src/lib.rs index 077e2d28d..6273f72b3 100644 --- a/crates/experimental/sel4-newlib/src/lib.rs +++ b/crates/experimental/sel4-newlib/src/lib.rs @@ -9,7 +9,11 @@ #![no_std] #[allow(unused_imports)] -use core::ffi::{c_char, c_int, c_uint}; +use core::ffi::{ + c_char, + c_int, + c_uint, +}; mod errno; mod heap; diff --git a/crates/experimental/sel4-shared-ring-buffer/block-io/src/lib.rs b/crates/experimental/sel4-shared-ring-buffer/block-io/src/lib.rs index 2fcd85239..611c1e2e6 100644 --- a/crates/experimental/sel4-shared-ring-buffer/block-io/src/lib.rs +++ b/crates/experimental/sel4-shared-ring-buffer/block-io/src/lib.rs @@ -10,25 +10,49 @@ extern crate alloc; use alloc::rc::Rc; -use core::cell::RefCell; -use core::future::Future; -use core::marker::PhantomData; -use core::pin::Pin; -use core::task::{Context, Poll}; +use core::{ + cell::RefCell, + future::Future, + marker::PhantomData, + pin::Pin, + task::{ + Context, + Poll, + }, +}; use async_unsync::semaphore::Semaphore; use sel4_abstract_allocator::AbstractAllocator; -use sel4_async_block_io::{BlockIO, BlockIOLayout, BlockSize, Operation, access::Access}; +use sel4_async_block_io::{ + BlockIO, + BlockIOLayout, + BlockSize, + Operation, + access::Access, +}; use sel4_shared_memory::SharedMemoryRef; -use sel4_shared_ring_buffer::{RingBuffers, roles::Provide}; +use sel4_shared_ring_buffer::{ + RingBuffers, + roles::Provide, +}; use sel4_shared_ring_buffer_block_io_types::BlockIORequest; mod errors; mod owned; -pub use errors::{Error, ErrorOrUserError, IOError, PeerMisbehaviorError, UserError}; -pub use owned::{IssueRequestBuf, OwnedSharedRingBufferBlockIO, PollRequestBuf}; +pub use errors::{ + Error, + ErrorOrUserError, + IOError, + PeerMisbehaviorError, + UserError, +}; +pub use owned::{ + IssueRequestBuf, + OwnedSharedRingBufferBlockIO, + PollRequestBuf, +}; pub struct SharedRingBufferBlockIO { shared: Rc>>, diff --git a/crates/experimental/sel4-shared-ring-buffer/block-io/src/owned.rs b/crates/experimental/sel4-shared-ring-buffer/block-io/src/owned.rs index 799d108e4..b4a7fee66 100644 --- a/crates/experimental/sel4-shared-ring-buffer/block-io/src/owned.rs +++ b/crates/experimental/sel4-shared-ring-buffer/block-io/src/owned.rs @@ -4,23 +4,47 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::alloc::Layout; -use core::marker::PhantomData; -use core::task::{Poll, Waker}; +use core::{ + alloc::Layout, + marker::PhantomData, + task::{ + Poll, + Waker, + }, +}; -use sel4_abstract_allocator::{AbstractAllocator, AbstractAllocatorAllocation}; -use sel4_async_block_io::{Operation, access::Access}; +use sel4_abstract_allocator::{ + AbstractAllocator, + AbstractAllocatorAllocation, +}; +use sel4_async_block_io::{ + Operation, + access::Access, +}; use sel4_shared_memory::SharedMemoryRef; use sel4_shared_ring_buffer::{ - Descriptor, PeerMisbehaviorError as SharedRingBuffersPeerMisbehaviorError, RingBuffers, + Descriptor, + PeerMisbehaviorError as SharedRingBuffersPeerMisbehaviorError, + RingBuffers, roles::Provide, }; use sel4_shared_ring_buffer_block_io_types::{ - BlockIORequest, BlockIORequestStatus, BlockIORequestType, + BlockIORequest, + BlockIORequestStatus, + BlockIORequestType, +}; +use sel4_shared_ring_buffer_bookkeeping::{ + slot_set_semaphore::*, + slot_tracker::*, }; -use sel4_shared_ring_buffer_bookkeeping::{slot_set_semaphore::*, slot_tracker::*}; -pub use crate::errors::{Error, ErrorOrUserError, IOError, PeerMisbehaviorError, UserError}; +pub use crate::errors::{ + Error, + ErrorOrUserError, + IOError, + PeerMisbehaviorError, + UserError, +}; pub struct OwnedSharedRingBufferBlockIO { dma_region: SharedMemoryRef<'static, [u8]>, diff --git a/crates/experimental/sel4-shared-ring-buffer/block-io/types/src/lib.rs b/crates/experimental/sel4-shared-ring-buffer/block-io/types/src/lib.rs index 654f83d56..983ce0b01 100644 --- a/crates/experimental/sel4-shared-ring-buffer/block-io/types/src/lib.rs +++ b/crates/experimental/sel4-shared-ring-buffer/block-io/types/src/lib.rs @@ -6,8 +6,16 @@ #![no_std] -use num_enum::{IntoPrimitive, TryFromPrimitive, TryFromPrimitiveError}; -use zerocopy::{FromBytes, Immutable, IntoBytes}; +use num_enum::{ + IntoPrimitive, + TryFromPrimitive, + TryFromPrimitiveError, +}; +use zerocopy::{ + FromBytes, + Immutable, + IntoBytes, +}; use sel4_shared_ring_buffer::Descriptor; diff --git a/crates/experimental/sel4-shared-ring-buffer/bookkeeping/src/slot_set_semaphore.rs b/crates/experimental/sel4-shared-ring-buffer/bookkeeping/src/slot_set_semaphore.rs index 039054e32..2e5372e65 100644 --- a/crates/experimental/sel4-shared-ring-buffer/bookkeeping/src/slot_set_semaphore.rs +++ b/crates/experimental/sel4-shared-ring-buffer/bookkeeping/src/slot_set_semaphore.rs @@ -5,12 +5,17 @@ // use alloc::rc::Rc; -use core::array; -use core::cell::Cell; -use core::future::Future; -use core::mem; - -use crate::slot_count_tracker::{SlotCountTracker, SlotCountTrackerError}; +use core::{ + array, + cell::Cell, + future::Future, + mem, +}; + +use crate::slot_count_tracker::{ + SlotCountTracker, + SlotCountTrackerError, +}; pub trait SlotSemaphore { fn new(count: usize) -> Self; @@ -259,7 +264,10 @@ impl SlotSemaphore for Rc { #[cfg(feature = "async-unsync")] mod async_unsync_impl { - use async_unsync::semaphore::{Semaphore, TryAcquireError}; + use async_unsync::semaphore::{ + Semaphore, + TryAcquireError, + }; use super::*; diff --git a/crates/experimental/sel4-shared-ring-buffer/bookkeeping/src/slot_tracker.rs b/crates/experimental/sel4-shared-ring-buffer/bookkeeping/src/slot_tracker.rs index 215053f85..d9fbce483 100644 --- a/crates/experimental/sel4-shared-ring-buffer/bookkeeping/src/slot_tracker.rs +++ b/crates/experimental/sel4-shared-ring-buffer/bookkeeping/src/slot_tracker.rs @@ -7,8 +7,10 @@ extern crate alloc; use alloc::vec::Vec; -use core::iter; -use core::mem; +use core::{ + iter, + mem, +}; type Result = core::result::Result; diff --git a/crates/experimental/sel4-shared-ring-buffer/smoltcp/src/inner.rs b/crates/experimental/sel4-shared-ring-buffer/smoltcp/src/inner.rs index d32340415..5a5f038b2 100644 --- a/crates/experimental/sel4-shared-ring-buffer/smoltcp/src/inner.rs +++ b/crates/experimental/sel4-shared-ring-buffer/smoltcp/src/inner.rs @@ -4,16 +4,23 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::alloc::Layout; -use core::marker::PhantomData; -use core::ptr::NonNull; +use core::{ + alloc::Layout, + marker::PhantomData, + ptr::NonNull, +}; use smoltcp::phy::DeviceCapabilities; -use sel4_abstract_allocator::{AbstractAllocator, AbstractAllocatorAllocation}; +use sel4_abstract_allocator::{ + AbstractAllocator, + AbstractAllocatorAllocation, +}; use sel4_shared_memory::SharedMemoryRef; use sel4_shared_ring_buffer::{ - Descriptor, PeerMisbehaviorError as SharedRingBuffersPeerMisbehaviorError, RingBuffers, + Descriptor, + PeerMisbehaviorError as SharedRingBuffersPeerMisbehaviorError, + RingBuffers, roles::Provide, }; use sel4_shared_ring_buffer_bookkeeping::slot_tracker::*; diff --git a/crates/experimental/sel4-shared-ring-buffer/smoltcp/src/lib.rs b/crates/experimental/sel4-shared-ring-buffer/smoltcp/src/lib.rs index 267394bfc..dec0c0fd6 100644 --- a/crates/experimental/sel4-shared-ring-buffer/smoltcp/src/lib.rs +++ b/crates/experimental/sel4-shared-ring-buffer/smoltcp/src/lib.rs @@ -8,20 +8,42 @@ extern crate alloc; -use lock_api::{Mutex, RawMutex}; +use lock_api::{ + Mutex, + RawMutex, +}; use one_shot_mutex::unsync::RawOneShotMutex; -use smoltcp::phy::{self, Device, DeviceCapabilities}; -use smoltcp::time::Instant; +use smoltcp::{ + phy::{ + self, + Device, + DeviceCapabilities, + }, + time::Instant, +}; use sel4_abstract_allocator::AbstractAllocator; -use sel4_abstract_rc::{AbstractRcT, RcT}; +use sel4_abstract_rc::{ + AbstractRcT, + RcT, +}; use sel4_shared_memory::SharedMemoryRef; -use sel4_shared_ring_buffer::{RingBuffers, roles::Provide}; +use sel4_shared_ring_buffer::{ + RingBuffers, + roles::Provide, +}; mod inner; -pub use inner::{Error, PeerMisbehaviorError}; -use inner::{Inner, RxBufferIndex, TxBufferIndex}; +pub use inner::{ + Error, + PeerMisbehaviorError, +}; +use inner::{ + Inner, + RxBufferIndex, + TxBufferIndex, +}; pub struct DeviceImpl { inner: P::Rc>>, diff --git a/crates/experimental/sel4-shared-ring-buffer/src/descriptor.rs b/crates/experimental/sel4-shared-ring-buffer/src/descriptor.rs index eccad42e3..a06fdefce 100644 --- a/crates/experimental/sel4-shared-ring-buffer/src/descriptor.rs +++ b/crates/experimental/sel4-shared-ring-buffer/src/descriptor.rs @@ -6,7 +6,11 @@ use core::ops::Range; -use zerocopy::{FromBytes, Immutable, IntoBytes}; +use zerocopy::{ + FromBytes, + Immutable, + IntoBytes, +}; #[repr(C)] #[derive(Copy, Clone, Debug, PartialOrd, Ord, PartialEq, Eq, FromBytes, IntoBytes, Immutable)] diff --git a/crates/experimental/sel4-shared-ring-buffer/src/lib.rs b/crates/experimental/sel4-shared-ring-buffer/src/lib.rs index 0deb806a1..f5bd8f404 100644 --- a/crates/experimental/sel4-shared-ring-buffer/src/lib.rs +++ b/crates/experimental/sel4-shared-ring-buffer/src/lib.rs @@ -6,17 +6,35 @@ #![no_std] -use core::marker::PhantomData; -use core::num::Wrapping; -use core::sync::atomic::{AtomicU32, Ordering}; - -use zerocopy::{FromBytes, IntoBytes}; - -use sel4_shared_memory::{SharedMemoryPtr, SharedMemoryRef, map_field}; +use core::{ + marker::PhantomData, + num::Wrapping, + sync::atomic::{ + AtomicU32, + Ordering, + }, +}; + +use zerocopy::{ + FromBytes, + IntoBytes, +}; + +use sel4_shared_memory::{ + SharedMemoryPtr, + SharedMemoryRef, + map_field, +}; pub mod roles; -use roles::{Read, RingBufferRole, RingBufferRoleValue, RingBuffersRole, Write}; +use roles::{ + Read, + RingBufferRole, + RingBufferRoleValue, + RingBuffersRole, + Write, +}; mod descriptor; diff --git a/crates/experimental/sel4-shared-ring-buffer/src/roles.rs b/crates/experimental/sel4-shared-ring-buffer/src/roles.rs index c888a4aed..74aa16475 100644 --- a/crates/experimental/sel4-shared-ring-buffer/src/roles.rs +++ b/crates/experimental/sel4-shared-ring-buffer/src/roles.rs @@ -87,7 +87,10 @@ impl RingBufferRoleValue { } } -use sealing::{RingBufferRoleSealed, RingBuffersRoleSealed}; +use sealing::{ + RingBufferRoleSealed, + RingBuffersRoleSealed, +}; mod sealing { use super::*; diff --git a/crates/private/support/sel4-minimal-linux-runtime/src/lib.rs b/crates/private/support/sel4-minimal-linux-runtime/src/lib.rs index 6d2bf7c96..314a6bc3e 100644 --- a/crates/private/support/sel4-minimal-linux-runtime/src/lib.rs +++ b/crates/private/support/sel4-minimal-linux-runtime/src/lib.rs @@ -8,9 +8,15 @@ use core::panic::UnwindSafe; -pub use sel4_minimal_linux_syscalls::{exit_failure, exit_success}; +pub use sel4_minimal_linux_syscalls::{ + exit_failure, + exit_success, +}; pub use sel4_panicking::catch_unwind; -pub use sel4_panicking_env::{abort, debug_println}; +pub use sel4_panicking_env::{ + abort, + debug_println, +}; pub use sel4_minimal_linux_runtime_macros::main; @@ -100,8 +106,15 @@ where // For macros #[doc(hidden)] pub mod _private { - pub use crate::{_run_main, DEFAULT_STACK_SIZE, declare_main}; + pub use crate::{ + _run_main, + DEFAULT_STACK_SIZE, + declare_main, + }; pub use one_shot_mutex::sync::RawOneShotMutex; - pub use sel4_dlmalloc::{StaticDlmalloc, StaticHeap}; + pub use sel4_dlmalloc::{ + StaticDlmalloc, + StaticHeap, + }; pub use sel4_runtime_common::declare_stack; } diff --git a/crates/private/support/sel4-minimal-linux-syscalls/src/lib.rs b/crates/private/support/sel4-minimal-linux-syscalls/src/lib.rs index 9a6cb6bef..44fb98aa4 100644 --- a/crates/private/support/sel4-minimal-linux-syscalls/src/lib.rs +++ b/crates/private/support/sel4-minimal-linux-syscalls/src/lib.rs @@ -6,9 +6,16 @@ #![no_std] -use sel4_panicking_env::{abort, register_abort_trap, register_debug_put_char}; - -use syscalls::{Sysno, syscall}; +use sel4_panicking_env::{ + abort, + register_abort_trap, + register_debug_put_char, +}; + +use syscalls::{ + Sysno, + syscall, +}; register_debug_put_char!(debug_put_char); diff --git a/crates/private/support/sel4-root-task-with-std/src/entry.rs b/crates/private/support/sel4-root-task-with-std/src/entry.rs index 4535a81d7..2e439209a 100644 --- a/crates/private/support/sel4-root-task-with-std/src/entry.rs +++ b/crates/private/support/sel4-root-task-with-std/src/entry.rs @@ -4,9 +4,15 @@ // SPDX-License-Identifier: BSD-2-Clause // -use std::panic::{UnwindSafe, catch_unwind}; +use std::panic::{ + UnwindSafe, + catch_unwind, +}; -use crate::{Termination, abort}; +use crate::{ + Termination, + abort, +}; sel4_runtime_common::declare_entrypoint_with_stack_init!(); diff --git a/crates/private/support/sel4-root-task-with-std/src/lib.rs b/crates/private/support/sel4-root-task-with-std/src/lib.rs index f9f08e223..2d89d875f 100644 --- a/crates/private/support/sel4-root-task-with-std/src/lib.rs +++ b/crates/private/support/sel4-root-task-with-std/src/lib.rs @@ -9,12 +9,19 @@ use sel4::sel4_cfg_if; -pub use sel4_panicking_env::{abort, debug_print, debug_println}; +pub use sel4_panicking_env::{ + abort, + debug_print, + debug_println, +}; mod entry; mod termination; -pub use termination::{Never, Termination}; +pub use termination::{ + Never, + Termination, +}; #[doc(hidden)] #[macro_export] @@ -62,5 +69,10 @@ pub mod _private { pub use sel4::BootInfoPtr; pub use sel4_runtime_common::declare_stack; - pub use crate::{DEFAULT_STACK_SIZE, declare_main, declare_root_task, entry::run_main}; + pub use crate::{ + DEFAULT_STACK_SIZE, + declare_main, + declare_root_task, + entry::run_main, + }; } diff --git a/crates/private/support/sel4-simple-task/application-config-types/src/lib.rs b/crates/private/support/sel4-simple-task/application-config-types/src/lib.rs index bc9191120..49ad2e296 100644 --- a/crates/private/support/sel4-simple-task/application-config-types/src/lib.rs +++ b/crates/private/support/sel4-simple-task/application-config-types/src/lib.rs @@ -9,7 +9,10 @@ use core::marker::PhantomData; use sel4_simple_task_threading::StaticThread; -use serde::{Deserialize, Serialize}; +use serde::{ + Deserialize, + Serialize, +}; #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)] #[serde(transparent)] diff --git a/crates/private/support/sel4-simple-task/rpc/src/lib.rs b/crates/private/support/sel4-simple-task/rpc/src/lib.rs index a15220372..e6a8b06d7 100644 --- a/crates/private/support/sel4-simple-task/rpc/src/lib.rs +++ b/crates/private/support/sel4-simple-task/rpc/src/lib.rs @@ -6,13 +6,25 @@ #![no_std] -use core::fmt; -use core::marker::PhantomData; -use core::mem; - -use serde::{Deserialize, Serialize}; - -use sel4::{Badge, IpcBuffer, MessageInfo, MessageInfoBuilder, Word, cap::Endpoint}; +use core::{ + fmt, + marker::PhantomData, + mem, +}; + +use serde::{ + Deserialize, + Serialize, +}; + +use sel4::{ + Badge, + IpcBuffer, + MessageInfo, + MessageInfoBuilder, + Word, + cap::Endpoint, +}; const BYTES_PER_WORD: usize = mem::size_of::() / mem::size_of::(); diff --git a/crates/private/support/sel4-simple-task/runtime/config/cli/src/bin/sel4-simple-task-serialize-runtime-config.rs b/crates/private/support/sel4-simple-task/runtime/config/cli/src/bin/sel4-simple-task-serialize-runtime-config.rs index 3ab59d1fc..4a3ef8cf1 100644 --- a/crates/private/support/sel4-simple-task/runtime/config/cli/src/bin/sel4-simple-task-serialize-runtime-config.rs +++ b/crates/private/support/sel4-simple-task/runtime/config/cli/src/bin/sel4-simple-task-serialize-runtime-config.rs @@ -4,9 +4,14 @@ // SPDX-License-Identifier: BSD-2-Clause // -use std::fs; -use std::io::{self, Write}; -use std::path::PathBuf; +use std::{ + fs, + io::{ + self, + Write, + }, + path::PathBuf, +}; use sel4_simple_task_runtime_config_types::GenericRuntimeConfig; diff --git a/crates/private/support/sel4-simple-task/runtime/config/types/src/lib.rs b/crates/private/support/sel4-simple-task/runtime/config/types/src/lib.rs index e246d4871..b7fff90a6 100644 --- a/crates/private/support/sel4-simple-task/runtime/config/types/src/lib.rs +++ b/crates/private/support/sel4-simple-task/runtime/config/types/src/lib.rs @@ -10,15 +10,22 @@ extern crate alloc; use core::ops::Range; -use alloc::string::String; -use alloc::vec::Vec; +use alloc::{ + string::String, + vec::Vec, +}; -use rkyv::Archive; -use rkyv::rancor; -use rkyv::util::AlignedVec; +use rkyv::{ + Archive, + rancor, + util::AlignedVec, +}; #[cfg(feature = "serde")] -use serde::{Deserialize, Serialize}; +use serde::{ + Deserialize, + Serialize, +}; #[cfg(target_pointer_width = "32")] type NativeWord = u32; diff --git a/crates/private/support/sel4-simple-task/runtime/macros/src/lib.rs b/crates/private/support/sel4-simple-task/runtime/macros/src/lib.rs index 70568dd48..eb94e9a34 100644 --- a/crates/private/support/sel4-simple-task/runtime/macros/src/lib.rs +++ b/crates/private/support/sel4-simple-task/runtime/macros/src/lib.rs @@ -9,7 +9,10 @@ extern crate proc_macro; use proc_macro::TokenStream; use proc_macro2::TokenStream as TokenStream2; use quote::quote; -use syn::{ItemFn, parse_macro_input}; +use syn::{ + ItemFn, + parse_macro_input, +}; #[proc_macro_attribute] pub fn main(_attr: TokenStream, item: TokenStream) -> TokenStream { diff --git a/crates/private/support/sel4-simple-task/runtime/src/declare_main.rs b/crates/private/support/sel4-simple-task/runtime/src/declare_main.rs index 55d90206c..426bd6905 100644 --- a/crates/private/support/sel4-simple-task/runtime/src/declare_main.rs +++ b/crates/private/support/sel4-simple-task/runtime/src/declare_main.rs @@ -4,8 +4,10 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::fmt; -use core::panic::UnwindSafe; +use core::{ + fmt, + panic::UnwindSafe, +}; use serde::Deserialize; @@ -65,9 +67,11 @@ macro_rules! declare_main_with { } pub mod _private { - pub use super::run_main; - pub use super::run_main_postcard; - pub use super::wrap; + pub use super::{ + run_main, + run_main_postcard, + wrap, + }; #[cfg(feature = "serde_json")] pub use super::run_main_json; diff --git a/crates/private/support/sel4-simple-task/runtime/src/global_allocator.rs b/crates/private/support/sel4-simple-task/runtime/src/global_allocator.rs index 41e220570..bf5fd07c3 100644 --- a/crates/private/support/sel4-simple-task/runtime/src/global_allocator.rs +++ b/crates/private/support/sel4-simple-task/runtime/src/global_allocator.rs @@ -4,7 +4,10 @@ // SPDX-License-Identifier: BSD-2-Clause // -use sel4_dlmalloc::{DeferredStaticDlmalloc, StaticHeapBounds}; +use sel4_dlmalloc::{ + DeferredStaticDlmalloc, + StaticHeapBounds, +}; use sel4_sync::RawDeferredNotificationMutex; #[global_allocator] diff --git a/crates/private/support/sel4-simple-task/runtime/src/lib.rs b/crates/private/support/sel4-simple-task/runtime/src/lib.rs index 4ec0062f4..acfae973d 100644 --- a/crates/private/support/sel4-simple-task/runtime/src/lib.rs +++ b/crates/private/support/sel4-simple-task/runtime/src/lib.rs @@ -13,15 +13,23 @@ #[cfg(feature = "alloc")] extern crate alloc; -use core::panic::PanicInfo; -use core::slice; +use core::{ + panic::PanicInfo, + slice, +}; use rkyv::Archive; use sel4_dlmalloc::StaticHeapBounds; use sel4_immediate_sync_once_cell::ImmediateSyncOnceCell; -use sel4_panicking_env::{AbortInfo, abort}; -use sel4_simple_task_runtime_config_types::{RuntimeConfig, RuntimeThreadConfig}; +use sel4_panicking_env::{ + AbortInfo, + abort, +}; +use sel4_simple_task_runtime_config_types::{ + RuntimeConfig, + RuntimeThreadConfig, +}; use sel4_simple_task_threading::StaticThread; #[cfg(not(target_arch = "arm"))] @@ -33,8 +41,15 @@ mod termination; #[cfg(feature = "alloc")] mod global_allocator; -pub use sel4_panicking_env::{debug_print, debug_println}; -pub use sel4_simple_task_runtime_macros::{main, main_json, main_postcard}; +pub use sel4_panicking_env::{ + debug_print, + debug_println, +}; +pub use sel4_simple_task_runtime_macros::{ + main, + main_json, + main_postcard, +}; unsafe extern "Rust" { pub(crate) fn __sel4_simple_task_main(arg: &[u8]); diff --git a/crates/private/support/sel4-test-harness/src/for_generated_code/mod.rs b/crates/private/support/sel4-test-harness/src/for_generated_code/mod.rs index f5f3f25ae..d47109089 100644 --- a/crates/private/support/sel4-test-harness/src/for_generated_code/mod.rs +++ b/crates/private/support/sel4-test-harness/src/for_generated_code/mod.rs @@ -4,11 +4,16 @@ // SPDX-License-Identifier: MIT OR Apache-2.0 // -use alloc::format; -use alloc::string::String; +use alloc::{ + format, + string::String, +}; use core::fmt; -use crate::{config::get_config, run_tests::run_tests_with_config}; +use crate::{ + config::get_config, + run_tests::run_tests_with_config, +}; pub(crate) mod types; diff --git a/crates/private/support/sel4-test-harness/src/for_generated_code/types.rs b/crates/private/support/sel4-test-harness/src/for_generated_code/types.rs index 5b26db7a6..4df7a9971 100644 --- a/crates/private/support/sel4-test-harness/src/for_generated_code/types.rs +++ b/crates/private/support/sel4-test-harness/src/for_generated_code/types.rs @@ -5,9 +5,11 @@ // SPDX-License-Identifier: MIT OR Apache-2.0 // -use alloc::borrow::Cow; -use alloc::fmt; -use alloc::string::String; +use alloc::{ + borrow::Cow, + fmt, + string::String, +}; use crate::short_backtrace::__rust_begin_short_backtrace; diff --git a/crates/private/support/sel4-test-harness/src/lib.rs b/crates/private/support/sel4-test-harness/src/lib.rs index a2b9c012a..b0fa109b9 100644 --- a/crates/private/support/sel4-test-harness/src/lib.rs +++ b/crates/private/support/sel4-test-harness/src/lib.rs @@ -18,7 +18,8 @@ mod short_backtrace; pub mod for_generated_code; -pub use { - config::{set_config, types::*}, - entry::run_test_main, +pub use config::{ + set_config, + types::*, }; +pub use entry::run_test_main; diff --git a/crates/private/support/sel4-test-harness/src/run_tests.rs b/crates/private/support/sel4-test-harness/src/run_tests.rs index 575087a4b..91e9b8e8f 100644 --- a/crates/private/support/sel4-test-harness/src/run_tests.rs +++ b/crates/private/support/sel4-test-harness/src/run_tests.rs @@ -5,16 +5,29 @@ // use alloc::string::String; -use core::fmt; -use core::panic::AssertUnwindSafe; +use core::{ + fmt, + panic::AssertUnwindSafe, +}; use sel4_panicking::catch_unwind; -use sel4_panicking_env::{debug_print, debug_println}; -use sel4_test_sentinels::{indicate_failure, indicate_success}; +use sel4_panicking_env::{ + debug_print, + debug_println, +}; +use sel4_test_sentinels::{ + indicate_failure, + indicate_success, +}; use crate::{ config::types::*, - for_generated_code::{Runnable, ShouldPanic, TestDescAndFn, TestFn}, + for_generated_code::{ + Runnable, + ShouldPanic, + TestDescAndFn, + TestFn, + }, }; pub fn run_tests_with_config(config: &Config, tests: &[&TestDescAndFn]) { diff --git a/crates/private/support/sel4-test-microkit/src/with_alloc.rs b/crates/private/support/sel4-test-microkit/src/with_alloc.rs index 6da83977f..7a61655bd 100644 --- a/crates/private/support/sel4-test-microkit/src/with_alloc.rs +++ b/crates/private/support/sel4-test-microkit/src/with_alloc.rs @@ -7,7 +7,15 @@ use alloc::boxed::Box; use core::error::Error; -use sel4_microkit::{Channel, ChannelSet, Child, DeferredAction, Handler, MessageInfo, Never}; +use sel4_microkit::{ + Channel, + ChannelSet, + Child, + DeferredAction, + Handler, + MessageInfo, + Never, +}; pub type UpcastedHandler = Box> + 'static>; diff --git a/crates/private/support/sel4-test-runner/src/main.rs b/crates/private/support/sel4-test-runner/src/main.rs index b39ad2d8f..7d49995fa 100644 --- a/crates/private/support/sel4-test-runner/src/main.rs +++ b/crates/private/support/sel4-test-runner/src/main.rs @@ -4,14 +4,30 @@ // SPDX-License-Identifier: BSD-2-Clause // -use std::os::unix; -use std::path::{Path, PathBuf}; -use std::process::Command; -use std::{env, fs, iter}; - -use anyhow::{Error, ensure}; +use std::{ + env, + fs, + iter, + os::unix, + path::{ + Path, + PathBuf, + }, + process::Command, +}; + +use anyhow::{ + Error, + ensure, +}; use clap::Parser; -use object::{Architecture, File, Object, ObjectSection as _, ObjectSymbol}; +use object::{ + Architecture, + File, + Object, + ObjectSection as _, + ObjectSymbol, +}; use tempfile::TempDir; #[derive(Parser, Debug)] diff --git a/crates/private/support/sel4-test-sentinels/src/lib.rs b/crates/private/support/sel4-test-sentinels/src/lib.rs index 66c50e71b..8e241e789 100644 --- a/crates/private/support/sel4-test-sentinels/src/lib.rs +++ b/crates/private/support/sel4-test-sentinels/src/lib.rs @@ -8,7 +8,10 @@ #![feature(core_intrinsics)] #![allow(internal_features)] -use sel4_panicking_env::{debug_println, register_abort_trap}; +use sel4_panicking_env::{ + debug_println, + register_abort_trap, +}; pub fn indicate_success() -> ! { debug_println!("INDICATE_SUCCESS\x06"); diff --git a/crates/private/support/sel4-test-sentinels/wrapper/src/lib.rs b/crates/private/support/sel4-test-sentinels/wrapper/src/lib.rs index e4caf8c4c..f35f249f3 100644 --- a/crates/private/support/sel4-test-sentinels/wrapper/src/lib.rs +++ b/crates/private/support/sel4-test-sentinels/wrapper/src/lib.rs @@ -4,11 +4,23 @@ // SPDX-License-Identifier: BSD-2-Clause // -use std::io; -use std::io::{Read, Write}; -use std::process::{Command, ExitStatus, Stdio}; - -use anyhow::{Error, bail}; +use std::{ + io, + io::{ + Read, + Write, + }, + process::{ + Command, + ExitStatus, + Stdio, + }, +}; + +use anyhow::{ + Error, + bail, +}; pub struct Sentinels { pub sequences: Vec>, diff --git a/crates/private/support/sel4-test-sentinels/wrapper/src/main.rs b/crates/private/support/sel4-test-sentinels/wrapper/src/main.rs index 5291d01b1..9b8c466b9 100644 --- a/crates/private/support/sel4-test-sentinels/wrapper/src/main.rs +++ b/crates/private/support/sel4-test-sentinels/wrapper/src/main.rs @@ -4,8 +4,10 @@ // SPDX-License-Identifier: BSD-2-Clause // -use std::env; -use std::process::Command; +use std::{ + env, + process::Command, +}; use anyhow::Error; diff --git a/crates/private/tests/capdl/threads/src/main.rs b/crates/private/tests/capdl/threads/src/main.rs index b11f3ba27..e266e966e 100644 --- a/crates/private/tests/capdl/threads/src/main.rs +++ b/crates/private/tests/capdl/threads/src/main.rs @@ -9,15 +9,26 @@ extern crate alloc; -use alloc::sync::Arc; -use alloc::vec::Vec; +use alloc::{ + sync::Arc, + vec::Vec, +}; -use serde::{Deserialize, Serialize}; +use serde::{ + Deserialize, + Serialize, +}; use sel4_simple_task_application_config_types::*; -use sel4_simple_task_runtime::{debug_println, main_json}; +use sel4_simple_task_runtime::{ + debug_println, + main_json, +}; use sel4_simple_task_threading::StaticThread; -use sel4_sync::{RawNotificationMutex, lock_api::Mutex}; +use sel4_sync::{ + RawNotificationMutex, + lock_api::Mutex, +}; sel4_test_capdl::embed_capdl_script!("system.py"); diff --git a/crates/private/tests/capdl/utcover/src/main.rs b/crates/private/tests/capdl/utcover/src/main.rs index 157f5461b..6cf20fd79 100644 --- a/crates/private/tests/capdl/utcover/src/main.rs +++ b/crates/private/tests/capdl/utcover/src/main.rs @@ -9,10 +9,16 @@ extern crate alloc; -use serde::{Deserialize, Serialize}; +use serde::{ + Deserialize, + Serialize, +}; use sel4_simple_task_application_config_types::*; -use sel4_simple_task_runtime::{debug_println, main_json}; +use sel4_simple_task_runtime::{ + debug_println, + main_json, +}; sel4_test_capdl::embed_capdl_script!("system.py"); diff --git a/crates/private/tests/microkit/minimal/src/bin/test.rs b/crates/private/tests/microkit/minimal/src/bin/test.rs index 4d7754542..31e600f5c 100644 --- a/crates/private/tests/microkit/minimal/src/bin/test.rs +++ b/crates/private/tests/microkit/minimal/src/bin/test.rs @@ -7,7 +7,10 @@ #![no_std] #![no_main] -use sel4_microkit::{Never, protection_domain}; +use sel4_microkit::{ + Never, + protection_domain, +}; sel4_test_microkit::embed_sdf_script!("system.xml"); diff --git a/crates/private/tests/microkit/passive-server-with-deferred-action/src/bin/test/client.rs b/crates/private/tests/microkit/passive-server-with-deferred-action/src/bin/test/client.rs index 57a6f8f52..f70ec5cbd 100644 --- a/crates/private/tests/microkit/passive-server-with-deferred-action/src/bin/test/client.rs +++ b/crates/private/tests/microkit/passive-server-with-deferred-action/src/bin/test/client.rs @@ -4,7 +4,12 @@ // SPDX-License-Identifier: BSD-2-Clause // -use sel4_microkit::{Channel, ChannelSet, Handler, Infallible}; +use sel4_microkit::{ + Channel, + ChannelSet, + Handler, + Infallible, +}; const SERVER: Channel = Channel::new(0); diff --git a/crates/private/tests/microkit/passive-server-with-deferred-action/src/bin/test/main.rs b/crates/private/tests/microkit/passive-server-with-deferred-action/src/bin/test/main.rs index 7ffdd2e4e..cf85c217c 100644 --- a/crates/private/tests/microkit/passive-server-with-deferred-action/src/bin/test/main.rs +++ b/crates/private/tests/microkit/passive-server-with-deferred-action/src/bin/test/main.rs @@ -8,7 +8,10 @@ #![no_main] use sel4_microkit::protection_domain; -use sel4_test_microkit::{embed_sdf_xml, match_handler}; +use sel4_test_microkit::{ + embed_sdf_xml, + match_handler, +}; embed_sdf_xml!("system.xml"); diff --git a/crates/private/tests/microkit/passive-server-with-deferred-action/src/bin/test/server.rs b/crates/private/tests/microkit/passive-server-with-deferred-action/src/bin/test/server.rs index 433950546..d7a6ada2f 100644 --- a/crates/private/tests/microkit/passive-server-with-deferred-action/src/bin/test/server.rs +++ b/crates/private/tests/microkit/passive-server-with-deferred-action/src/bin/test/server.rs @@ -4,7 +4,14 @@ // SPDX-License-Identifier: BSD-2-Clause // -use sel4_microkit::{Channel, ChannelSet, DeferredAction, DeferredActionSlot, Handler, Infallible}; +use sel4_microkit::{ + Channel, + ChannelSet, + DeferredAction, + DeferredActionSlot, + Handler, + Infallible, +}; const CLIENT: Channel = Channel::new(0); diff --git a/crates/private/tests/microkit/reset/src/bin/test.rs b/crates/private/tests/microkit/reset/src/bin/test.rs index 7fb43744d..3af69a3c0 100644 --- a/crates/private/tests/microkit/reset/src/bin/test.rs +++ b/crates/private/tests/microkit/reset/src/bin/test.rs @@ -8,7 +8,11 @@ #![no_main] #![allow(static_mut_refs)] -use sel4_microkit::{NullHandler, debug_println, protection_domain}; +use sel4_microkit::{ + NullHandler, + debug_println, + protection_domain, +}; use sel4_reset::reset; sel4_test_microkit::embed_sdf_xml!("system.xml"); diff --git a/crates/private/tests/microkit/unwind/src/bin/test.rs b/crates/private/tests/microkit/unwind/src/bin/test.rs index f90ed3149..bdcfc7183 100644 --- a/crates/private/tests/microkit/unwind/src/bin/test.rs +++ b/crates/private/tests/microkit/unwind/src/bin/test.rs @@ -7,9 +7,17 @@ #![no_std] #![no_main] -use core::sync::atomic::{AtomicBool, Ordering}; - -use sel4_microkit::{NullHandler, debug_println, panicking, protection_domain}; +use core::sync::atomic::{ + AtomicBool, + Ordering, +}; + +use sel4_microkit::{ + NullHandler, + debug_println, + panicking, + protection_domain, +}; sel4_test_microkit::embed_sdf_xml!("system.xml"); diff --git a/crates/private/tests/root-task/alloca/src/main.rs b/crates/private/tests/root-task/alloca/src/main.rs index 30844e280..6c2268e6f 100644 --- a/crates/private/tests/root-task/alloca/src/main.rs +++ b/crates/private/tests/root-task/alloca/src/main.rs @@ -10,7 +10,10 @@ use core::alloc::Layout; use sel4_alloca::*; -use sel4_root_task::{debug_println, root_task}; +use sel4_root_task::{ + debug_println, + root_task, +}; const X: usize = 1234; diff --git a/crates/private/tests/root-task/backtrace/src/main.rs b/crates/private/tests/root-task/backtrace/src/main.rs index b68df9a66..fab70a67c 100644 --- a/crates/private/tests/root-task/backtrace/src/main.rs +++ b/crates/private/tests/root-task/backtrace/src/main.rs @@ -14,7 +14,11 @@ use alloc::string::String; use sel4_backtrace::collect; use sel4_backtrace_embedded_debug_info::get_context; use sel4_backtrace_simple::SimpleBacktracing; -use sel4_root_task::{debug_println, panicking, root_task}; +use sel4_root_task::{ + debug_println, + panicking, + root_task, +}; // TODO // Why are such a large stack and heap required? The unwinding part seems to consume the stack, and diff --git a/crates/private/tests/root-task/c/src/main.rs b/crates/private/tests/root-task/c/src/main.rs index 5d4185328..a66230c26 100644 --- a/crates/private/tests/root-task/c/src/main.rs +++ b/crates/private/tests/root-task/c/src/main.rs @@ -10,7 +10,10 @@ use core::ffi::c_char; use sel4_newlib as _; -use sel4_root_task::{debug_println, root_task}; +use sel4_root_task::{ + debug_println, + root_task, +}; unsafe extern "C" { fn test(s: *const c_char) -> i32; diff --git a/crates/private/tests/root-task/config/src/main.rs b/crates/private/tests/root-task/config/src/main.rs index 78ad2656b..e48db653d 100644 --- a/crates/private/tests/root-task/config/src/main.rs +++ b/crates/private/tests/root-task/config/src/main.rs @@ -7,7 +7,10 @@ #![no_std] #![no_main] -use sel4_root_task::{debug_println, root_task}; +use sel4_root_task::{ + debug_println, + root_task, +}; #[sel4::sel4_cfg(not(KERNEL_STACK_BITS = "0"))] #[root_task] diff --git a/crates/private/tests/root-task/dafny/core/build.rs b/crates/private/tests/root-task/dafny/core/build.rs index 4c1165524..69ca0a254 100644 --- a/crates/private/tests/root-task/dafny/core/build.rs +++ b/crates/private/tests/root-task/dafny/core/build.rs @@ -4,9 +4,11 @@ // SPDX-License-Identifier: BSD-2-Clause // -use std::env; -use std::fs; -use std::path::PathBuf; +use std::{ + env, + fs, + path::PathBuf, +}; use proc_macro2::TokenStream; use quote::quote; diff --git a/crates/private/tests/root-task/loader/src/main.rs b/crates/private/tests/root-task/loader/src/main.rs index 89b6522f1..807861e3a 100644 --- a/crates/private/tests/root-task/loader/src/main.rs +++ b/crates/private/tests/root-task/loader/src/main.rs @@ -10,7 +10,11 @@ #![allow(clippy::single_match)] use sel4_platform_info::PLATFORM_INFO; -use sel4_root_task::{debug_print, debug_println, root_task}; +use sel4_root_task::{ + debug_print, + debug_println, + root_task, +}; #[repr(C, align(8192))] struct Y(i32); diff --git a/crates/private/tests/root-task/musl/src/main.rs b/crates/private/tests/root-task/musl/src/main.rs index 158ca5cee..1611f7c9f 100644 --- a/crates/private/tests/root-task/musl/src/main.rs +++ b/crates/private/tests/root-task/musl/src/main.rs @@ -8,19 +8,39 @@ #![allow(unreachable_patterns)] #![allow(unused_variables)] -use core::alloc::GlobalAlloc; -use core::alloc::Layout; -use core::ffi::c_char; -use core::ptr; +use core::{ + alloc::{ + GlobalAlloc, + Layout, + }, + ffi::c_char, + ptr, +}; use one_shot_mutex::sync::RawOneShotMutex; -use sel4_dlmalloc::{StaticDlmalloc, StaticHeap}; -use sel4_linux_syscall_types::{ENOMEM, ENOSYS, MAP_ANONYMOUS, SEEK_CUR}; +use sel4_dlmalloc::{ + StaticDlmalloc, + StaticHeap, +}; +use sel4_linux_syscall_types::{ + ENOMEM, + ENOSYS, + MAP_ANONYMOUS, + SEEK_CUR, +}; use sel4_musl::{ - ParseSyscallError, Syscall, SyscallReturnValue, VaListAsSyscallArgs, set_syscall_handler, + ParseSyscallError, + Syscall, + SyscallReturnValue, + VaListAsSyscallArgs, + set_syscall_handler, +}; +use sel4_root_task_with_std::{ + debug_print, + debug_println, + declare_root_task, }; -use sel4_root_task_with_std::{debug_print, debug_println, declare_root_task}; declare_root_task!(main = main); diff --git a/crates/private/tests/root-task/panicking/src/main.rs b/crates/private/tests/root-task/panicking/src/main.rs index a8182ac24..55514cefc 100644 --- a/crates/private/tests/root-task/panicking/src/main.rs +++ b/crates/private/tests/root-task/panicking/src/main.rs @@ -7,9 +7,16 @@ #![no_std] #![no_main] -use core::sync::atomic::{AtomicBool, Ordering}; - -use sel4_root_task::{debug_println, panicking, root_task}; +use core::sync::atomic::{ + AtomicBool, + Ordering, +}; + +use sel4_root_task::{ + debug_println, + panicking, + root_task, +}; static F1_DROPPED: AtomicBool = AtomicBool::new(false); diff --git a/crates/private/tests/root-task/reset/src/main.rs b/crates/private/tests/root-task/reset/src/main.rs index ef12423c5..81d30c191 100644 --- a/crates/private/tests/root-task/reset/src/main.rs +++ b/crates/private/tests/root-task/reset/src/main.rs @@ -9,7 +9,10 @@ #![allow(static_mut_refs)] use sel4_reset::reset1; -use sel4_root_task::{debug_println, root_task}; +use sel4_root_task::{ + debug_println, + root_task, +}; const INIT: usize = 1337; diff --git a/crates/private/tests/root-task/ring-test-harness/src/lib.rs b/crates/private/tests/root-task/ring-test-harness/src/lib.rs index 15c0908ba..0c01d2bcd 100644 --- a/crates/private/tests/root-task/ring-test-harness/src/lib.rs +++ b/crates/private/tests/root-task/ring-test-harness/src/lib.rs @@ -31,8 +31,11 @@ fn init() { mod dummy_custom_getrandom { use core::cell::RefCell; - use rand::rngs::SmallRng; - use rand::{Rng, SeedableRng}; + use rand::{ + Rng, + SeedableRng, + rngs::SmallRng, + }; #[cfg(not(target_thread_local))] compile_error!(""); diff --git a/crates/private/tests/root-task/tls/src/main.rs b/crates/private/tests/root-task/tls/src/main.rs index 1ceae5733..7e52d1bc7 100644 --- a/crates/private/tests/root-task/tls/src/main.rs +++ b/crates/private/tests/root-task/tls/src/main.rs @@ -10,7 +10,10 @@ use core::hint::black_box; -use sel4_root_task::{debug_println, root_task}; +use sel4_root_task::{ + debug_println, + root_task, +}; const X: i32 = 1337; diff --git a/crates/sel4-abstract-ptr/src/abstract_ptr/atomic_operations.rs b/crates/sel4-abstract-ptr/src/abstract_ptr/atomic_operations.rs index 96f0746bb..56420a484 100644 --- a/crates/sel4-abstract-ptr/src/abstract_ptr/atomic_operations.rs +++ b/crates/sel4-abstract-ptr/src/abstract_ptr/atomic_operations.rs @@ -6,7 +6,10 @@ use core::sync::atomic::Ordering; -use crate::{AbstractPtr, memory_type::AtomicOps}; +use crate::{ + AbstractPtr, + memory_type::AtomicOps, +}; impl AbstractPtr<'_, M, T, A> where diff --git a/crates/sel4-abstract-ptr/src/abstract_ptr/mod.rs b/crates/sel4-abstract-ptr/src/abstract_ptr/mod.rs index 59b4ab9c2..5609d9857 100644 --- a/crates/sel4-abstract-ptr/src/abstract_ptr/mod.rs +++ b/crates/sel4-abstract-ptr/src/abstract_ptr/mod.rs @@ -5,7 +5,13 @@ // SPDX-License-Identifier: MIT OR Apache-2.0 // -use core::{cmp::Ordering, fmt, hash, marker::PhantomData, ptr::NonNull}; +use core::{ + cmp::Ordering, + fmt, + hash, + marker::PhantomData, + ptr::NonNull, +}; use crate::access::ReadWrite; diff --git a/crates/sel4-abstract-ptr/src/abstract_ptr/operations.rs b/crates/sel4-abstract-ptr/src/abstract_ptr/operations.rs index 74aec8c8e..c6ff55a2b 100644 --- a/crates/sel4-abstract-ptr/src/abstract_ptr/operations.rs +++ b/crates/sel4-abstract-ptr/src/abstract_ptr/operations.rs @@ -5,11 +5,22 @@ // SPDX-License-Identifier: MIT OR Apache-2.0 // -use core::{marker::PhantomData, ptr::NonNull}; +use core::{ + marker::PhantomData, + ptr::NonNull, +}; use crate::{ AbstractPtr, - access::{Access, ReadOnly, ReadWrite, Readable, RestrictAccess, Writable, WriteOnly}, + access::{ + Access, + ReadOnly, + ReadWrite, + Readable, + RestrictAccess, + Writable, + WriteOnly, + }, memory_type::UnitaryOps, }; diff --git a/crates/sel4-abstract-ptr/src/abstract_ptr/slice_operations.rs b/crates/sel4-abstract-ptr/src/abstract_ptr/slice_operations.rs index ba3a1cac4..1a0b7cd1f 100644 --- a/crates/sel4-abstract-ptr/src/abstract_ptr/slice_operations.rs +++ b/crates/sel4-abstract-ptr/src/abstract_ptr/slice_operations.rs @@ -6,16 +6,30 @@ // use core::{ - ops::{Range, RangeBounds}, - ptr::{self, NonNull}, + ops::{ + Range, + RangeBounds, + }, + ptr::{ + self, + NonNull, + }, slice::SliceIndex, }; use crate::{ AbstractPtr, - access::{Access, Readable, Writable}, + access::{ + Access, + Readable, + Writable, + }, core_ext::{ - AbstractPtrSliceIndex, non_null_index, non_null_slice_as_mut_ptr, non_null_slice_len, range, + AbstractPtrSliceIndex, + non_null_index, + non_null_slice_as_mut_ptr, + non_null_slice_len, + range, }, memory_type::BulkOps, }; diff --git a/crates/sel4-abstract-ptr/src/abstract_ref.rs b/crates/sel4-abstract-ptr/src/abstract_ref.rs index 08ad1e229..99fdab1a9 100644 --- a/crates/sel4-abstract-ptr/src/abstract_ref.rs +++ b/crates/sel4-abstract-ptr/src/abstract_ref.rs @@ -5,11 +5,24 @@ // SPDX-License-Identifier: MIT OR Apache-2.0 // -use core::{cmp::Ordering, fmt, hash, marker::PhantomData, ptr::NonNull}; +use core::{ + cmp::Ordering, + fmt, + hash, + marker::PhantomData, + ptr::NonNull, +}; use crate::{ abstract_ptr::AbstractPtr, - access::{Access, Copyable, ReadOnly, ReadWrite, RestrictAccess, WriteOnly}, + access::{ + Access, + Copyable, + ReadOnly, + ReadWrite, + RestrictAccess, + WriteOnly, + }, }; #[must_use] diff --git a/crates/sel4-abstract-ptr/src/core_ext.rs b/crates/sel4-abstract-ptr/src/core_ext.rs index e361b2df8..e25877a1a 100644 --- a/crates/sel4-abstract-ptr/src/core_ext.rs +++ b/crates/sel4-abstract-ptr/src/core_ext.rs @@ -5,8 +5,17 @@ // use core::{ - ops::{self, Bound, Range, RangeBounds, RangeTo}, - ptr::{self, NonNull}, + ops::{ + self, + Bound, + Range, + RangeBounds, + RangeTo, + }, + ptr::{ + self, + NonNull, + }, slice::SliceIndex, }; diff --git a/crates/sel4-alloca/src/lib.rs b/crates/sel4-alloca/src/lib.rs index f11a7773b..1246871e0 100644 --- a/crates/sel4-alloca/src/lib.rs +++ b/crates/sel4-alloca/src/lib.rs @@ -6,10 +6,15 @@ #![no_std] -use core::alloc::Layout; -use core::arch::global_asm; -use core::mem::{ManuallyDrop, MaybeUninit}; -use core::slice; +use core::{ + alloc::Layout, + arch::global_asm, + mem::{ + ManuallyDrop, + MaybeUninit, + }, + slice, +}; // TODO: // - support unwinding diff --git a/crates/sel4-capdl-initializer/add-spec/src/lib.rs b/crates/sel4-capdl-initializer/add-spec/src/lib.rs index 6d794a77e..26562a0e5 100644 --- a/crates/sel4-capdl-initializer/add-spec/src/lib.rs +++ b/crates/sel4-capdl-initializer/add-spec/src/lib.rs @@ -10,7 +10,10 @@ use rkyv::util::AlignedVec; use sel4_capdl_initializer_types::InputSpec; use sel4_patch_elf::dynamic::Patching; -use sel4_phdrs_constants::{PT_SEL4_CAPDL_FRAME_DATA, PT_SEL4_CAPDL_SPEC}; +use sel4_phdrs_constants::{ + PT_SEL4_CAPDL_FRAME_DATA, + PT_SEL4_CAPDL_SPEC, +}; mod reserialize_spec; diff --git a/crates/sel4-capdl-initializer/add-spec/src/main.rs b/crates/sel4-capdl-initializer/add-spec/src/main.rs index 486e4b943..27400080b 100644 --- a/crates/sel4-capdl-initializer/add-spec/src/main.rs +++ b/crates/sel4-capdl-initializer/add-spec/src/main.rs @@ -9,7 +9,10 @@ use std::fs; use anyhow::Result; use clap::Parser; -use sel4_capdl_initializer_add_spec::{ObjectNamesLevel, add_spec}; +use sel4_capdl_initializer_add_spec::{ + ObjectNamesLevel, + add_spec, +}; #[derive(Parser, Debug)] pub struct Cli { diff --git a/crates/sel4-capdl-initializer/add-spec/src/reserialize_spec.rs b/crates/sel4-capdl-initializer/add-spec/src/reserialize_spec.rs index e728d2f91..3a0ae758b 100644 --- a/crates/sel4-capdl-initializer/add-spec/src/reserialize_spec.rs +++ b/crates/sel4-capdl-initializer/add-spec/src/reserialize_spec.rs @@ -8,7 +8,10 @@ use std::{ collections::BTreeMap, fs::File, os::unix::fs::FileExt as _, - path::{Path, PathBuf}, + path::{ + Path, + PathBuf, + }, }; use sel4_capdl_initializer_types::*; diff --git a/crates/sel4-capdl-initializer/src/error.rs b/crates/sel4-capdl-initializer/src/error.rs index 2f2a0557e..a53f2d0ff 100644 --- a/crates/sel4-capdl-initializer/src/error.rs +++ b/crates/sel4-capdl-initializer/src/error.rs @@ -4,8 +4,10 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::convert::Infallible; -use core::fmt; +use core::{ + convert::Infallible, + fmt, +}; use crate::cslot_allocator::CSlotAllocatorError; diff --git a/crates/sel4-capdl-initializer/src/hold_slots.rs b/crates/sel4-capdl-initializer/src/hold_slots.rs index f8884fced..fa85f237a 100644 --- a/crates/sel4-capdl-initializer/src/hold_slots.rs +++ b/crates/sel4-capdl-initializer/src/hold_slots.rs @@ -4,10 +4,15 @@ // SPDX-License-Identifier: BSD-2-Clause // -use sel4::{AbsoluteCPtr, init_thread::Slot}; +use sel4::{ + AbsoluteCPtr, + init_thread::Slot, +}; -use crate::cslot_allocator::CSlotAllocator; -use crate::error::CapDLInitializerError; +use crate::{ + cslot_allocator::CSlotAllocator, + error::CapDLInitializerError, +}; const NUM_SLOTS: usize = 2; diff --git a/crates/sel4-capdl-initializer/src/initialize.rs b/crates/sel4-capdl-initializer/src/initialize.rs index e05e5eca5..5f5b2c5e9 100644 --- a/crates/sel4-capdl-initializer/src/initialize.rs +++ b/crates/sel4-capdl-initializer/src/initialize.rs @@ -4,28 +4,47 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::array; -use core::ops::Range; -use core::result::Result as CoreResult; -use core::slice; +use core::{ + array, + ops::Range, + result::Result as CoreResult, + slice, +}; -use rkyv::Archive; -use rkyv::ops::ArchivedRange; -use rkyv::option::ArchivedOption; +use rkyv::{ + Archive, + ops::ArchivedRange, + option::ArchivedOption, +}; #[allow(unused_imports)] -use log::{debug, error, info, trace}; +use log::{ + debug, + error, + info, + trace, +}; use sel4::{ - CapRights, CapTypeForFrameObjectOfFixedSize, cap_type, - init_thread::{self, Slot}, + CapRights, + CapTypeForFrameObjectOfFixedSize, + cap_type, + init_thread::{ + self, + Slot, + }, }; use sel4_capdl_initializer_types::*; -use crate::cslot_allocator::CSlotAllocator; -use crate::error::CapDLInitializerError; -use crate::hold_slots::HoldSlots; -use crate::memory::{CopyAddrs, get_user_image_frame_slot}; +use crate::{ + cslot_allocator::CSlotAllocator, + error::CapDLInitializerError, + hold_slots::HoldSlots, + memory::{ + CopyAddrs, + get_user_image_frame_slot, + }, +}; type Result = CoreResult; diff --git a/crates/sel4-capdl-initializer/src/lib_main.rs b/crates/sel4-capdl-initializer/src/lib_main.rs index fff3c2266..bccb877ec 100644 --- a/crates/sel4-capdl-initializer/src/lib_main.rs +++ b/crates/sel4-capdl-initializer/src/lib_main.rs @@ -10,9 +10,20 @@ use rkyv::Archive; use sel4_capdl_initializer_types::SpecForInitializer; use sel4_immediate_sync_once_cell::ImmediateSyncOnceCell; -use sel4_logging::{LevelFilter, Logger, LoggerBuilder}; -use sel4_phdrs::{PT_SEL4_CAPDL_FRAME_DATA, PT_SEL4_CAPDL_SPEC, locate_phdrs}; -use sel4_root_task::{debug_print, root_task}; +use sel4_logging::{ + LevelFilter, + Logger, + LoggerBuilder, +}; +use sel4_phdrs::{ + PT_SEL4_CAPDL_FRAME_DATA, + PT_SEL4_CAPDL_SPEC, + locate_phdrs, +}; +use sel4_root_task::{ + debug_print, + root_task, +}; use sel4_phdrs_patched as _; diff --git a/crates/sel4-capdl-initializer/src/memory.rs b/crates/sel4-capdl-initializer/src/memory.rs index 195447019..086e86c48 100644 --- a/crates/sel4-capdl-initializer/src/memory.rs +++ b/crates/sel4-capdl-initializer/src/memory.rs @@ -4,10 +4,18 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::ops::Range; -use core::ptr; +use core::{ + ops::Range, + ptr, +}; -use sel4::{CapTypeForFrameObjectOfFixedSize, cap_type, init_thread, sel4_cfg_attr, sel4_cfg_bool}; +use sel4::{ + CapTypeForFrameObjectOfFixedSize, + cap_type, + init_thread, + sel4_cfg_attr, + sel4_cfg_bool, +}; const SMALL_PAGE_PLACEHOLDER_SIZE: usize = if sel4_cfg_bool!(ARCH_AARCH32) { 1 << 16 diff --git a/crates/sel4-capdl-initializer/types/derive/src/lib.rs b/crates/sel4-capdl-initializer/types/derive/src/lib.rs index 4b54370c3..09a54a075 100644 --- a/crates/sel4-capdl-initializer/types/derive/src/lib.rs +++ b/crates/sel4-capdl-initializer/types/derive/src/lib.rs @@ -5,7 +5,10 @@ // use proc_macro::TokenStream; -use quote::{format_ident, quote}; +use quote::{ + format_ident, + quote, +}; #[proc_macro_derive(IsCap)] pub fn derive_cap(input: TokenStream) -> TokenStream { diff --git a/crates/sel4-capdl-initializer/types/src/cap_table.rs b/crates/sel4-capdl-initializer/types/src/cap_table.rs index 9a4726fae..c0c18e0a7 100644 --- a/crates/sel4-capdl-initializer/types/src/cap_table.rs +++ b/crates/sel4-capdl-initializer/types/src/cap_table.rs @@ -7,7 +7,13 @@ use rkyv::Archive; use crate::{ - ArchivedCapSlot, ArchivedCapTableEntry, CapSlot, CapTableEntry, IsArchivedCap, IsCap, cap, + ArchivedCapSlot, + ArchivedCapTableEntry, + CapSlot, + CapTableEntry, + IsArchivedCap, + IsCap, + cap, object, }; diff --git a/crates/sel4-capdl-initializer/types/src/frame_init.rs b/crates/sel4-capdl-initializer/types/src/frame_init.rs index 4ddd9da5f..276b1c460 100644 --- a/crates/sel4-capdl-initializer/types/src/frame_init.rs +++ b/crates/sel4-capdl-initializer/types/src/frame_init.rs @@ -4,13 +4,20 @@ // SPDX-License-Identifier: BSD-2-Clause // -use alloc::string::String; -use alloc::vec::Vec; -use core::fmt; -use core::ops::Range; +use alloc::{ + string::String, + vec::Vec, +}; +use core::{ + fmt, + ops::Range, +}; #[cfg(feature = "serde")] -use serde::{Deserialize, Serialize}; +use serde::{ + Deserialize, + Serialize, +}; #[derive(Debug, Clone, Eq, PartialEq, rkyv::Archive, rkyv::Serialize)] pub enum FrameInit { diff --git a/crates/sel4-capdl-initializer/types/src/lib.rs b/crates/sel4-capdl-initializer/types/src/lib.rs index 5951cb229..44553bb99 100644 --- a/crates/sel4-capdl-initializer/types/src/lib.rs +++ b/crates/sel4-capdl-initializer/types/src/lib.rs @@ -8,9 +8,11 @@ extern crate alloc; -use rkyv::Archive; -use rkyv::rancor; -use rkyv::util::AlignedVec; +use rkyv::{ + Archive, + rancor, + util::AlignedVec, +}; mod cap_table; mod frame_init; @@ -23,7 +25,10 @@ mod transform; #[cfg(feature = "sel4")] mod when_sel4; -pub use cap_table::{HasArchivedCapTable, HasCapTable}; +pub use cap_table::{ + HasArchivedCapTable, + HasCapTable, +}; pub use frame_init::*; pub use spec::*; diff --git a/crates/sel4-capdl-initializer/types/src/spec.rs b/crates/sel4-capdl-initializer/types/src/spec.rs index 5524c9058..38aa199db 100644 --- a/crates/sel4-capdl-initializer/types/src/spec.rs +++ b/crates/sel4-capdl-initializer/types/src/spec.rs @@ -4,21 +4,37 @@ // SPDX-License-Identifier: BSD-2-Clause // -use alloc::boxed::Box; -use alloc::string::String; -use alloc::vec::Vec; -use core::num::NonZero; -use core::ops::Range; - -use rkyv::Archive; -use rkyv::option::ArchivedOption; +use alloc::{ + boxed::Box, + string::String, + vec::Vec, +}; +use core::{ + num::NonZero, + ops::Range, +}; + +use rkyv::{ + Archive, + option::ArchivedOption, +}; #[cfg(feature = "serde")] -use serde::{Deserialize, Serialize}; - -use sel4_capdl_initializer_types_derive::{HasCapTable, IsCap, IsObject}; - -use crate::{HasArchivedCapTable, HasCapTable}; +use serde::{ + Deserialize, + Serialize, +}; + +use sel4_capdl_initializer_types_derive::{ + HasCapTable, + IsCap, + IsObject, +}; + +use crate::{ + HasArchivedCapTable, + HasCapTable, +}; #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] diff --git a/crates/sel4-capdl-initializer/types/src/transform.rs b/crates/sel4-capdl-initializer/types/src/transform.rs index 0c79e5c62..93354b176 100644 --- a/crates/sel4-capdl-initializer/types/src/transform.rs +++ b/crates/sel4-capdl-initializer/types/src/transform.rs @@ -4,15 +4,31 @@ // SPDX-License-Identifier: BSD-2-Clause // -use alloc::vec; -use alloc::vec::Vec; -use core::convert::Infallible; -use core::ops::Range; +use alloc::{ + vec, + vec::Vec, +}; +use core::{ + convert::Infallible, + ops::Range, +}; use crate::{ - BytesContent, Content, DeflatedBytesContent, EmbeddedFrameIndex, Fill, FillEntry, - FillEntryContent, FrameInit, NamedObject, Object, ObjectId, OrigCapSlots, Spec, - SpecForInitializer, object, + BytesContent, + Content, + DeflatedBytesContent, + EmbeddedFrameIndex, + Fill, + FillEntry, + FillEntryContent, + FrameInit, + NamedObject, + Object, + ObjectId, + OrigCapSlots, + Spec, + SpecForInitializer, + object, }; impl Spec> { diff --git a/crates/sel4-capdl-initializer/types/src/when_sel4.rs b/crates/sel4-capdl-initializer/types/src/when_sel4.rs index 55f385b22..cbff4ab85 100644 --- a/crates/sel4-capdl-initializer/types/src/when_sel4.rs +++ b/crates/sel4-capdl-initializer/types/src/when_sel4.rs @@ -6,11 +6,19 @@ use rkyv::Archive; -use sel4::{ObjectBlueprint, VmAttributes}; +use sel4::{ + ObjectBlueprint, + VmAttributes, +}; use crate::{ - ArchivedCap, ArchivedFillEntryContentBootInfoId, ArchivedObject, ArchivedRights, ArchivedWord, - cap, object::ArchivedPCIDevice, + ArchivedCap, + ArchivedFillEntryContentBootInfoId, + ArchivedObject, + ArchivedRights, + ArchivedWord, + cap, + object::ArchivedPCIDevice, }; impl ArchivedObject { diff --git a/crates/sel4-ctors-dtors/src/lib.rs b/crates/sel4-ctors-dtors/src/lib.rs index 40c51a8a0..ca9a1fdad 100644 --- a/crates/sel4-ctors-dtors/src/lib.rs +++ b/crates/sel4-ctors-dtors/src/lib.rs @@ -11,10 +11,12 @@ #![no_std] #![feature(linkage)] -use core::fmt; -use core::mem; -use core::ptr; -use core::slice; +use core::{ + fmt, + mem, + ptr, + slice, +}; type ArrayEntry = extern "C" fn(); diff --git a/crates/sel4-dlmalloc/src/lib.rs b/crates/sel4-dlmalloc/src/lib.rs index 0d1ab21e0..9c7c961e5 100644 --- a/crates/sel4-dlmalloc/src/lib.rs +++ b/crates/sel4-dlmalloc/src/lib.rs @@ -6,13 +6,27 @@ #![no_std] -use core::alloc::{GlobalAlloc, Layout}; -use core::cell::UnsafeCell; -use core::ptr; -use core::sync::atomic::{AtomicUsize, Ordering}; - -use dlmalloc::{Allocator, Dlmalloc}; -use lock_api::{Mutex, RawMutex}; +use core::{ + alloc::{ + GlobalAlloc, + Layout, + }, + cell::UnsafeCell, + ptr, + sync::atomic::{ + AtomicUsize, + Ordering, + }, +}; + +use dlmalloc::{ + Allocator, + Dlmalloc, +}; +use lock_api::{ + Mutex, + RawMutex, +}; // TODO implement core::alloc::Allocator for StaticDlmalloc once stable diff --git a/crates/sel4-generate-target-specs/src/main.rs b/crates/sel4-generate-target-specs/src/main.rs index 2e8c08baf..0ba4aa222 100644 --- a/crates/sel4-generate-target-specs/src/main.rs +++ b/crates/sel4-generate-target-specs/src/main.rs @@ -9,14 +9,26 @@ extern crate rustc_driver; extern crate rustc_target; -use std::borrow::Cow; -use std::collections::BTreeMap; -use std::fs; -use std::path::Path; - -use rustc_target::json::ToJson; -use rustc_target::spec::{ - Cc, Env, LinkerFlavor, Lld, Os, PanicStrategy, RelocModel, RelroLevel, Target, +use std::{ + borrow::Cow, + collections::BTreeMap, + fs, + path::Path, +}; + +use rustc_target::{ + json::ToJson, + spec::{ + Cc, + Env, + LinkerFlavor, + Lld, + Os, + PanicStrategy, + RelocModel, + RelroLevel, + Target, + }, }; cfg_if! { @@ -28,7 +40,10 @@ cfg_if! { } use cfg_if::cfg_if; -use clap::{Parser, Subcommand}; +use clap::{ + Parser, + Subcommand, +}; const CHOSEN_LINKER_FLAVOR: LinkerFlavor = LinkerFlavor::Gnu(Cc::No, Lld::Yes); diff --git a/crates/sel4-immediate-sync-once-cell/src/lib.rs b/crates/sel4-immediate-sync-once-cell/src/lib.rs index 776744db8..79a3db72b 100644 --- a/crates/sel4-immediate-sync-once-cell/src/lib.rs +++ b/crates/sel4-immediate-sync-once-cell/src/lib.rs @@ -6,8 +6,13 @@ #![no_std] -use core::cell::UnsafeCell; -use core::sync::atomic::{AtomicBool, Ordering}; +use core::{ + cell::UnsafeCell, + sync::atomic::{ + AtomicBool, + Ordering, + }, +}; pub struct ImmediateSyncOnceCell { init_started: AtomicBool, diff --git a/crates/sel4-initialize-tls/src/lib.rs b/crates/sel4-initialize-tls/src/lib.rs index a868ea60f..fa3a3d1ad 100644 --- a/crates/sel4-initialize-tls/src/lib.rs +++ b/crates/sel4-initialize-tls/src/lib.rs @@ -17,10 +17,12 @@ #![no_std] -use core::alloc::Layout; -use core::mem; -use core::ptr; -use core::slice; +use core::{ + alloc::Layout, + mem, + ptr, + slice, +}; #[cfg(feature = "alloc")] extern crate alloc; @@ -36,7 +38,10 @@ compile_error!("unsupported architecture"); mod set_thread_pointer; -pub use set_thread_pointer::{DEFAULT_SET_THREAD_POINTER_FN, SetThreadPointerFn}; +pub use set_thread_pointer::{ + DEFAULT_SET_THREAD_POINTER_FN, + SetThreadPointerFn, +}; mod static_allocation; pub use static_allocation::*; diff --git a/crates/sel4-initialize-tls/src/on_heap.rs b/crates/sel4-initialize-tls/src/on_heap.rs index 7df2e19d9..2b679078e 100644 --- a/crates/sel4-initialize-tls/src/on_heap.rs +++ b/crates/sel4-initialize-tls/src/on_heap.rs @@ -6,7 +6,10 @@ use core::alloc::Layout; -use crate::{Region, TlsImage}; +use crate::{ + Region, + TlsImage, +}; pub struct HeapTlsReservation { start: *mut u8, diff --git a/crates/sel4-initialize-tls/src/on_stack.rs b/crates/sel4-initialize-tls/src/on_stack.rs index ad33380ca..0726b9819 100644 --- a/crates/sel4-initialize-tls/src/on_stack.rs +++ b/crates/sel4-initialize-tls/src/on_stack.rs @@ -6,7 +6,10 @@ use sel4_alloca::with_alloca_ptr; -use crate::{SetThreadPointerFn, TlsImage}; +use crate::{ + SetThreadPointerFn, + TlsImage, +}; impl TlsImage { #[allow(clippy::missing_safety_doc)] diff --git a/crates/sel4-kernel-loader/add-payload/src/main.rs b/crates/sel4-kernel-loader/add-payload/src/main.rs index 34fa16a36..393f2d444 100644 --- a/crates/sel4-kernel-loader/add-payload/src/main.rs +++ b/crates/sel4-kernel-loader/add-payload/src/main.rs @@ -4,17 +4,33 @@ // SPDX-License-Identifier: BSD-2-Clause // -use std::fs::{self, File}; +use std::fs::{ + self, + File, +}; use anyhow::Result; use clap::Parser; -use object::elf::{FileHeader32, FileHeader64}; -use object::read::elf::{ElfFile, FileHeader, ProgramHeader}; -use object::{Endianness, ReadRef}; +use object::{ + Endianness, + ReadRef, + elf::{ + FileHeader32, + FileHeader64, + }, + read::elf::{ + ElfFile, + FileHeader, + ProgramHeader, + }, +}; use rkyv::util::AlignedVec; use sel4_config_types::Configuration; -use sel4_patch_elf::{FileHeaderExt, Patching}; +use sel4_patch_elf::{ + FileHeaderExt, + Patching, +}; use sel4_phdrs_constants::PT_SEL4_KERNEL_LOADER_PAYLOAD; use sel4_platform_info_types::OwnedPlatformInfo; @@ -23,8 +39,13 @@ mod page_tables; mod serialize_payload; mod utils; -use crate::page_tables::Scheme; -use crate::utils::{virt_footprint, with_elf}; +use crate::{ + page_tables::Scheme, + utils::{ + virt_footprint, + with_elf, + }, +}; type ArchiveAlignedVec = AlignedVec; diff --git a/crates/sel4-kernel-loader/add-payload/src/maps.rs b/crates/sel4-kernel-loader/add-payload/src/maps.rs index cdb2f8e30..1bc0d54a2 100644 --- a/crates/sel4-kernel-loader/add-payload/src/maps.rs +++ b/crates/sel4-kernel-loader/add-payload/src/maps.rs @@ -12,7 +12,13 @@ use std::ops::Range; use sel4_platform_info_types::OwnedPlatformInfo; use crate::page_tables::{ - LeafDescriptor, MkLeafArgs, RawDescriptor, Region, RegionsBuilder, Scheme, schemes, + LeafDescriptor, + MkLeafArgs, + RawDescriptor, + Region, + RegionsBuilder, + Scheme, + schemes, }; pub(crate) fn mk_loader_map( diff --git a/crates/sel4-kernel-loader/add-payload/src/page_tables/embed.rs b/crates/sel4-kernel-loader/add-payload/src/page_tables/embed.rs index e7329b4fd..4f5ae19ac 100644 --- a/crates/sel4-kernel-loader/add-payload/src/page_tables/embed.rs +++ b/crates/sel4-kernel-loader/add-payload/src/page_tables/embed.rs @@ -4,8 +4,16 @@ // SPDX-License-Identifier: BSD-2-Clause // -use super::scheme::{Level, Scheme}; -use super::table::{AbstractEntry, Table}; +use super::{ + scheme::{ + Level, + Scheme, + }, + table::{ + AbstractEntry, + Table, + }, +}; impl Table { pub(crate) fn embed(&self, scheme: &Scheme, vaddr: u64) -> (Vec, u64) { diff --git a/crates/sel4-kernel-loader/add-payload/src/page_tables/glue.rs b/crates/sel4-kernel-loader/add-payload/src/page_tables/glue.rs index 7a163ca40..43a7d83e5 100644 --- a/crates/sel4-kernel-loader/add-payload/src/page_tables/glue.rs +++ b/crates/sel4-kernel-loader/add-payload/src/page_tables/glue.rs @@ -6,9 +6,19 @@ use std::ops::Range; -use super::regions::{AbstractRegion, AbstractRegions, AbstractRegionsBuilder}; -use super::scheme::Scheme; -use super::table::{MkLeafFn, RegionContent, Table}; +use super::{ + regions::{ + AbstractRegion, + AbstractRegions, + AbstractRegionsBuilder, + }, + scheme::Scheme, + table::{ + MkLeafFn, + RegionContent, + Table, + }, +}; pub(crate) type Region = AbstractRegion>; pub(crate) type Regions = AbstractRegions>; diff --git a/crates/sel4-kernel-loader/add-payload/src/page_tables/mod.rs b/crates/sel4-kernel-loader/add-payload/src/page_tables/mod.rs index e3098a377..e3e4d48fc 100644 --- a/crates/sel4-kernel-loader/add-payload/src/page_tables/mod.rs +++ b/crates/sel4-kernel-loader/add-payload/src/page_tables/mod.rs @@ -10,12 +10,21 @@ mod regions; mod scheme; mod table; -pub(crate) use glue::{Region, RegionsBuilder}; -pub(crate) use scheme::{LeafDescriptor, RawDescriptor, Scheme}; +pub(crate) use glue::{ + Region, + RegionsBuilder, +}; +pub(crate) use scheme::{ + LeafDescriptor, + RawDescriptor, + Scheme, +}; pub(crate) use table::MkLeafArgs; pub(crate) mod schemes { pub(crate) use super::scheme::{ - AArch32LeafDescriptor, AArch64LeafDescriptor, RiscVLeafDescriptor, + AArch32LeafDescriptor, + AArch64LeafDescriptor, + RiscVLeafDescriptor, }; } diff --git a/crates/sel4-kernel-loader/add-payload/src/page_tables/regions.rs b/crates/sel4-kernel-loader/add-payload/src/page_tables/regions.rs index 09bb2488b..826e149f8 100644 --- a/crates/sel4-kernel-loader/add-payload/src/page_tables/regions.rs +++ b/crates/sel4-kernel-loader/add-payload/src/page_tables/regions.rs @@ -4,8 +4,10 @@ // SPDX-License-Identifier: BSD-2-Clause // -use std::ops::Range; -use std::sync::Arc; +use std::{ + ops::Range, + sync::Arc, +}; #[derive(Debug, Clone, PartialEq, Eq)] pub(crate) struct AbstractRegion { diff --git a/crates/sel4-kernel-loader/add-payload/src/page_tables/scheme.rs b/crates/sel4-kernel-loader/add-payload/src/page_tables/scheme.rs index c376a04d5..ca3e8a847 100644 --- a/crates/sel4-kernel-loader/add-payload/src/page_tables/scheme.rs +++ b/crates/sel4-kernel-loader/add-payload/src/page_tables/scheme.rs @@ -6,7 +6,10 @@ use core::ops::Range; -use bitfield::{BitMut, BitRangeMut}; +use bitfield::{ + BitMut, + BitRangeMut, +}; use sel4_config_types::Configuration; diff --git a/crates/sel4-kernel-loader/add-payload/src/page_tables/table.rs b/crates/sel4-kernel-loader/add-payload/src/page_tables/table.rs index 0640000dc..bc3ffbd96 100644 --- a/crates/sel4-kernel-loader/add-payload/src/page_tables/table.rs +++ b/crates/sel4-kernel-loader/add-payload/src/page_tables/table.rs @@ -4,11 +4,23 @@ // SPDX-License-Identifier: BSD-2-Clause // -use std::borrow::Borrow; -use std::sync::Arc; - -use super::regions::{AbstractRegion, AbstractRegions}; -use super::scheme::{LeafDescriptor, Level, RawDescriptor, Scheme}; +use std::{ + borrow::Borrow, + sync::Arc, +}; + +use super::{ + regions::{ + AbstractRegion, + AbstractRegions, + }, + scheme::{ + LeafDescriptor, + Level, + RawDescriptor, + Scheme, + }, +}; #[derive(Debug)] pub(crate) struct Table { diff --git a/crates/sel4-kernel-loader/add-payload/src/serialize_payload.rs b/crates/sel4-kernel-loader/add-payload/src/serialize_payload.rs index 753b27eeb..0c63ae941 100644 --- a/crates/sel4-kernel-loader/add-payload/src/serialize_payload.rs +++ b/crates/sel4-kernel-loader/add-payload/src/serialize_payload.rs @@ -4,20 +4,39 @@ // SPDX-License-Identifier: BSD-2-Clause // -use std::fs; -use std::ops::Range; -use std::path::Path; +use std::{ + fs, + ops::Range, + path::Path, +}; use num::Integer; -use object::read::elf::{ElfFile, FileHeader, ProgramHeader}; -use object::{Object, ObjectSegment, ReadRef}; +use object::{ + Object, + ObjectSegment, + ReadRef, + read::elf::{ + ElfFile, + FileHeader, + ProgramHeader, + }, +}; use sel4_kernel_loader_payload_types::{ - DtbInfo, Payload, PayloadInfo, Region, UserImageInfo, Word, + DtbInfo, + Payload, + PayloadInfo, + Region, + UserImageInfo, + Word, }; use sel4_platform_info_types::OwnedPlatformInfo; -use crate::utils::{loadable_segments, virt_footprint, with_elf}; +use crate::utils::{ + loadable_segments, + virt_footprint, + with_elf, +}; const PAGE_SIZE: u64 = 4096; diff --git a/crates/sel4-kernel-loader/add-payload/src/utils.rs b/crates/sel4-kernel-loader/add-payload/src/utils.rs index bb55e4711..004a39f19 100644 --- a/crates/sel4-kernel-loader/add-payload/src/utils.rs +++ b/crates/sel4-kernel-loader/add-payload/src/utils.rs @@ -4,13 +4,25 @@ // SPDX-License-Identifier: BSD-2-Clause // -use std::fs::File; -use std::ops::Range; -use std::path::Path; +use std::{ + fs::File, + ops::Range, + path::Path, +}; -use object::elf::PT_LOAD; -use object::read::elf::{ElfFile, ElfSegment, FileHeader, ProgramHeader}; -use object::{Object, ObjectSegment, ReadCache, ReadRef}; +use object::{ + Object, + ObjectSegment, + ReadCache, + ReadRef, + elf::PT_LOAD, + read::elf::{ + ElfFile, + ElfSegment, + FileHeader, + ProgramHeader, + }, +}; pub(crate) fn with_elf(path: impl AsRef, f: F) -> R where diff --git a/crates/sel4-kernel-loader/build.rs b/crates/sel4-kernel-loader/build.rs index 3d36f22c2..8a76b1af2 100644 --- a/crates/sel4-kernel-loader/build.rs +++ b/crates/sel4-kernel-loader/build.rs @@ -6,18 +6,30 @@ #![allow(clippy::useless_conversion)] -use std::fs; -use std::ops::Range; +use std::{ + fs, + ops::Range, +}; use object::{ ReadRef, elf::PT_LOAD, endian::Endianness, - read::elf::{ElfFile, FileHeader, ProgramHeader}, + read::elf::{ + ElfFile, + FileHeader, + ProgramHeader, + }, }; -use sel4_build_env::{get_libsel4_include_dirs, get_with_sel4_prefix_relative_fallback}; -use sel4_config::{sel4_cfg, sel4_cfg_str}; +use sel4_build_env::{ + get_libsel4_include_dirs, + get_with_sel4_prefix_relative_fallback, +}; +use sel4_config::{ + sel4_cfg, + sel4_cfg_str, +}; pub const SEL4_KERNEL_ENV: &str = "SEL4_KERNEL"; diff --git a/crates/sel4-kernel-loader/payload-types/src/lib.rs b/crates/sel4-kernel-loader/payload-types/src/lib.rs index 31717ea6b..cacdbfde8 100644 --- a/crates/sel4-kernel-loader/payload-types/src/lib.rs +++ b/crates/sel4-kernel-loader/payload-types/src/lib.rs @@ -9,15 +9,19 @@ extern crate alloc; use alloc::vec::Vec; -use core::cmp; -use core::fmt; -use core::ops::Range; -use core::ptr; -use core::slice; - -use rkyv::Archive; -use rkyv::rancor; -use rkyv::util::AlignedVec; +use core::{ + cmp, + fmt, + ops::Range, + ptr, + slice, +}; + +use rkyv::{ + Archive, + rancor, + util::AlignedVec, +}; use sel4_platform_info_types::PlatformInfo; diff --git a/crates/sel4-kernel-loader/src/arch/arm/arch/aarch32/drivers/spin_table.rs b/crates/sel4-kernel-loader/src/arch/arm/arch/aarch32/drivers/spin_table.rs index 6c42e25f2..c6e8db19c 100644 --- a/crates/sel4-kernel-loader/src/arch/arm/arch/aarch32/drivers/spin_table.rs +++ b/crates/sel4-kernel-loader/src/arch/arm/arch/aarch32/drivers/spin_table.rs @@ -4,8 +4,13 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::arch::{asm, global_asm}; -use core::ptr; +use core::{ + arch::{ + asm, + global_asm, + }, + ptr, +}; #[used] #[unsafe(no_mangle)] diff --git a/crates/sel4-kernel-loader/src/arch/arm/arch/aarch32/mod.rs b/crates/sel4-kernel-loader/src/arch/arm/arch/aarch32/mod.rs index 71f130889..30f04c14a 100644 --- a/crates/sel4-kernel-loader/src/arch/arm/arch/aarch32/mod.rs +++ b/crates/sel4-kernel-loader/src/arch/arm/arch/aarch32/mod.rs @@ -4,12 +4,18 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::arch::asm; -use core::mem; +use core::{ + arch::asm, + mem, +}; use sel4_kernel_loader_payload_types::ArchivedPayloadInfo; -use crate::{arch::Arch, main, secondary_main}; +use crate::{ + arch::Arch, + main, + secondary_main, +}; pub(crate) mod drivers; diff --git a/crates/sel4-kernel-loader/src/arch/arm/arch/aarch64/drivers/spin_table.rs b/crates/sel4-kernel-loader/src/arch/arm/arch/aarch64/drivers/spin_table.rs index 683c6d9b7..17a56552e 100644 --- a/crates/sel4-kernel-loader/src/arch/arm/arch/aarch64/drivers/spin_table.rs +++ b/crates/sel4-kernel-loader/src/arch/arm/arch/aarch64/drivers/spin_table.rs @@ -4,9 +4,17 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::arch::{asm, global_asm}; -use core::ptr; -use core::sync::atomic::{AtomicUsize, Ordering}; +use core::{ + arch::{ + asm, + global_asm, + }, + ptr, + sync::atomic::{ + AtomicUsize, + Ordering, + }, +}; #[used] #[unsafe(no_mangle)] diff --git a/crates/sel4-kernel-loader/src/arch/arm/arch/aarch64/exception_handler.rs b/crates/sel4-kernel-loader/src/arch/arm/arch/aarch64/exception_handler.rs index 75da18c9e..e4f549404 100644 --- a/crates/sel4-kernel-loader/src/arch/arm/arch/aarch64/exception_handler.rs +++ b/crates/sel4-kernel-loader/src/arch/arm/arch/aarch64/exception_handler.rs @@ -4,11 +4,18 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::arch::asm; -use core::fmt; +use core::{ + arch::asm, + fmt, +}; -use crate::arch::{Arch, ArchImpl}; -use crate::fmt::debug_println_without_synchronization; +use crate::{ + arch::{ + Arch, + ArchImpl, + }, + fmt::debug_println_without_synchronization, +}; #[used] #[unsafe(no_mangle)] diff --git a/crates/sel4-kernel-loader/src/arch/arm/arch/aarch64/mod.rs b/crates/sel4-kernel-loader/src/arch/arm/arch/aarch64/mod.rs index dd11fca60..5da48d244 100644 --- a/crates/sel4-kernel-loader/src/arch/arm/arch/aarch64/mod.rs +++ b/crates/sel4-kernel-loader/src/arch/arm/arch/aarch64/mod.rs @@ -4,14 +4,23 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::arch::asm; -use core::mem; +use core::{ + arch::asm, + mem, +}; -use aarch64_cpu::registers::{CurrentEL, Readable}; +use aarch64_cpu::registers::{ + CurrentEL, + Readable, +}; use sel4_kernel_loader_payload_types::ArchivedPayloadInfo; -use crate::{arch::Arch, main, secondary_main}; +use crate::{ + arch::Arch, + main, + secondary_main, +}; pub(crate) mod drivers; pub(crate) mod exception_handler; diff --git a/crates/sel4-kernel-loader/src/arch/riscv/mod.rs b/crates/sel4-kernel-loader/src/arch/riscv/mod.rs index b497c1149..0a3d7bba8 100644 --- a/crates/sel4-kernel-loader/src/arch/riscv/mod.rs +++ b/crates/sel4-kernel-loader/src/arch/riscv/mod.rs @@ -4,15 +4,22 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::arch::asm; -use core::mem; +use core::{ + arch::asm, + mem, +}; use riscv::register::satp; use sel4_config::sel4_cfg_if; use sel4_kernel_loader_payload_types::ArchivedPayloadInfo; -use crate::{arch::Arch, main, secondary_main, this_image::kernel_boot_level_0_table}; +use crate::{ + arch::Arch, + main, + secondary_main, + this_image::kernel_boot_level_0_table, +}; pub(crate) struct PerCoreImpl { hart_id: usize, diff --git a/crates/sel4-kernel-loader/src/barrier.rs b/crates/sel4-kernel-loader/src/barrier.rs index 44c102f64..890ba6cc0 100644 --- a/crates/sel4-kernel-loader/src/barrier.rs +++ b/crates/sel4-kernel-loader/src/barrier.rs @@ -4,8 +4,13 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::hint; -use core::sync::atomic::{AtomicUsize, Ordering}; +use core::{ + hint, + sync::atomic::{ + AtomicUsize, + Ordering, + }, +}; // ::spin::Barrier appears to use too tight of a loop diff --git a/crates/sel4-kernel-loader/src/fmt.rs b/crates/sel4-kernel-loader/src/fmt.rs index 7a88182e7..820112546 100644 --- a/crates/sel4-kernel-loader/src/fmt.rs +++ b/crates/sel4-kernel-loader/src/fmt.rs @@ -9,7 +9,10 @@ use core::fmt; -use crate::plat::{Plat, PlatImpl}; +use crate::plat::{ + Plat, + PlatImpl, +}; struct DebugWrite; diff --git a/crates/sel4-kernel-loader/src/logging.rs b/crates/sel4-kernel-loader/src/logging.rs index fce783ba6..fe2f30ef8 100644 --- a/crates/sel4-kernel-loader/src/logging.rs +++ b/crates/sel4-kernel-loader/src/logging.rs @@ -6,7 +6,12 @@ use spin::Mutex; -use sel4_logging::{LevelFilter, Logger, LoggerBuilder, SynchronizedLogger}; +use sel4_logging::{ + LevelFilter, + Logger, + LoggerBuilder, + SynchronizedLogger, +}; use crate::fmt::debug_print; diff --git a/crates/sel4-kernel-loader/src/main.rs b/crates/sel4-kernel-loader/src/main.rs index 0964795e5..544704fe8 100644 --- a/crates/sel4-kernel-loader/src/main.rs +++ b/crates/sel4-kernel-loader/src/main.rs @@ -24,9 +24,15 @@ mod rt; mod this_image; use crate::{ - arch::{Arch, ArchImpl}, + arch::{ + Arch, + ArchImpl, + }, barrier::Barrier, - plat::{Plat, PlatImpl}, + plat::{ + Plat, + PlatImpl, + }, }; const MAX_NUM_NODES: usize = sel4_config::sel4_cfg_usize!(MAX_NUM_NODES); diff --git a/crates/sel4-kernel-loader/src/plat/bcm2711/mod.rs b/crates/sel4-kernel-loader/src/plat/bcm2711/mod.rs index 023970126..81bafc419 100644 --- a/crates/sel4-kernel-loader/src/plat/bcm2711/mod.rs +++ b/crates/sel4-kernel-loader/src/plat/bcm2711/mod.rs @@ -4,14 +4,22 @@ // SPDX-License-Identifier: BSD-2-Clause // -use embedded_hal_nb::nb; -use embedded_hal_nb::serial::Write; +use embedded_hal_nb::{ + nb, + serial::Write, +}; use spin::lock_api::Mutex; use sel4_bcm2835_aux_uart_driver::Driver as Bcm2835AuxUartDriver; -use sel4_config::{sel4_cfg, sel4_cfg_bool}; +use sel4_config::{ + sel4_cfg, + sel4_cfg_bool, +}; -use crate::{arch::reset_cntvoff, plat::Plat}; +use crate::{ + arch::reset_cntvoff, + plat::Plat, +}; const SERIAL_DEVICE_BASE_ADDR: usize = 0xfe21_5000; diff --git a/crates/sel4-kernel-loader/src/plat/qemu_arm_virt/mod.rs b/crates/sel4-kernel-loader/src/plat/qemu_arm_virt/mod.rs index a721036a9..9c470753b 100644 --- a/crates/sel4-kernel-loader/src/plat/qemu_arm_virt/mod.rs +++ b/crates/sel4-kernel-loader/src/plat/qemu_arm_virt/mod.rs @@ -4,15 +4,20 @@ // SPDX-License-Identifier: BSD-2-Clause // -use embedded_hal_nb::nb; -use embedded_hal_nb::serial::Write; +use embedded_hal_nb::{ + nb, + serial::Write, +}; use spin::lock_api::Mutex; use sel4_config::sel4_cfg_bool; use sel4_pl011_driver::Driver as Pl011Driver; use crate::{ - arch::{drivers::psci, reset_cntvoff}, + arch::{ + drivers::psci, + reset_cntvoff, + }, plat::Plat, }; diff --git a/crates/sel4-kernel-loader/src/plat/riscv_generic/mod.rs b/crates/sel4-kernel-loader/src/plat/riscv_generic/mod.rs index c0dad7532..e7da3e541 100644 --- a/crates/sel4-kernel-loader/src/plat/riscv_generic/mod.rs +++ b/crates/sel4-kernel-loader/src/plat/riscv_generic/mod.rs @@ -4,8 +4,14 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::ptr; -use core::sync::atomic::{AtomicI32, AtomicUsize, Ordering}; +use core::{ + ptr, + sync::atomic::{ + AtomicI32, + AtomicUsize, + Ordering, + }, +}; use sel4_config::sel4_cfg_usize; diff --git a/crates/sel4-kernel-loader/src/rt.rs b/crates/sel4-kernel-loader/src/rt.rs index 1f9d71c12..f92bb7f42 100644 --- a/crates/sel4-kernel-loader/src/rt.rs +++ b/crates/sel4-kernel-loader/src/rt.rs @@ -6,7 +6,10 @@ use core::panic::PanicInfo; -use crate::arch::{Arch, ArchImpl}; +use crate::arch::{ + Arch, + ArchImpl, +}; #[panic_handler] fn panic_handler(info: &PanicInfo) -> ! { diff --git a/crates/sel4-kernel-loader/src/this_image.rs b/crates/sel4-kernel-loader/src/this_image.rs index 3a726224b..f6b199942 100644 --- a/crates/sel4-kernel-loader/src/this_image.rs +++ b/crates/sel4-kernel-loader/src/this_image.rs @@ -8,7 +8,10 @@ use core::ops::Range; use sel4_immutable_cell::ImmutableCell; use sel4_kernel_loader_payload_types::*; -use sel4_phdrs::{PT_SEL4_KERNEL_LOADER_PAYLOAD, locate_phdrs}; +use sel4_phdrs::{ + PT_SEL4_KERNEL_LOADER_PAYLOAD, + locate_phdrs, +}; use sel4_phdrs_patched as _; @@ -39,7 +42,10 @@ pub(crate) static kernel_boot_level_0_table: ImmutableCell = ImmutableCel pub(crate) mod stacks { use sel4_config::sel4_cfg_usize; - use sel4_stack::{Stack, StackBottom}; + use sel4_stack::{ + Stack, + StackBottom, + }; const PRIMARY_STACK_SIZE: usize = 4096 * 8; // TODO this is excessive diff --git a/crates/sel4-logging/src/lib.rs b/crates/sel4-logging/src/lib.rs index 1aa185b9c..30974aa8b 100644 --- a/crates/sel4-logging/src/lib.rs +++ b/crates/sel4-logging/src/lib.rs @@ -6,11 +6,22 @@ #![no_std] -use core::fmt::{self, Write}; - -use log::{Log, Metadata, Record, SetLoggerError}; - -pub use log::{self, LevelFilter}; +use core::fmt::{ + self, + Write, +}; + +use log::{ + Log, + Metadata, + Record, + SetLoggerError, +}; + +pub use log::{ + self, + LevelFilter, +}; mod synchronized; diff --git a/crates/sel4-logging/src/synchronized.rs b/crates/sel4-logging/src/synchronized.rs index 35ad26b8a..65a29ef08 100644 --- a/crates/sel4-logging/src/synchronized.rs +++ b/crates/sel4-logging/src/synchronized.rs @@ -4,8 +4,15 @@ // SPDX-License-Identifier: BSD-2-Clause // -use lock_api::{Mutex, RawMutex}; -use log::{Log, Metadata, Record}; +use lock_api::{ + Mutex, + RawMutex, +}; +use log::{ + Log, + Metadata, + Record, +}; pub struct SynchronizedLogger(Mutex); diff --git a/crates/sel4-microkit/base/src/channel.rs b/crates/sel4-microkit/base/src/channel.rs index 8a4c91305..b91c0d4c5 100644 --- a/crates/sel4-microkit/base/src/channel.rs +++ b/crates/sel4-microkit/base/src/channel.rs @@ -8,7 +8,11 @@ use core::fmt; use crate::{ MessageInfo, - symbols::{pd_irqs, pd_notifications, pd_pps}, + symbols::{ + pd_irqs, + pd_notifications, + pd_pps, + }, }; const BASE_OUTPUT_NOTIFICATION_SLOT: usize = 10; diff --git a/crates/sel4-microkit/base/src/defer.rs b/crates/sel4-microkit/base/src/defer.rs index d04ddc934..f9b425e4f 100644 --- a/crates/sel4-microkit/base/src/defer.rs +++ b/crates/sel4-microkit/base/src/defer.rs @@ -4,7 +4,10 @@ // SPDX-License-Identifier: BSD-2-Clause // -use crate::{Channel, IrqAckError}; +use crate::{ + Channel, + IrqAckError, +}; // For rustdoc #[allow(unused_imports)] diff --git a/crates/sel4-microkit/base/src/handler.rs b/crates/sel4-microkit/base/src/handler.rs index f39009657..f10b82f0c 100644 --- a/crates/sel4-microkit/base/src/handler.rs +++ b/crates/sel4-microkit/base/src/handler.rs @@ -10,10 +10,20 @@ use core::fmt; use alloc::boxed::Box; use crate::{ - Channel, Child, MessageInfo, - defer::{DeferredAction, PreparedDeferredAction}, - ipc::{self, ChannelSet, Event}, - pd_is_passive, symbols, + Channel, + Child, + MessageInfo, + defer::{ + DeferredAction, + PreparedDeferredAction, + }, + ipc::{ + self, + ChannelSet, + Event, + }, + pd_is_passive, + symbols, }; pub use core::convert::Infallible; diff --git a/crates/sel4-microkit/base/src/ipc.rs b/crates/sel4-microkit/base/src/ipc.rs index 49ee0c49c..9ce2011f0 100644 --- a/crates/sel4-microkit/base/src/ipc.rs +++ b/crates/sel4-microkit/base/src/ipc.rs @@ -6,7 +6,12 @@ use core::fmt; -use crate::{Channel, Child, MessageInfo, defer::PreparedDeferredAction}; +use crate::{ + Channel, + Child, + MessageInfo, + defer::PreparedDeferredAction, +}; const INPUT_CAP: sel4::cap::Endpoint = sel4::Cap::from_bits(1); const REPLY_CAP: sel4::cap::Reply = sel4::Cap::from_bits(4); diff --git a/crates/sel4-microkit/base/src/lib.rs b/crates/sel4-microkit/base/src/lib.rs index dd81c6aae..a6352306f 100644 --- a/crates/sel4-microkit/base/src/lib.rs +++ b/crates/sel4-microkit/base/src/lib.rs @@ -20,15 +20,41 @@ mod symbols; #[doc(hidden)] pub mod ipc; -pub use channel::{Channel, Child, IrqAckError}; -pub use defer::{DeferredAction, DeferredActionInterface, DeferredActionSlot}; -pub use handler::{Handler, Infallible, Never, NullHandler}; -pub use ipc::{ChannelSet, DisplayChannelSet}; +pub use channel::{ + Channel, + Child, + IrqAckError, +}; +pub use defer::{ + DeferredAction, + DeferredActionInterface, + DeferredActionSlot, +}; +pub use handler::{ + Handler, + Infallible, + Never, + NullHandler, +}; +pub use ipc::{ + ChannelSet, + DisplayChannelSet, +}; pub use message::{ - MessageInfo, MessageLabel, MessageRegisterValue, get_mr, set_mr, with_msg_bytes, - with_msg_bytes_mut, with_msg_regs, with_msg_regs_mut, + MessageInfo, + MessageLabel, + MessageRegisterValue, + get_mr, + set_mr, + with_msg_bytes, + with_msg_bytes_mut, + with_msg_regs, + with_msg_regs_mut, +}; +pub use symbols::{ + pd_is_passive, + pd_name, }; -pub use symbols::{pd_is_passive, pd_name}; // For macros #[doc(hidden)] diff --git a/crates/sel4-microkit/base/src/symbols.rs b/crates/sel4-microkit/base/src/symbols.rs index cd773e847..b5909ad0e 100644 --- a/crates/sel4-microkit/base/src/symbols.rs +++ b/crates/sel4-microkit/base/src/symbols.rs @@ -4,7 +4,10 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::str::{self, Utf8Error}; +use core::str::{ + self, + Utf8Error, +}; /// Declares a symbol via which the `microkit` tool can inject a variable declared by e.g. /// `setvar_vaddr`, and returns the variable's value at runtime. diff --git a/crates/sel4-microkit/src/entry.rs b/crates/sel4-microkit/src/entry.rs index b997e5609..7ba037b17 100644 --- a/crates/sel4-microkit/src/entry.rs +++ b/crates/sel4-microkit/src/entry.rs @@ -9,7 +9,10 @@ use core::panic::UnwindSafe; use sel4_panicking::catch_unwind; use sel4_panicking_env::abort; -use crate::{Handler, panicking::init_panicking}; +use crate::{ + Handler, + panicking::init_panicking, +}; sel4_runtime_common::declare_rust_entrypoint! { entrypoint() diff --git a/crates/sel4-microkit/src/heap.rs b/crates/sel4-microkit/src/heap.rs index 151cef8b7..d19ea6d91 100644 --- a/crates/sel4-microkit/src/heap.rs +++ b/crates/sel4-microkit/src/heap.rs @@ -29,5 +29,8 @@ macro_rules! declare_heap { pub mod _private { pub use one_shot_mutex::sync::RawOneShotMutex; - pub use sel4_dlmalloc::{StaticDlmalloc, StaticHeap}; + pub use sel4_dlmalloc::{ + StaticDlmalloc, + StaticHeap, + }; } diff --git a/crates/sel4-microkit/src/lib.rs b/crates/sel4-microkit/src/lib.rs index 703e753ad..ad79e1a07 100644 --- a/crates/sel4-microkit/src/lib.rs +++ b/crates/sel4-microkit/src/lib.rs @@ -43,7 +43,10 @@ mod printing; pub mod panicking; #[sel4::sel4_cfg(PRINTING)] -pub use printing::{debug_print, debug_println}; +pub use printing::{ + debug_print, + debug_println, +}; /// Declares a function to be the the protection domain's initialization function. /// @@ -112,8 +115,15 @@ pub mod _private { pub use crate::heap::_private as heap; pub use sel4_runtime_common::{ - declare_entrypoint, declare_entrypoint_with_stack_init, declare_stack, + declare_entrypoint, + declare_entrypoint_with_stack_init, + declare_stack, }; - pub use crate::{declare_heap, declare_init, declare_protection_domain, entry::run_main}; + pub use crate::{ + declare_heap, + declare_init, + declare_protection_domain, + entry::run_main, + }; } diff --git a/crates/sel4-microkit/src/panicking.rs b/crates/sel4-microkit/src/panicking.rs index 9390a6466..c7a4859ca 100644 --- a/crates/sel4-microkit/src/panicking.rs +++ b/crates/sel4-microkit/src/panicking.rs @@ -10,7 +10,10 @@ use sel4_immediate_sync_once_cell::ImmediateSyncOnceCell; use sel4_panicking::set_hook as set_outer_hook; use sel4_panicking_env::debug_println; -pub use sel4_panicking::{PanicHook, catch_unwind}; +pub use sel4_panicking::{ + PanicHook, + catch_unwind, +}; use crate::pd_name; diff --git a/crates/sel4-no-allocator/src/lib.rs b/crates/sel4-no-allocator/src/lib.rs index c925b4776..c70ecff7a 100644 --- a/crates/sel4-no-allocator/src/lib.rs +++ b/crates/sel4-no-allocator/src/lib.rs @@ -6,7 +6,10 @@ #![no_std] -use core::alloc::{GlobalAlloc, Layout}; +use core::alloc::{ + GlobalAlloc, + Layout, +}; #[global_allocator] static A: NoAllocator = NoAllocator; diff --git a/crates/sel4-one-ref-cell/src/lib.rs b/crates/sel4-one-ref-cell/src/lib.rs index 80a1ea543..b9b99c85c 100644 --- a/crates/sel4-one-ref-cell/src/lib.rs +++ b/crates/sel4-one-ref-cell/src/lib.rs @@ -6,8 +6,13 @@ #![no_std] -use core::cell::UnsafeCell; -use core::sync::atomic::{AtomicBool, Ordering}; +use core::{ + cell::UnsafeCell, + sync::atomic::{ + AtomicBool, + Ordering, + }, +}; pub struct OneRefCell { taken: AtomicBool, diff --git a/crates/sel4-panicking/env/src/lib.rs b/crates/sel4-panicking/env/src/lib.rs index fdaa4cd27..55ba445c3 100644 --- a/crates/sel4-panicking/env/src/lib.rs +++ b/crates/sel4-panicking/env/src/lib.rs @@ -7,9 +7,11 @@ #![no_std] #![feature(linkage)] -use core::fmt; -use core::panic::Location; -use core::str; +use core::{ + fmt, + panic::Location, + str, +}; unsafe extern "Rust" { fn __sel4_panicking_env__debug_put_char(c: u8); diff --git a/crates/sel4-panicking/src/count/with_tls.rs b/crates/sel4-panicking/src/count/with_tls.rs index 344fcd547..fc4a8780a 100644 --- a/crates/sel4-panicking/src/count/with_tls.rs +++ b/crates/sel4-panicking/src/count/with_tls.rs @@ -4,8 +4,10 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::cell::Cell; -use core::fmt; +use core::{ + cell::Cell, + fmt, +}; #[thread_local] static PANIC_COUNT: Cell = Cell::new(0); diff --git a/crates/sel4-panicking/src/count/without_tls.rs b/crates/sel4-panicking/src/count/without_tls.rs index a263475e6..c81985e6d 100644 --- a/crates/sel4-panicking/src/count/without_tls.rs +++ b/crates/sel4-panicking/src/count/without_tls.rs @@ -4,8 +4,13 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::fmt; -use core::sync::atomic::{AtomicBool, Ordering}; +use core::{ + fmt, + sync::atomic::{ + AtomicBool, + Ordering, + }, +}; static PANICKING: AtomicBool = AtomicBool::new(false); diff --git a/crates/sel4-panicking/src/lib.rs b/crates/sel4-panicking/src/lib.rs index a8a9437ab..3fa0677b2 100644 --- a/crates/sel4-panicking/src/lib.rs +++ b/crates/sel4-panicking/src/lib.rs @@ -13,18 +13,30 @@ #[cfg(feature = "alloc")] extern crate alloc; -use core::panic::{PanicInfo, UnwindSafe}; +use core::panic::{ + PanicInfo, + UnwindSafe, +}; -use sel4_panicking_env::{abort, debug_println}; +use sel4_panicking_env::{ + abort, + debug_println, +}; mod count; mod hook; mod strategy; -use count::{count_panic, count_panic_caught}; +use count::{ + count_panic, + count_panic_caught, +}; use hook::get_hook; -pub use hook::{PanicHook, set_hook}; +pub use hook::{ + PanicHook, + set_hook, +}; #[cfg_attr(feature = "panic-handler", panic_handler)] #[cfg_attr(not(feature = "panic-handler"), allow(dead_code))] diff --git a/crates/sel4-panicking/src/strategy/abort/mod.rs b/crates/sel4-panicking/src/strategy/abort/mod.rs index 6ff3696d8..0198db006 100644 --- a/crates/sel4-panicking/src/strategy/abort/mod.rs +++ b/crates/sel4-panicking/src/strategy/abort/mod.rs @@ -4,8 +4,10 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::ffi::c_int; -use core::panic::UnwindSafe; +use core::{ + ffi::c_int, + panic::UnwindSafe, +}; use sel4_panicking_env::abort_without_info; diff --git a/crates/sel4-panicking/src/strategy/unwind/mod.rs b/crates/sel4-panicking/src/strategy/unwind/mod.rs index a852a1ff3..2065d7c34 100644 --- a/crates/sel4-panicking/src/strategy/unwind/mod.rs +++ b/crates/sel4-panicking/src/strategy/unwind/mod.rs @@ -4,10 +4,15 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::ffi::c_int; -use core::mem::{self, MaybeUninit}; -use core::panic::UnwindSafe; -use core::ptr; +use core::{ + ffi::c_int, + mem::{ + self, + MaybeUninit, + }, + panic::UnwindSafe, + ptr, +}; use unwinding::abi::*; diff --git a/crates/sel4-panicking/src/strategy/unwind/with_alloc.rs b/crates/sel4-panicking/src/strategy/unwind/with_alloc.rs index 084ab8829..ad5ffdc32 100644 --- a/crates/sel4-panicking/src/strategy/unwind/with_alloc.rs +++ b/crates/sel4-panicking/src/strategy/unwind/with_alloc.rs @@ -6,10 +6,16 @@ use alloc::boxed::Box; -use unwinding::abi::*; -use unwinding::panicking::Exception; +use unwinding::{ + abi::*, + panicking::Exception, +}; -use super::{ExceptionImpl, RustPanic, foreign_exception}; +use super::{ + ExceptionImpl, + RustPanic, + foreign_exception, +}; unsafe impl Exception for RustPanic { const CLASS: [u8; 8] = RustPanic::EXCEPTION_CLASS; diff --git a/crates/sel4-panicking/src/strategy/unwind/without_alloc.rs b/crates/sel4-panicking/src/strategy/unwind/without_alloc.rs index 8b5532023..9c0c44785 100644 --- a/crates/sel4-panicking/src/strategy/unwind/without_alloc.rs +++ b/crates/sel4-panicking/src/strategy/unwind/without_alloc.rs @@ -4,13 +4,21 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::cell::Cell; -use core::mem::MaybeUninit; - -use unwinding::abi::*; -use unwinding::panicking::Exception; - -use super::{ExceptionImpl, RustPanic, foreign_exception}; +use core::{ + cell::Cell, + mem::MaybeUninit, +}; + +use unwinding::{ + abi::*, + panicking::Exception, +}; + +use super::{ + ExceptionImpl, + RustPanic, + foreign_exception, +}; #[cfg(not(target_thread_local))] compile_error!(""); diff --git a/crates/sel4-patch-elf/src/dynamic.rs b/crates/sel4-patch-elf/src/dynamic.rs index ebea9fe7b..3fdea9e5d 100644 --- a/crates/sel4-patch-elf/src/dynamic.rs +++ b/crates/sel4-patch-elf/src/dynamic.rs @@ -4,8 +4,14 @@ // SPDX-License-Identifier: BSD-2-Clause // -use object::elf::{FileHeader32, FileHeader64}; -use object::{Endianness, File}; +use object::{ + Endianness, + File, + elf::{ + FileHeader32, + FileHeader64, + }, +}; use super as low_level; diff --git a/crates/sel4-patch-elf/src/lib.rs b/crates/sel4-patch-elf/src/lib.rs index d5a0ed587..71ff15b68 100644 --- a/crates/sel4-patch-elf/src/lib.rs +++ b/crates/sel4-patch-elf/src/lib.rs @@ -4,14 +4,35 @@ // SPDX-License-Identifier: BSD-2-Clause // -use std::fmt; -use std::ops::Range; +use std::{ + fmt, + ops::Range, +}; -use object::elf::{ - FileHeader32, FileHeader64, PF_R, PT_LOAD, PT_PHDR, ProgramHeader32, ProgramHeader64, +use object::{ + Endian, + Object as _, + ObjectSegment as _, + ObjectSymbol as _, + Pod, + U32, + U64, + elf::{ + FileHeader32, + FileHeader64, + PF_R, + PT_LOAD, + PT_PHDR, + ProgramHeader32, + ProgramHeader64, + }, + pod, + read::elf::{ + ElfFile, + FileHeader, + ProgramHeader, + }, }; -use object::read::elf::{ElfFile, FileHeader, ProgramHeader}; -use object::{Endian, Object as _, ObjectSegment as _, ObjectSymbol as _, Pod, U32, U64, pod}; pub mod dynamic; diff --git a/crates/sel4-phdrs/patched/src/lib.rs b/crates/sel4-phdrs/patched/src/lib.rs index 7d124fee8..bddf4f8af 100644 --- a/crates/sel4-phdrs/patched/src/lib.rs +++ b/crates/sel4-phdrs/patched/src/lib.rs @@ -6,10 +6,16 @@ #![no_std] -use core::error::Error; -use core::fmt; - -use sel4_phdrs::{ProgramHeader, ProgramHeaders, register_locate_phdrs}; +use core::{ + error::Error, + fmt, +}; + +use sel4_phdrs::{ + ProgramHeader, + ProgramHeaders, + register_locate_phdrs, +}; use sel4_rodata_static::rodata_static; register_locate_phdrs!(locate_patched_phdrs); diff --git a/crates/sel4-phdrs/src/lib.rs b/crates/sel4-phdrs/src/lib.rs index 7a1036454..49fe1a8ad 100644 --- a/crates/sel4-phdrs/src/lib.rs +++ b/crates/sel4-phdrs/src/lib.rs @@ -7,10 +7,12 @@ #![no_std] #![feature(linkage)] -use core::error::Error; -use core::fmt; -use core::ops::Range; -use core::slice; +use core::{ + error::Error, + fmt, + ops::Range, + slice, +}; pub use sel4_phdrs_constants::*; diff --git a/crates/sel4-platform-info/build.rs b/crates/sel4-platform-info/build.rs index 4fbbe4967..14dd19980 100644 --- a/crates/sel4-platform-info/build.rs +++ b/crates/sel4-platform-info/build.rs @@ -4,10 +4,12 @@ // SPDX-License-Identifier: BSD-2-Clause // -use std::env; -use std::fs; -use std::ops::Range; -use std::path::PathBuf; +use std::{ + env, + fs, + ops::Range, + path::PathBuf, +}; use proc_macro2::TokenStream; use quote::quote; diff --git a/crates/sel4-platform-info/types/src/lib.rs b/crates/sel4-platform-info/types/src/lib.rs index a90be3bed..39516978a 100644 --- a/crates/sel4-platform-info/types/src/lib.rs +++ b/crates/sel4-platform-info/types/src/lib.rs @@ -15,7 +15,10 @@ use core::ops::Range; use alloc::vec::Vec; #[cfg(feature = "owned")] -use serde::{Deserialize, Serialize}; +use serde::{ + Deserialize, + Serialize, +}; #[derive(Debug, Clone)] pub struct PlatformInfo<'a> { diff --git a/crates/sel4-reset/cli/src/main.rs b/crates/sel4-reset/cli/src/main.rs index 1eaa6d515..421532192 100644 --- a/crates/sel4-reset/cli/src/main.rs +++ b/crates/sel4-reset/cli/src/main.rs @@ -4,17 +4,37 @@ // SPDX-License-Identifier: BSD-2-Clause // -use std::fs; -use std::path::PathBuf; +use std::{ + fs, + path::PathBuf, +}; use anyhow::Error; use clap::Parser; -use object::elf::{PF_R, PF_W, PT_LOAD}; -use object::read::elf::{ElfFile, FileHeader, ProgramHeader}; -use object::{File, Object, ObjectSection, Pod, pod}; +use object::{ + File, + Object, + ObjectSection, + Pod, + elf::{ + PF_R, + PF_W, + PT_LOAD, + }, + pod, + read::elf::{ + ElfFile, + FileHeader, + ProgramHeader, + }, +}; use rangemap::RangeSet; -use sel4_patch_elf::{FileHeaderExt, GenericProgramHeader, Patching}; +use sel4_patch_elf::{ + FileHeaderExt, + GenericProgramHeader, + Patching, +}; use sel4_phdrs_constants::PT_SEL4_RESET_REGIONS; #[derive(Parser, Debug)] diff --git a/crates/sel4-reset/src/lib.rs b/crates/sel4-reset/src/lib.rs index 79c2d1061..b73756a25 100644 --- a/crates/sel4-reset/src/lib.rs +++ b/crates/sel4-reset/src/lib.rs @@ -6,12 +6,20 @@ #![no_std] -use core::arch::global_asm; -use core::slice; +use core::{ + arch::global_asm, + slice, +}; use sel4_panicking_env::abort; -use sel4_phdrs::{PT_SEL4_RESET_REGIONS, locate_phdrs}; -use sel4_stack::{Stack, StackBottom}; +use sel4_phdrs::{ + PT_SEL4_RESET_REGIONS, + locate_phdrs, +}; +use sel4_stack::{ + Stack, + StackBottom, +}; use sel4_phdrs_patched as _; diff --git a/crates/sel4-rodata-static/src/lib.rs b/crates/sel4-rodata-static/src/lib.rs index 38931bf64..2be2d649b 100644 --- a/crates/sel4-rodata-static/src/lib.rs +++ b/crates/sel4-rodata-static/src/lib.rs @@ -35,6 +35,11 @@ macro_rules! rodata_static { #[doc(hidden)] pub mod _private { - pub use core::arch::global_asm; - pub use core::mem::{align_of, size_of}; + pub use core::{ + arch::global_asm, + mem::{ + align_of, + size_of, + }, + }; } diff --git a/crates/sel4-root-task/src/entry.rs b/crates/sel4-root-task/src/entry.rs index 5da523360..e81ddab5e 100644 --- a/crates/sel4-root-task/src/entry.rs +++ b/crates/sel4-root-task/src/entry.rs @@ -6,7 +6,11 @@ use core::panic::UnwindSafe; -use crate::{Termination, abort, panicking::catch_unwind}; +use crate::{ + Termination, + abort, + panicking::catch_unwind, +}; sel4_runtime_common::declare_entrypoint_with_stack_init!(); diff --git a/crates/sel4-root-task/src/heap.rs b/crates/sel4-root-task/src/heap.rs index 6391192b0..2c58447cf 100644 --- a/crates/sel4-root-task/src/heap.rs +++ b/crates/sel4-root-task/src/heap.rs @@ -56,7 +56,10 @@ macro_rules! declare_heap { } pub mod _private { - pub use sel4_dlmalloc::{StaticDlmalloc, StaticHeap}; + pub use sel4_dlmalloc::{ + StaticDlmalloc, + StaticHeap, + }; pub use sel4_sync::RawLazyNotificationMutex; pub use super::get_global_allocator_mutex_notification; diff --git a/crates/sel4-root-task/src/lib.rs b/crates/sel4-root-task/src/lib.rs index eaec5de07..012e68416 100644 --- a/crates/sel4-root-task/src/lib.rs +++ b/crates/sel4-root-task/src/lib.rs @@ -43,10 +43,16 @@ mod printing; mod termination; pub use heap::set_global_allocator_mutex_notification; -pub use termination::{Never, Termination}; +pub use termination::{ + Never, + Termination, +}; #[sel4::sel4_cfg(PRINTING)] -pub use printing::{debug_print, debug_println}; +pub use printing::{ + debug_print, + debug_println, +}; /// Declares a function to be the root task's main function. /// @@ -133,6 +139,10 @@ pub mod _private { pub use crate::heap::_private as heap; pub use crate::{ - DEFAULT_STACK_SIZE, declare_heap, declare_main, declare_root_task, entry::run_main, + DEFAULT_STACK_SIZE, + declare_heap, + declare_main, + declare_root_task, + entry::run_main, }; } diff --git a/crates/sel4-runtime-common/src/lib.rs b/crates/sel4-runtime-common/src/lib.rs index 141fd2cad..c303ece52 100644 --- a/crates/sel4-runtime-common/src/lib.rs +++ b/crates/sel4-runtime-common/src/lib.rs @@ -11,7 +11,10 @@ #![feature(linkage)] #![allow(internal_features)] -use core::sync::atomic::{AtomicBool, Ordering}; +use core::sync::atomic::{ + AtomicBool, + Ordering, +}; use sel4_panicking_env::abort; @@ -117,5 +120,8 @@ pub mod _private { pub use super::_run_entrypoint; pub use cfg_if::cfg_if; pub use core::arch::global_asm; - pub use sel4_stack::{Stack, StackBottom}; + pub use sel4_stack::{ + Stack, + StackBottom, + }; } diff --git a/crates/sel4-runtime-common/src/tls.rs b/crates/sel4-runtime-common/src/tls.rs index 97b912d8f..7bb141eb9 100644 --- a/crates/sel4-runtime-common/src/tls.rs +++ b/crates/sel4-runtime-common/src/tls.rs @@ -7,11 +7,17 @@ use cfg_if::cfg_if; use sel4_panicking_env::abort; -use sel4_phdrs::PT_TLS; -use sel4_phdrs::locate_phdrs; +use sel4_phdrs::{ + PT_TLS, + locate_phdrs, +}; #[allow(unused_imports)] -use sel4_initialize_tls::{DEFAULT_SET_THREAD_POINTER_FN, SetThreadPointerFn, UncheckedTlsImage}; +use sel4_initialize_tls::{ + DEFAULT_SET_THREAD_POINTER_FN, + SetThreadPointerFn, + UncheckedTlsImage, +}; #[allow(clippy::missing_safety_doc)] pub(crate) unsafe fn with_tls(f: impl FnOnce() -> !) -> ! { diff --git a/crates/sel4-runtime-common/src/unwinding.rs b/crates/sel4-runtime-common/src/unwinding.rs index f48d6c332..40d6cbf19 100644 --- a/crates/sel4-runtime-common/src/unwinding.rs +++ b/crates/sel4-runtime-common/src/unwinding.rs @@ -7,10 +7,17 @@ use sel4_panicking_env::abort; use unwinding::custom_eh_frame_finder::{ - EhFrameFinder, FrameInfo, FrameInfoKind, set_custom_eh_frame_finder, + EhFrameFinder, + FrameInfo, + FrameInfoKind, + set_custom_eh_frame_finder, }; -use sel4_phdrs::{PT_GNU_EH_FRAME, PT_LOAD, locate_phdrs}; +use sel4_phdrs::{ + PT_GNU_EH_FRAME, + PT_LOAD, + locate_phdrs, +}; struct EhFrameFinderImpl; diff --git a/crates/sel4-shared-memory/src/atomic_ops/mod.rs b/crates/sel4-shared-memory/src/atomic_ops/mod.rs index 87ff9d6ef..d65d802de 100644 --- a/crates/sel4-shared-memory/src/atomic_ops/mod.rs +++ b/crates/sel4-shared-memory/src/atomic_ops/mod.rs @@ -4,10 +4,16 @@ // SPDX-License-Identifier: MIT OR Apache-2.0 // -use core::sync::atomic::{self, Ordering}; +use core::sync::atomic::{ + self, + Ordering, +}; use aligned::Aligned; -use zerocopy::{FromBytes, IntoBytes}; +use zerocopy::{ + FromBytes, + IntoBytes, +}; use sel4_abstract_ptr::memory_type::AtomicOps; diff --git a/crates/sel4-shared-memory/src/lib.rs b/crates/sel4-shared-memory/src/lib.rs index 2aed4ad6c..32d6d753e 100644 --- a/crates/sel4-shared-memory/src/lib.rs +++ b/crates/sel4-shared-memory/src/lib.rs @@ -9,9 +9,17 @@ #![cfg_attr(feature = "atomics", feature(core_intrinsics))] #![cfg_attr(feature = "atomics", allow(internal_features))] -use sel4_abstract_ptr::{AbstractPtr, AbstractRef, access::ReadWrite, memory_type::MemoryType}; - -pub use sel4_abstract_ptr::{access, map_field}; +use sel4_abstract_ptr::{ + AbstractPtr, + AbstractRef, + access::ReadWrite, + memory_type::MemoryType, +}; + +pub use sel4_abstract_ptr::{ + access, + map_field, +}; mod ops; diff --git a/crates/sel4-shared-memory/src/ops.rs b/crates/sel4-shared-memory/src/ops.rs index 5f79901c8..962f23b53 100644 --- a/crates/sel4-shared-memory/src/ops.rs +++ b/crates/sel4-shared-memory/src/ops.rs @@ -6,9 +6,15 @@ use core::ptr; -use zerocopy::{FromBytes, IntoBytes}; - -use sel4_abstract_ptr::memory_type::{BulkOps, UnitaryOps}; +use zerocopy::{ + FromBytes, + IntoBytes, +}; + +use sel4_abstract_ptr::memory_type::{ + BulkOps, + UnitaryOps, +}; use crate::SharedMemory; diff --git a/crates/sel4-sync/src/lib.rs b/crates/sel4-sync/src/lib.rs index cc63dd4a0..04c6d8c95 100644 --- a/crates/sel4-sync/src/lib.rs +++ b/crates/sel4-sync/src/lib.rs @@ -10,4 +10,8 @@ pub use lock_api; mod mutex; -pub use mutex::{RawDeferredNotificationMutex, RawLazyNotificationMutex, RawNotificationMutex}; +pub use mutex::{ + RawDeferredNotificationMutex, + RawLazyNotificationMutex, + RawNotificationMutex, +}; diff --git a/crates/sel4-sync/src/mutex.rs b/crates/sel4-sync/src/mutex.rs index 34b915860..ed7f5857f 100644 --- a/crates/sel4-sync/src/mutex.rs +++ b/crates/sel4-sync/src/mutex.rs @@ -5,8 +5,14 @@ // SPDX-License-Identifier: MIT // -use core::marker::PhantomData; -use core::sync::atomic::{AtomicIsize, Ordering, fence}; +use core::{ + marker::PhantomData, + sync::atomic::{ + AtomicIsize, + Ordering, + fence, + }, +}; use sel4_immediate_sync_once_cell::ImmediateSyncOnceCell; diff --git a/crates/sel4/bitfield-ops/src/lib.rs b/crates/sel4/bitfield-ops/src/lib.rs index e8ceb6d87..5798d9247 100644 --- a/crates/sel4/bitfield-ops/src/lib.rs +++ b/crates/sel4/bitfield-ops/src/lib.rs @@ -6,9 +6,20 @@ #![no_std] -use core::marker::PhantomData; -use core::mem; -use core::ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign, Not, Range, Shl, Shr}; +use core::{ + marker::PhantomData, + mem, + ops::{ + BitAnd, + BitAndAssign, + BitOr, + BitOrAssign, + Not, + Range, + Shl, + Shr, + }, +}; pub trait UnsignedPrimInt: UnsignedPrimIntSealed @@ -56,7 +67,10 @@ where } } -use sealing::{PrimIntSealed, UnsignedPrimIntSealed}; +use sealing::{ + PrimIntSealed, + UnsignedPrimIntSealed, +}; mod sealing { pub trait UnsignedPrimIntSealed {} @@ -358,8 +372,10 @@ mod test { extern crate std; - use std::eprintln; - use std::fmt; + use std::{ + eprintln, + fmt, + }; use super::*; diff --git a/crates/sel4/build-env/src/lib.rs b/crates/sel4/build-env/src/lib.rs index db16377cf..4eebf86a7 100644 --- a/crates/sel4/build-env/src/lib.rs +++ b/crates/sel4/build-env/src/lib.rs @@ -4,8 +4,16 @@ // SPDX-License-Identifier: BSD-2-Clause // -use std::env::{self, VarError}; -use std::path::{Path, PathBuf}; +use std::{ + env::{ + self, + VarError, + }, + path::{ + Path, + PathBuf, + }, +}; pub const SEL4_PREFIX_ENV: &str = "SEL4_PREFIX"; diff --git a/crates/sel4/config/build.rs b/crates/sel4/config/build.rs index 04ca8dcfd..442457b41 100644 --- a/crates/sel4/config/build.rs +++ b/crates/sel4/config/build.rs @@ -4,15 +4,23 @@ // SPDX-License-Identifier: BSD-2-Clause // -use std::env; -use std::fs; -use std::path::PathBuf; +use std::{ + env, + fs, + path::PathBuf, +}; use proc_macro2::TokenStream; -use quote::{format_ident, quote}; +use quote::{ + format_ident, + quote, +}; use sel4_config_data::get_kernel_config; -use sel4_config_types::{Configuration, Value}; +use sel4_config_types::{ + Configuration, + Value, +}; fn main() { let toks = generate_consts(get_kernel_config()); diff --git a/crates/sel4/config/data/build.rs b/crates/sel4/config/data/build.rs index 70e974610..0ad7a7e6f 100644 --- a/crates/sel4/config/data/build.rs +++ b/crates/sel4/config/data/build.rs @@ -4,9 +4,14 @@ // SPDX-License-Identifier: BSD-2-Clause // -use std::env; -use std::fs::File; -use std::path::{Path, PathBuf}; +use std::{ + env, + fs::File, + path::{ + Path, + PathBuf, + }, +}; use sel4_build_env::find_in_libsel4_include_dirs; use sel4_config_types::Configuration; diff --git a/crates/sel4/config/macros/src/generic/attr_macros.rs b/crates/sel4/config/macros/src/generic/attr_macros.rs index e766a7be3..1b1b367f7 100644 --- a/crates/sel4/config/macros/src/generic/attr_macros.rs +++ b/crates/sel4/config/macros/src/generic/attr_macros.rs @@ -5,10 +5,22 @@ // use proc_macro2::TokenStream; -use quote::{ToTokens, quote, quote_spanned}; -use syn::{Token, parse2, spanned::Spanned}; - -use super::{Condition, MacroImpls, parse_or_return}; +use quote::{ + ToTokens, + quote, + quote_spanned, +}; +use syn::{ + Token, + parse2, + spanned::Spanned, +}; + +use super::{ + Condition, + MacroImpls, + parse_or_return, +}; macro_rules! ensure_empty { ($tokenstream:ident) => { diff --git a/crates/sel4/config/macros/src/generic/cfg_if.rs b/crates/sel4/config/macros/src/generic/cfg_if.rs index d7f8f0b88..ea7e9f673 100644 --- a/crates/sel4/config/macros/src/generic/cfg_if.rs +++ b/crates/sel4/config/macros/src/generic/cfg_if.rs @@ -8,11 +8,17 @@ use proc_macro2::TokenStream; use quote::quote; use syn::{ Token, - parse::{ParseStream, Parser}, + parse::{ + ParseStream, + Parser, + }, spanned::Spanned, }; -use super::{Condition, MacroImpls}; +use super::{ + Condition, + MacroImpls, +}; impl MacroImpls<'_> { pub fn cfg_if_impl(&self, toks: TokenStream) -> TokenStream { diff --git a/crates/sel4/config/macros/src/generic/condition.rs b/crates/sel4/config/macros/src/generic/condition.rs index 797853362..6bc36d1aa 100644 --- a/crates/sel4/config/macros/src/generic/condition.rs +++ b/crates/sel4/config/macros/src/generic/condition.rs @@ -5,13 +5,26 @@ // use fallible_iterator::FallibleIterator; -use proc_macro2::{Span, TokenStream}; +use proc_macro2::{ + Span, + TokenStream, +}; use quote::quote_spanned; -use syn::Token; -use syn::parse::{Parse, ParseStream, Parser, Result as ParseResult}; -use syn::spanned::Spanned; +use syn::{ + Token, + parse::{ + Parse, + ParseStream, + Parser, + Result as ParseResult, + }, + spanned::Spanned, +}; -use sel4_config_types::{Configuration, Value}; +use sel4_config_types::{ + Configuration, + Value, +}; pub(crate) enum Condition { Key(syn::Ident), diff --git a/crates/sel4/config/macros/src/generic/expr_macros.rs b/crates/sel4/config/macros/src/generic/expr_macros.rs index bd0fb1531..8ca9006f0 100644 --- a/crates/sel4/config/macros/src/generic/expr_macros.rs +++ b/crates/sel4/config/macros/src/generic/expr_macros.rs @@ -4,18 +4,33 @@ // SPDX-License-Identifier: BSD-2-Clause // -use std::any; -use std::fmt::Debug; -use std::marker::PhantomData; -use std::str::FromStr; +use std::{ + any, + fmt::Debug, + marker::PhantomData, + str::FromStr, +}; use proc_macro2::TokenStream; -use quote::{ToTokens, quote, quote_spanned}; -use syn::{parse2, spanned::Spanned}; +use quote::{ + ToTokens, + quote, + quote_spanned, +}; +use syn::{ + parse2, + spanned::Spanned, +}; -use sel4_config_types::{Key, Value}; +use sel4_config_types::{ + Key, + Value, +}; -use super::{MacroImpls, parse_or_return}; +use super::{ + MacroImpls, + parse_or_return, +}; impl MacroImpls<'_> { pub fn cfg_generic_impl( diff --git a/crates/sel4/config/macros/src/generic/mod.rs b/crates/sel4/config/macros/src/generic/mod.rs index fd27eb69c..14e8fa13e 100644 --- a/crates/sel4/config/macros/src/generic/mod.rs +++ b/crates/sel4/config/macros/src/generic/mod.rs @@ -13,7 +13,10 @@ mod condition; mod expr_macros; use common_helpers::parse_or_return; -use condition::{Condition, EvalError}; +use condition::{ + Condition, + EvalError, +}; pub struct MacroImpls<'a> { config: &'a Configuration, diff --git a/crates/sel4/config/types/src/lib.rs b/crates/sel4/config/types/src/lib.rs index 32bff5337..62d083e43 100644 --- a/crates/sel4/config/types/src/lib.rs +++ b/crates/sel4/config/types/src/lib.rs @@ -8,11 +8,16 @@ extern crate alloc; -use alloc::collections::BTreeMap; -use alloc::string::String; +use alloc::{ + collections::BTreeMap, + string::String, +}; #[cfg(feature = "serde")] -use serde::{Deserialize, Serialize}; +use serde::{ + Deserialize, + Serialize, +}; #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] diff --git a/crates/sel4/src/arch/arm/arch/aarch32/fault.rs b/crates/sel4/src/arch/arm/arch/aarch32/fault.rs index 4d5318d35..8a0dbeb65 100644 --- a/crates/sel4/src/arch/arm/arch/aarch32/fault.rs +++ b/crates/sel4/src/arch/arm/arch/aarch32/fault.rs @@ -4,7 +4,10 @@ // SPDX-License-Identifier: MIT // -use crate::{UnknownSyscall, Word}; +use crate::{ + UnknownSyscall, + Word, +}; impl UnknownSyscall { pub fn cpsr(&self) -> Word { diff --git a/crates/sel4/src/arch/arm/arch/aarch32/mod.rs b/crates/sel4/src/arch/arm/arch/aarch32/mod.rs index 1345dfe18..ca05115b2 100644 --- a/crates/sel4/src/arch/arm/arch/aarch32/mod.rs +++ b/crates/sel4/src/arch/arm/arch/aarch32/mod.rs @@ -21,7 +21,10 @@ mod vcpu_reg; pub(crate) mod top_level { pub use super::{ object::{ - ObjectBlueprintAArch32, ObjectBlueprintSeL4Arch, ObjectTypeAArch32, ObjectTypeSeL4Arch, + ObjectBlueprintAArch32, + ObjectBlueprintSeL4Arch, + ObjectTypeAArch32, + ObjectTypeSeL4Arch, }, user_context::UserContext, }; diff --git a/crates/sel4/src/arch/arm/arch/aarch32/object.rs b/crates/sel4/src/arch/arm/arch/aarch32/object.rs index 7e766b6a2..1ec07b494 100644 --- a/crates/sel4/src/arch/arm/arch/aarch32/object.rs +++ b/crates/sel4/src/arch/arm/arch/aarch32/object.rs @@ -6,7 +6,10 @@ use core::ffi::c_uint; -use crate::{const_helpers::u32_into_usize, sys}; +use crate::{ + const_helpers::u32_into_usize, + sys, +}; /// Alias for [`ObjectTypeAArch32`]. pub type ObjectTypeSeL4Arch = ObjectTypeAArch32; diff --git a/crates/sel4/src/arch/arm/arch/aarch32/user_context.rs b/crates/sel4/src/arch/arm/arch/aarch32/user_context.rs index acdba1304..4db1b0eea 100644 --- a/crates/sel4/src/arch/arm/arch/aarch32/user_context.rs +++ b/crates/sel4/src/arch/arm/arch/aarch32/user_context.rs @@ -4,7 +4,11 @@ // SPDX-License-Identifier: MIT // -use crate::{Word, newtype_methods, sys}; +use crate::{ + Word, + newtype_methods, + sys, +}; /// Corresponds to `seL4_UserContext`. #[derive(Debug, Clone, PartialEq, Eq, Default)] diff --git a/crates/sel4/src/arch/arm/arch/aarch64/fault.rs b/crates/sel4/src/arch/arm/arch/aarch64/fault.rs index 435f5041a..eae379832 100644 --- a/crates/sel4/src/arch/arm/arch/aarch64/fault.rs +++ b/crates/sel4/src/arch/arm/arch/aarch64/fault.rs @@ -4,7 +4,10 @@ // SPDX-License-Identifier: MIT // -use crate::{UnknownSyscall, Word}; +use crate::{ + UnknownSyscall, + Word, +}; impl UnknownSyscall { pub fn spsr(&self) -> Word { diff --git a/crates/sel4/src/arch/arm/arch/aarch64/mod.rs b/crates/sel4/src/arch/arm/arch/aarch64/mod.rs index 40dc5583f..92892ce10 100644 --- a/crates/sel4/src/arch/arm/arch/aarch64/mod.rs +++ b/crates/sel4/src/arch/arm/arch/aarch64/mod.rs @@ -21,7 +21,10 @@ mod vcpu_reg; pub(crate) mod top_level { pub use super::{ object::{ - ObjectBlueprintAArch64, ObjectBlueprintSeL4Arch, ObjectTypeAArch64, ObjectTypeSeL4Arch, + ObjectBlueprintAArch64, + ObjectBlueprintSeL4Arch, + ObjectTypeAArch64, + ObjectTypeSeL4Arch, }, user_context::UserContext, }; diff --git a/crates/sel4/src/arch/arm/arch/aarch64/object.rs b/crates/sel4/src/arch/arm/arch/aarch64/object.rs index ffa7923e0..6c274bd6e 100644 --- a/crates/sel4/src/arch/arm/arch/aarch64/object.rs +++ b/crates/sel4/src/arch/arm/arch/aarch64/object.rs @@ -6,7 +6,10 @@ use core::ffi::c_uint; -use crate::{const_helpers::u32_into_usize, sys}; +use crate::{ + const_helpers::u32_into_usize, + sys, +}; /// Alias for [`ObjectTypeAArch64`]. pub type ObjectTypeSeL4Arch = ObjectTypeAArch64; diff --git a/crates/sel4/src/arch/arm/arch/aarch64/user_context.rs b/crates/sel4/src/arch/arm/arch/aarch64/user_context.rs index 7429b790a..2c15be131 100644 --- a/crates/sel4/src/arch/arm/arch/aarch64/user_context.rs +++ b/crates/sel4/src/arch/arm/arch/aarch64/user_context.rs @@ -5,7 +5,11 @@ // SPDX-License-Identifier: MIT // -use crate::{Word, newtype_methods, sys}; +use crate::{ + Word, + newtype_methods, + sys, +}; /// Corresponds to `seL4_UserContext`. #[derive(Debug, Clone, PartialEq, Eq, Default)] diff --git a/crates/sel4/src/arch/arm/fault.rs b/crates/sel4/src/arch/arm/fault.rs index 040bb4cd1..7436a63de 100644 --- a/crates/sel4/src/arch/arm/fault.rs +++ b/crates/sel4/src/arch/arm/fault.rs @@ -5,9 +5,18 @@ // SPDX-License-Identifier: MIT // -use sel4_config::{sel4_cfg, sel4_cfg_enum, sel4_cfg_if, sel4_cfg_wrap_match}; - -use crate::{Word, declare_fault_newtype, sys}; +use sel4_config::{ + sel4_cfg, + sel4_cfg_enum, + sel4_cfg_if, + sel4_cfg_wrap_match, +}; + +use crate::{ + Word, + declare_fault_newtype, + sys, +}; declare_fault_newtype!(NullFault, seL4_Fault_NullFault); declare_fault_newtype!(CapFault, seL4_Fault_CapFault); diff --git a/crates/sel4/src/arch/arm/invocations.rs b/crates/sel4/src/arch/arm/invocations.rs index b037fd4b8..ce72f225f 100644 --- a/crates/sel4/src/arch/arm/invocations.rs +++ b/crates/sel4/src/arch/arm/invocations.rs @@ -7,8 +7,18 @@ use sel4_config::sel4_cfg; use crate::{ - AbsoluteCPtr, Cap, CapRights, CapTypeForFrameObject, Error, InvocationContext, Result, - TranslationTableObjectType, VmAttributes, Word, cap::*, cap_type, + AbsoluteCPtr, + Cap, + CapRights, + CapTypeForFrameObject, + Error, + InvocationContext, + Result, + TranslationTableObjectType, + VmAttributes, + Word, + cap::*, + cap_type, }; #[sel4_cfg(ARM_HYPERVISOR_SUPPORT)] diff --git a/crates/sel4/src/arch/arm/mod.rs b/crates/sel4/src/arch/arm/mod.rs index 9d341dc47..bff7c4283 100644 --- a/crates/sel4/src/arch/arm/mod.rs +++ b/crates/sel4/src/arch/arm/mod.rs @@ -4,7 +4,10 @@ // SPDX-License-Identifier: MIT // -use crate::{const_helpers::u32_into_usize, sys}; +use crate::{ + const_helpers::u32_into_usize, + sys, +}; mod arch; mod invocations; @@ -18,9 +21,17 @@ pub(crate) mod top_level { pub use super::{ NUM_FAST_MESSAGE_REGISTERS, arch::top_level::*, - object::{ObjectBlueprintArch, ObjectBlueprintArm, ObjectTypeArch, ObjectTypeArm}, + object::{ + ObjectBlueprintArch, + ObjectBlueprintArm, + ObjectTypeArch, + ObjectTypeArm, + }, vm_attributes::VmAttributes, - vspace::{FrameObjectType, TranslationTableObjectType}, + vspace::{ + FrameObjectType, + TranslationTableObjectType, + }, }; } @@ -30,7 +41,10 @@ pub(crate) use vspace::vspace_levels; pub const NUM_FAST_MESSAGE_REGISTERS: usize = u32_into_usize(sys::seL4_FastMessageRegisters); pub(crate) mod cap_type_arch { - use crate::{declare_cap_type_for_object_of_fixed_size, sel4_cfg}; + use crate::{ + declare_cap_type_for_object_of_fixed_size, + sel4_cfg, + }; #[sel4_cfg(ARM_HYPERVISOR_SUPPORT)] declare_cap_type_for_object_of_fixed_size! { @@ -86,7 +100,10 @@ pub(crate) mod cap_type_arch { } pub(crate) mod cap_arch { - use crate::{declare_cap_alias, sel4_cfg}; + use crate::{ + declare_cap_alias, + sel4_cfg, + }; #[sel4_cfg(ARM_HYPERVISOR_SUPPORT)] declare_cap_alias!(VCpu); diff --git a/crates/sel4/src/arch/arm/object.rs b/crates/sel4/src/arch/arm/object.rs index 9069997dc..b3acc9e5a 100644 --- a/crates/sel4/src/arch/arm/object.rs +++ b/crates/sel4/src/arch/arm/object.rs @@ -7,11 +7,18 @@ use core::ffi::c_uint; -use sel4_config::{sel4_cfg_enum, sel4_cfg_wrap_match}; +use sel4_config::{ + sel4_cfg_enum, + sel4_cfg_wrap_match, +}; use crate::{ - ObjectBlueprint, ObjectBlueprintSeL4Arch, ObjectType, ObjectTypeSeL4Arch, - const_helpers::u32_into_usize, sys, + ObjectBlueprint, + ObjectBlueprintSeL4Arch, + ObjectType, + ObjectTypeSeL4Arch, + const_helpers::u32_into_usize, + sys, }; /// Alias for [`ObjectTypeArm`]. diff --git a/crates/sel4/src/arch/arm/vm_attributes.rs b/crates/sel4/src/arch/arm/vm_attributes.rs index 7f99115c3..6042bbbe2 100644 --- a/crates/sel4/src/arch/arm/vm_attributes.rs +++ b/crates/sel4/src/arch/arm/vm_attributes.rs @@ -4,9 +4,18 @@ // SPDX-License-Identifier: MIT // -use core::ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign, Not}; +use core::ops::{ + BitAnd, + BitAndAssign, + BitOr, + BitOrAssign, + Not, +}; -use crate::{newtype_methods, sys}; +use crate::{ + newtype_methods, + sys, +}; /// Corresponds to `seL4_ARM_VMAttributes`. #[derive(Debug, Copy, Clone, PartialEq, Eq)] diff --git a/crates/sel4/src/arch/arm/vspace.rs b/crates/sel4/src/arch/arm/vspace.rs index 13cd086ee..b9ab70d8d 100644 --- a/crates/sel4/src/arch/arm/vspace.rs +++ b/crates/sel4/src/arch/arm/vspace.rs @@ -4,11 +4,21 @@ // SPDX-License-Identifier: MIT // -use sel4_config::{sel4_cfg, sel4_cfg_enum, sel4_cfg_wrap_match}; +use sel4_config::{ + sel4_cfg, + sel4_cfg_enum, + sel4_cfg_wrap_match, +}; use crate::{ - CapTypeForFrameObject, CapTypeForFrameObjectOfFixedSize, CapTypeForTranslationTableObject, - ObjectBlueprint, ObjectBlueprintArm, cap_type, const_helpers::u32_into_usize, sys, + CapTypeForFrameObject, + CapTypeForFrameObjectOfFixedSize, + CapTypeForTranslationTableObject, + ObjectBlueprint, + ObjectBlueprintArm, + cap_type, + const_helpers::u32_into_usize, + sys, }; #[sel4_cfg(ARCH_AARCH64)] diff --git a/crates/sel4/src/arch/riscv/fault.rs b/crates/sel4/src/arch/riscv/fault.rs index e964334df..dd70fb9ba 100644 --- a/crates/sel4/src/arch/riscv/fault.rs +++ b/crates/sel4/src/arch/riscv/fault.rs @@ -4,9 +4,16 @@ // SPDX-License-Identifier: MIT // -use sel4_config::{sel4_cfg, sel4_cfg_enum, sel4_cfg_wrap_match}; +use sel4_config::{ + sel4_cfg, + sel4_cfg_enum, + sel4_cfg_wrap_match, +}; -use crate::{declare_fault_newtype, sys}; +use crate::{ + declare_fault_newtype, + sys, +}; declare_fault_newtype!(NullFault, seL4_Fault_NullFault); declare_fault_newtype!(CapFault, seL4_Fault_CapFault); diff --git a/crates/sel4/src/arch/riscv/invocations.rs b/crates/sel4/src/arch/riscv/invocations.rs index 5017aa4ff..4d09c1fe5 100644 --- a/crates/sel4/src/arch/riscv/invocations.rs +++ b/crates/sel4/src/arch/riscv/invocations.rs @@ -5,8 +5,18 @@ // use crate::{ - AbsoluteCPtr, Cap, CapRights, CapTypeForFrameObject, Error, InvocationContext, Result, - TranslationTableObjectType, VmAttributes, Word, cap::*, cap_type, + AbsoluteCPtr, + Cap, + CapRights, + CapTypeForFrameObject, + Error, + InvocationContext, + Result, + TranslationTableObjectType, + VmAttributes, + Word, + cap::*, + cap_type, }; impl Cap { diff --git a/crates/sel4/src/arch/riscv/mod.rs b/crates/sel4/src/arch/riscv/mod.rs index 160df4241..f384f1dd9 100644 --- a/crates/sel4/src/arch/riscv/mod.rs +++ b/crates/sel4/src/arch/riscv/mod.rs @@ -15,10 +15,18 @@ pub(crate) mod fault; pub(crate) mod top_level { pub use super::{ NUM_FAST_MESSAGE_REGISTERS, - object::{ObjectBlueprintArch, ObjectBlueprintRiscV, ObjectTypeArch, ObjectTypeRISCV}, + object::{ + ObjectBlueprintArch, + ObjectBlueprintRiscV, + ObjectTypeArch, + ObjectTypeRISCV, + }, user_context::UserContext, vm_attributes::VmAttributes, - vspace::{FrameObjectType, TranslationTableObjectType}, + vspace::{ + FrameObjectType, + TranslationTableObjectType, + }, }; } diff --git a/crates/sel4/src/arch/riscv/object.rs b/crates/sel4/src/arch/riscv/object.rs index beb6e1a39..410aefa64 100644 --- a/crates/sel4/src/arch/riscv/object.rs +++ b/crates/sel4/src/arch/riscv/object.rs @@ -6,9 +6,15 @@ use core::ffi::c_uint; -use sel4_config::{sel4_cfg_enum, sel4_cfg_wrap_match}; +use sel4_config::{ + sel4_cfg_enum, + sel4_cfg_wrap_match, +}; -use crate::{const_helpers::u32_into_usize, sys}; +use crate::{ + const_helpers::u32_into_usize, + sys, +}; pub type ObjectTypeArch = ObjectTypeRISCV; diff --git a/crates/sel4/src/arch/riscv/user_context.rs b/crates/sel4/src/arch/riscv/user_context.rs index 3a1393b6b..7dacf4d09 100644 --- a/crates/sel4/src/arch/riscv/user_context.rs +++ b/crates/sel4/src/arch/riscv/user_context.rs @@ -4,7 +4,11 @@ // SPDX-License-Identifier: MIT // -use crate::{Word, newtype_methods, sys}; +use crate::{ + Word, + newtype_methods, + sys, +}; /// Corresponds to `seL4_UserContext`. #[derive(Debug, Clone, PartialEq, Eq, Default)] diff --git a/crates/sel4/src/arch/riscv/vm_attributes.rs b/crates/sel4/src/arch/riscv/vm_attributes.rs index ad7c7fb28..1d0a8674f 100644 --- a/crates/sel4/src/arch/riscv/vm_attributes.rs +++ b/crates/sel4/src/arch/riscv/vm_attributes.rs @@ -4,9 +4,18 @@ // SPDX-License-Identifier: MIT // -use core::ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign, Not}; +use core::ops::{ + BitAnd, + BitAndAssign, + BitOr, + BitOrAssign, + Not, +}; -use crate::{newtype_methods, sys}; +use crate::{ + newtype_methods, + sys, +}; /// Corresponds to `seL4_RISCV_VMAttributes`. #[derive(Debug, Copy, Clone, PartialEq, Eq)] diff --git a/crates/sel4/src/arch/riscv/vspace.rs b/crates/sel4/src/arch/riscv/vspace.rs index 868b08632..6ff47bf53 100644 --- a/crates/sel4/src/arch/riscv/vspace.rs +++ b/crates/sel4/src/arch/riscv/vspace.rs @@ -10,8 +10,14 @@ use sel4_config::sel4_cfg_wrap_match; #[allow(unused_imports)] use crate::{ - CapTypeForFrameObject, CapTypeForFrameObjectOfFixedSize, CapTypeForTranslationTableObject, - ObjectBlueprint, ObjectBlueprintRiscV, cap_type, const_helpers::u32_into_usize, sys, + CapTypeForFrameObject, + CapTypeForFrameObjectOfFixedSize, + CapTypeForTranslationTableObject, + ObjectBlueprint, + ObjectBlueprintRiscV, + cap_type, + const_helpers::u32_into_usize, + sys, }; /// Frame object types for this kernel configuration. diff --git a/crates/sel4/src/arch/x86/arch/x64/mod.rs b/crates/sel4/src/arch/x86/arch/x64/mod.rs index 167a9b2b8..edd545d42 100644 --- a/crates/sel4/src/arch/x86/arch/x64/mod.rs +++ b/crates/sel4/src/arch/x86/arch/x64/mod.rs @@ -9,7 +9,12 @@ mod user_context; pub(crate) mod top_level { pub use super::{ - object::{ObjectBlueprintSeL4Arch, ObjectBlueprintX64, ObjectTypeSeL4Arch, ObjectTypeX64}, + object::{ + ObjectBlueprintSeL4Arch, + ObjectBlueprintX64, + ObjectTypeSeL4Arch, + ObjectTypeX64, + }, user_context::UserContext, }; } diff --git a/crates/sel4/src/arch/x86/arch/x64/object.rs b/crates/sel4/src/arch/x86/arch/x64/object.rs index 9645aa0d4..ab91294bc 100644 --- a/crates/sel4/src/arch/x86/arch/x64/object.rs +++ b/crates/sel4/src/arch/x86/arch/x64/object.rs @@ -6,9 +6,15 @@ use core::ffi::c_uint; -use sel4_config::{sel4_cfg_enum, sel4_cfg_wrap_match}; +use sel4_config::{ + sel4_cfg_enum, + sel4_cfg_wrap_match, +}; -use crate::{const_helpers::u32_into_usize, sys}; +use crate::{ + const_helpers::u32_into_usize, + sys, +}; pub type ObjectTypeSeL4Arch = ObjectTypeX64; diff --git a/crates/sel4/src/arch/x86/arch/x64/user_context.rs b/crates/sel4/src/arch/x86/arch/x64/user_context.rs index d81d5f64e..3b4e6ffe7 100644 --- a/crates/sel4/src/arch/x86/arch/x64/user_context.rs +++ b/crates/sel4/src/arch/x86/arch/x64/user_context.rs @@ -4,7 +4,11 @@ // SPDX-License-Identifier: MIT // -use crate::{Word, newtype_methods, sys}; +use crate::{ + Word, + newtype_methods, + sys, +}; #[derive(Debug, Clone, PartialEq, Eq, Default)] pub struct UserContext(sys::seL4_UserContext); diff --git a/crates/sel4/src/arch/x86/fault.rs b/crates/sel4/src/arch/x86/fault.rs index d7f9cbfa4..9e20f41ac 100644 --- a/crates/sel4/src/arch/x86/fault.rs +++ b/crates/sel4/src/arch/x86/fault.rs @@ -4,9 +4,16 @@ // SPDX-License-Identifier: MIT // -use sel4_config::{sel4_cfg, sel4_cfg_enum, sel4_cfg_wrap_match}; +use sel4_config::{ + sel4_cfg, + sel4_cfg_enum, + sel4_cfg_wrap_match, +}; -use crate::{declare_fault_newtype, sys}; +use crate::{ + declare_fault_newtype, + sys, +}; declare_fault_newtype!(NullFault, seL4_Fault_NullFault); declare_fault_newtype!(CapFault, seL4_Fault_CapFault); diff --git a/crates/sel4/src/arch/x86/invocations.rs b/crates/sel4/src/arch/x86/invocations.rs index 7aee95be6..8b0db08d8 100644 --- a/crates/sel4/src/arch/x86/invocations.rs +++ b/crates/sel4/src/arch/x86/invocations.rs @@ -7,8 +7,19 @@ use sel4_config::sel4_cfg; use crate::{ - AbsoluteCPtr, Cap, CapRights, CapTypeForFrameObject, Error, InvocationContext, Result, - TranslationTableObjectType, VmAttributes, Word, cap::*, cap_type, sel4_cfg_wrap_match, + AbsoluteCPtr, + Cap, + CapRights, + CapTypeForFrameObject, + Error, + InvocationContext, + Result, + TranslationTableObjectType, + VmAttributes, + Word, + cap::*, + cap_type, + sel4_cfg_wrap_match, }; #[sel4_cfg(VTX)] diff --git a/crates/sel4/src/arch/x86/mod.rs b/crates/sel4/src/arch/x86/mod.rs index 5a11e9b4c..d2523231d 100644 --- a/crates/sel4/src/arch/x86/mod.rs +++ b/crates/sel4/src/arch/x86/mod.rs @@ -4,7 +4,10 @@ // SPDX-License-Identifier: MIT // -use crate::{const_helpers::u32_into_usize, sys}; +use crate::{ + const_helpers::u32_into_usize, + sys, +}; mod arch; mod invocations; @@ -18,9 +21,17 @@ pub(crate) mod top_level { pub use super::{ NUM_FAST_MESSAGE_REGISTERS, arch::top_level::*, - object::{ObjectBlueprintArch, ObjectBlueprintX86, ObjectTypeArch, ObjectTypeX86}, + object::{ + ObjectBlueprintArch, + ObjectBlueprintX86, + ObjectTypeArch, + ObjectTypeX86, + }, vm_attributes::VmAttributes, - vspace::{FrameObjectType, TranslationTableObjectType}, + vspace::{ + FrameObjectType, + TranslationTableObjectType, + }, }; #[crate::sel4_cfg(all(ARCH_X86_64, IOMMU))] @@ -32,7 +43,11 @@ pub(crate) use vspace::vspace_levels; pub const NUM_FAST_MESSAGE_REGISTERS: usize = u32_into_usize(sys::seL4_FastMessageRegisters); pub(crate) mod cap_type_arch { - use crate::{declare_cap_type, declare_cap_type_for_object_of_fixed_size, sel4_cfg_if}; + use crate::{ + declare_cap_type, + declare_cap_type_for_object_of_fixed_size, + sel4_cfg_if, + }; sel4_cfg_if! { if #[sel4_cfg(VTX)] { @@ -115,7 +130,10 @@ pub(crate) mod cap_type_arch { } pub(crate) mod cap_arch { - use crate::{declare_cap_alias, sel4_cfg_if}; + use crate::{ + declare_cap_alias, + sel4_cfg_if, + }; sel4_cfg_if! { if #[sel4_cfg(VTX)] { diff --git a/crates/sel4/src/arch/x86/object.rs b/crates/sel4/src/arch/x86/object.rs index 167d7e7c4..5344ed899 100644 --- a/crates/sel4/src/arch/x86/object.rs +++ b/crates/sel4/src/arch/x86/object.rs @@ -6,11 +6,18 @@ use core::ffi::c_uint; -use sel4_config::{sel4_cfg_enum, sel4_cfg_wrap_match}; +use sel4_config::{ + sel4_cfg_enum, + sel4_cfg_wrap_match, +}; use crate::{ - ObjectBlueprint, ObjectBlueprintSeL4Arch, ObjectType, ObjectTypeSeL4Arch, - const_helpers::u32_into_usize, sys, + ObjectBlueprint, + ObjectBlueprintSeL4Arch, + ObjectType, + ObjectTypeSeL4Arch, + const_helpers::u32_into_usize, + sys, }; pub type ObjectTypeArch = ObjectTypeX86; diff --git a/crates/sel4/src/arch/x86/vm_attributes.rs b/crates/sel4/src/arch/x86/vm_attributes.rs index 6756d3118..8cf6936a9 100644 --- a/crates/sel4/src/arch/x86/vm_attributes.rs +++ b/crates/sel4/src/arch/x86/vm_attributes.rs @@ -4,9 +4,19 @@ // SPDX-License-Identifier: MIT // -use core::ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign, Not}; +use core::ops::{ + BitAnd, + BitAndAssign, + BitOr, + BitOrAssign, + Not, +}; -use crate::{newtype_methods, sel4_cfg_if, sys}; +use crate::{ + newtype_methods, + sel4_cfg_if, + sys, +}; /// Corresponds to `seL4_X86_VMAttributes`. #[derive(Debug, Copy, Clone, PartialEq, Eq)] diff --git a/crates/sel4/src/arch/x86/vspace.rs b/crates/sel4/src/arch/x86/vspace.rs index 4a2892268..5c7c01ea3 100644 --- a/crates/sel4/src/arch/x86/vspace.rs +++ b/crates/sel4/src/arch/x86/vspace.rs @@ -4,12 +4,23 @@ // SPDX-License-Identifier: MIT // -use sel4_config::{sel4_cfg, sel4_cfg_enum, sel4_cfg_if, sel4_cfg_wrap_match}; +use sel4_config::{ + sel4_cfg, + sel4_cfg_enum, + sel4_cfg_if, + sel4_cfg_wrap_match, +}; use crate::{ - CapTypeForFrameObject, CapTypeForFrameObjectOfFixedSize, CapTypeForTranslationTableObject, - ObjectBlueprint, ObjectBlueprintX64, ObjectBlueprintX86, cap_type, - const_helpers::u32_into_usize, sys, + CapTypeForFrameObject, + CapTypeForFrameObjectOfFixedSize, + CapTypeForTranslationTableObject, + ObjectBlueprint, + ObjectBlueprintX64, + ObjectBlueprintX86, + cap_type, + const_helpers::u32_into_usize, + sys, }; /// Frame object types for this kernel configuration. @@ -215,7 +226,10 @@ pub mod vspace_levels { #[sel4_cfg(all(ARCH_X86_64, IOMMU))] pub mod io_space { use super::sys; - use crate::{Word, newtype_methods}; + use crate::{ + Word, + newtype_methods, + }; use sel4_sys::seL4_X86_IOSpace_CapData; /// Corresponds to `seL4_IOSpace_CapData`. @@ -244,7 +258,10 @@ pub mod io_space { } pub mod levels { - use super::super::{FrameObjectType, TranslationTableObjectType}; + use super::super::{ + FrameObjectType, + TranslationTableObjectType, + }; // On x86 the leaf entries are normal frame objects, not IOMMU specific fn span_bits(num_levels: usize, level: usize) -> usize { diff --git a/crates/sel4/src/bootinfo.rs b/crates/sel4/src/bootinfo.rs index e677040a3..8cee9e77b 100644 --- a/crates/sel4/src/bootinfo.rs +++ b/crates/sel4/src/bootinfo.rs @@ -7,13 +7,25 @@ #![allow(clippy::useless_conversion)] -use core::mem; -use core::ops::{Deref, Range}; -use core::slice; +use core::{ + mem, + ops::{ + Deref, + Range, + }, + slice, +}; use sel4_config::sel4_cfg; -use crate::{FrameObjectType, IpcBuffer, cap_type, init_thread::SlotRegion, newtype_methods, sys}; +use crate::{ + FrameObjectType, + IpcBuffer, + cap_type, + init_thread::SlotRegion, + newtype_methods, + sys, +}; /// A wrapped pointer to a [`BootInfo`] block. /// diff --git a/crates/sel4/src/cap_rights.rs b/crates/sel4/src/cap_rights.rs index 5b4542897..ff0fbb41c 100644 --- a/crates/sel4/src/cap_rights.rs +++ b/crates/sel4/src/cap_rights.rs @@ -4,7 +4,10 @@ // SPDX-License-Identifier: MIT // -use crate::{newtype_methods, sys}; +use crate::{ + newtype_methods, + sys, +}; /// Corresponds to `seL4_CapRights_t`. #[derive(Debug, Clone, PartialEq, Eq)] diff --git a/crates/sel4/src/cnode_cap_data.rs b/crates/sel4/src/cnode_cap_data.rs index 11f7b294b..7dd04ec74 100644 --- a/crates/sel4/src/cnode_cap_data.rs +++ b/crates/sel4/src/cnode_cap_data.rs @@ -4,7 +4,12 @@ // SPDX-License-Identifier: MIT // -use crate::{WORD_SIZE, Word, newtype_methods, sys}; +use crate::{ + WORD_SIZE, + Word, + newtype_methods, + sys, +}; /// Corresponds to `seL4_CNode_CapData`. #[derive(Debug, Clone, PartialEq, Eq)] diff --git a/crates/sel4/src/cptr.rs b/crates/sel4/src/cptr.rs index 7a43b64a1..e5476a011 100644 --- a/crates/sel4/src/cptr.rs +++ b/crates/sel4/src/cptr.rs @@ -5,11 +5,19 @@ // SPDX-License-Identifier: MIT // -use core::fmt; -use core::hash::Hash; -use core::marker::PhantomData; - -use crate::{InvocationContext, IpcBuffer, NoExplicitInvocationContext, WORD_SIZE, sys}; +use core::{ + fmt, + hash::Hash, + marker::PhantomData, +}; + +use crate::{ + InvocationContext, + IpcBuffer, + NoExplicitInvocationContext, + WORD_SIZE, + sys, +}; /// The raw bits of a capability pointer. pub type CPtrBits = sys::seL4_CPtr; @@ -175,7 +183,8 @@ pub mod cap_type { use sel4_config::sel4_cfg_if; use crate::{ - declare_cap_type, declare_cap_type_for_object_of_fixed_size, + declare_cap_type, + declare_cap_type_for_object_of_fixed_size, declare_cap_type_for_object_of_variable_size, }; diff --git a/crates/sel4/src/error.rs b/crates/sel4/src/error.rs index 587bb9674..64742ab80 100644 --- a/crates/sel4/src/error.rs +++ b/crates/sel4/src/error.rs @@ -5,7 +5,10 @@ // SPDX-License-Identifier: MIT // -use core::{fmt, result}; +use core::{ + fmt, + result, +}; use crate::sys; diff --git a/crates/sel4/src/fault.rs b/crates/sel4/src/fault.rs index 13908c614..bbda5e678 100644 --- a/crates/sel4/src/fault.rs +++ b/crates/sel4/src/fault.rs @@ -6,7 +6,11 @@ //! Fault types. -use crate::{IpcBuffer, MessageInfo, sys}; +use crate::{ + IpcBuffer, + MessageInfo, + sys, +}; pub use crate::arch::fault::*; diff --git a/crates/sel4/src/init_thread.rs b/crates/sel4/src/init_thread.rs index 2a63a89a2..0943dcec8 100644 --- a/crates/sel4/src/init_thread.rs +++ b/crates/sel4/src/init_thread.rs @@ -6,14 +6,24 @@ //! Items that are applicable within the context of the root task's initial thread's CSpace. -use core::marker::PhantomData; -use core::ops::Range; +use core::{ + marker::PhantomData, + ops::Range, +}; use sel4_config::sel4_cfg; use crate::{ - CPtr, CPtrBits, Cap, CapType, cap_type, - const_helpers::{u32_into_usize, usize_into_word, word_into_usize}, + CPtr, + CPtrBits, + Cap, + CapType, + cap_type, + const_helpers::{ + u32_into_usize, + usize_into_word, + word_into_usize, + }, sys, }; @@ -111,7 +121,12 @@ impl SlotRegion { /// Initial CSpace slot constants corresponding to `seL4_Cap*`. pub mod slot { - use super::{Slot, cap_type, sel4_cfg, sys}; + use super::{ + Slot, + cap_type, + sel4_cfg, + sys, + }; macro_rules! mk { [ diff --git a/crates/sel4/src/invocations.rs b/crates/sel4/src/invocations.rs index a682e1711..cc62271a8 100644 --- a/crates/sel4/src/invocations.rs +++ b/crates/sel4/src/invocations.rs @@ -8,11 +8,24 @@ use core::mem; -use sel4_config::{sel4_cfg, sel4_cfg_if}; +use sel4_config::{ + sel4_cfg, + sel4_cfg_if, +}; use crate::{ - AbsoluteCPtr, CNodeCapData, CPtr, CapRights, Error, InvocationContext, ObjectBlueprint, Result, - UserContext, Word, cap::*, sys, + AbsoluteCPtr, + CNodeCapData, + CPtr, + CapRights, + Error, + InvocationContext, + ObjectBlueprint, + Result, + UserContext, + Word, + cap::*, + sys, }; #[sel4_cfg(KERNEL_MCS)] diff --git a/crates/sel4/src/ipc_buffer.rs b/crates/sel4/src/ipc_buffer.rs index aa69c4e41..cff983bc5 100644 --- a/crates/sel4/src/ipc_buffer.rs +++ b/crates/sel4/src/ipc_buffer.rs @@ -5,13 +5,25 @@ // SPDX-License-Identifier: MIT // -use core::mem; -use core::slice; +use core::{ + mem, + slice, +}; #[sel4_cfg(KERNEL_INVOCATION_REPORT_ERROR_IPC)] -use core::str::{self, Utf8Error}; - -use crate::{AbsoluteCPtr, Word, cap, newtype_methods, sel4_cfg, sys}; +use core::str::{ + self, + Utf8Error, +}; + +use crate::{ + AbsoluteCPtr, + Word, + cap, + newtype_methods, + sel4_cfg, + sys, +}; #[sel4_cfg(KERNEL_INVOCATION_REPORT_ERROR_IPC)] use crate::const_helpers::u32_into_usize; diff --git a/crates/sel4/src/lib.rs b/crates/sel4/src/lib.rs index f5adb235e..a34f416b7 100644 --- a/crates/sel4/src/lib.rs +++ b/crates/sel4/src/lib.rs @@ -87,8 +87,17 @@ #![allow(clippy::unit_arg)] pub use sel4_config::{ - self as config, sel4_cfg, sel4_cfg_attr, sel4_cfg_bool, sel4_cfg_enum, sel4_cfg_if, - sel4_cfg_match, sel4_cfg_str, sel4_cfg_struct, sel4_cfg_usize, sel4_cfg_word, + self as config, + sel4_cfg, + sel4_cfg_attr, + sel4_cfg_bool, + sel4_cfg_enum, + sel4_cfg_if, + sel4_cfg_match, + sel4_cfg_str, + sel4_cfg_struct, + sel4_cfg_usize, + sel4_cfg_word, sel4_cfg_wrap_match, }; @@ -115,27 +124,71 @@ mod vspace; pub mod init_thread; pub use bootinfo::{ - BootInfo, BootInfoExtra, BootInfoExtraId, BootInfoExtraIter, BootInfoPtr, UntypedDesc, + BootInfo, + BootInfoExtra, + BootInfoExtraId, + BootInfoExtraIter, + BootInfoPtr, + UntypedDesc, +}; +pub use cap_rights::{ + CapRights, + CapRightsBuilder, }; -pub use cap_rights::{CapRights, CapRightsBuilder}; pub use cnode_cap_data::CNodeCapData; pub use cptr::{ - AbsoluteCPtr, CPtr, CPtrBits, CPtrWithDepth, Cap, CapType, HasCPtrWithDepth, cap, cap_type, + AbsoluteCPtr, + CPtr, + CPtrBits, + CPtrWithDepth, + Cap, + CapType, + HasCPtrWithDepth, + cap, + cap_type, +}; +pub use error::{ + Error, + Result, }; -pub use error::{Error, Result}; pub use fault::*; -pub use invocation_context::{InvocationContext, NoExplicitInvocationContext, NoInvocationContext}; -pub use invocations::{TcbFlagsBuilder, Time}; +pub use invocation_context::{ + InvocationContext, + NoExplicitInvocationContext, + NoInvocationContext, +}; +pub use invocations::{ + TcbFlagsBuilder, + Time, +}; pub use ipc_buffer::IpcBuffer; -pub use message_info::{MessageInfo, MessageInfoBuilder}; +pub use message_info::{ + MessageInfo, + MessageInfoBuilder, +}; pub use object::{ - CapTypeForObject, CapTypeForObjectOfFixedSize, CapTypeForObjectOfVariableSize, ObjectBlueprint, + CapTypeForObject, + CapTypeForObjectOfFixedSize, + CapTypeForObjectOfVariableSize, + ObjectBlueprint, ObjectType, }; -pub use reply_authority::{ConveysReplyAuthority, ReplyAuthority}; -pub use syscalls::{Badge, CallWithMRs, FastMessages, NUM_MESSAGE_REGISTERS, RecvWithMRs, r#yield}; +pub use reply_authority::{ + ConveysReplyAuthority, + ReplyAuthority, +}; +pub use syscalls::{ + Badge, + CallWithMRs, + FastMessages, + NUM_MESSAGE_REGISTERS, + RecvWithMRs, + r#yield, +}; pub use vspace::{ - CapTypeForFrameObject, CapTypeForFrameObjectOfFixedSize, CapTypeForTranslationTableObject, + CapTypeForFrameObject, + CapTypeForFrameObjectOfFixedSize, + CapTypeForTranslationTableObject, vspace_levels, }; @@ -150,9 +203,13 @@ pub use syscalls::set_tls_base; pub use arch::top_level::*; pub(crate) use helper_macros::{ - declare_cap_alias, declare_cap_type, declare_cap_type_for_object, - declare_cap_type_for_object_of_fixed_size, declare_cap_type_for_object_of_variable_size, - declare_fault_newtype, newtype_methods, + declare_cap_alias, + declare_cap_type, + declare_cap_type_for_object, + declare_cap_type_for_object_of_fixed_size, + declare_cap_type_for_object_of_variable_size, + declare_fault_newtype, + newtype_methods, }; sel4_cfg_if! { @@ -203,8 +260,13 @@ mod state; #[cfg(feature = "state")] pub use state::{ - ImplicitInvocationContext, ipc_buffer_is_thread_local, set_ipc_buffer, - try_with_ipc_buffer_slot, try_with_ipc_buffer_slot_mut, with_ipc_buffer, with_ipc_buffer_mut, + ImplicitInvocationContext, + ipc_buffer_is_thread_local, + set_ipc_buffer, + try_with_ipc_buffer_slot, + try_with_ipc_buffer_slot_mut, + with_ipc_buffer, + with_ipc_buffer_mut, }; /// Corresponds to `seL4_Word`. diff --git a/crates/sel4/src/message_info.rs b/crates/sel4/src/message_info.rs index 0460770f5..5d84c91a0 100644 --- a/crates/sel4/src/message_info.rs +++ b/crates/sel4/src/message_info.rs @@ -4,7 +4,11 @@ // SPDX-License-Identifier: MIT // -use crate::{Word, newtype_methods, sys}; +use crate::{ + Word, + newtype_methods, + sys, +}; /// Corresponds to `seL4_MessageInfo_t`. #[derive(Debug, Clone, PartialEq, Eq)] diff --git a/crates/sel4/src/object.rs b/crates/sel4/src/object.rs index 5ede6e791..bd89197a5 100644 --- a/crates/sel4/src/object.rs +++ b/crates/sel4/src/object.rs @@ -8,8 +8,14 @@ use core::ffi::c_uint; use crate::{ - CapType, ObjectBlueprintArch, ObjectTypeArch, const_helpers::u32_into_usize, sel4_cfg, - sel4_cfg_enum, sel4_cfg_wrap_match, sys, + CapType, + ObjectBlueprintArch, + ObjectTypeArch, + const_helpers::u32_into_usize, + sel4_cfg, + sel4_cfg_enum, + sel4_cfg_wrap_match, + sys, }; #[sel4_cfg(KERNEL_MCS)] diff --git a/crates/sel4/src/reply_authority.rs b/crates/sel4/src/reply_authority.rs index 8584d4fea..2b70820cf 100644 --- a/crates/sel4/src/reply_authority.rs +++ b/crates/sel4/src/reply_authority.rs @@ -4,15 +4,24 @@ // SPDX-License-Identifier: MIT // -use sel4_config::{sel4_cfg, sel4_cfg_if}; +use sel4_config::{ + sel4_cfg, + sel4_cfg_if, +}; -use crate::{NoExplicitInvocationContext, sys}; +use crate::{ + NoExplicitInvocationContext, + sys, +}; #[sel4_cfg(KERNEL_MCS)] use crate::cap; #[sel4_cfg(not(KERNEL_MCS))] -use crate::{InvocationContext, MessageInfo}; +use crate::{ + InvocationContext, + MessageInfo, +}; /// Configuration-dependant alias for conveying reply authority to syscalls. pub type ReplyAuthority = ReplyAuthorityImpl; diff --git a/crates/sel4/src/state/mod.rs b/crates/sel4/src/state/mod.rs index 8eae5facf..f63f78ac3 100644 --- a/crates/sel4/src/state/mod.rs +++ b/crates/sel4/src/state/mod.rs @@ -6,12 +6,22 @@ use core::cell::UnsafeCell; -use crate::{InvocationContext, IpcBuffer}; +use crate::{ + InvocationContext, + IpcBuffer, +}; mod token; #[allow(unused_imports)] -use token::{Accessor, BorrowError, BorrowMutError, SyncToken, TokenCell, UnsyncToken}; +use token::{ + Accessor, + BorrowError, + BorrowMutError, + SyncToken, + TokenCell, + UnsyncToken, +}; // // // diff --git a/crates/sel4/src/state/token.rs b/crates/sel4/src/state/token.rs index 2ed3baff7..ce78d86e0 100644 --- a/crates/sel4/src/state/token.rs +++ b/crates/sel4/src/state/token.rs @@ -4,9 +4,19 @@ // SPDX-License-Identifier: MIT // -use core::cell::{Ref, RefCell, RefMut, UnsafeCell}; -use core::fmt; -use core::sync::atomic::{AtomicIsize, Ordering}; +use core::{ + cell::{ + Ref, + RefCell, + RefMut, + UnsafeCell, + }, + fmt, + sync::atomic::{ + AtomicIsize, + Ordering, + }, +}; pub(crate) struct TokenCell { token: K, diff --git a/crates/sel4/src/syscalls.rs b/crates/sel4/src/syscalls.rs index 7471a0df2..e5650c07d 100644 --- a/crates/sel4/src/syscalls.rs +++ b/crates/sel4/src/syscalls.rs @@ -6,11 +6,22 @@ use core::array; -use sel4_config::{sel4_cfg, sel4_cfg_if}; +use sel4_config::{ + sel4_cfg, + sel4_cfg_if, +}; use crate::{ - Cap, CapType, ConveysReplyAuthority, InvocationContext, MessageInfo, - NUM_FAST_MESSAGE_REGISTERS, Word, cap, const_helpers::u32_into_usize, sys, + Cap, + CapType, + ConveysReplyAuthority, + InvocationContext, + MessageInfo, + NUM_FAST_MESSAGE_REGISTERS, + Word, + cap, + const_helpers::u32_into_usize, + sys, }; #[sel4_cfg(not(KERNEL_MCS))] diff --git a/crates/sel4/src/vspace.rs b/crates/sel4/src/vspace.rs index 9a4a5a1c6..2f4c7fda6 100644 --- a/crates/sel4/src/vspace.rs +++ b/crates/sel4/src/vspace.rs @@ -6,7 +6,11 @@ // use crate::{ - CapType, CapTypeForObjectOfFixedSize, FrameObjectType, TranslationTableObjectType, cap_type, + CapType, + CapTypeForObjectOfFixedSize, + FrameObjectType, + TranslationTableObjectType, + cap_type, }; impl FrameObjectType { @@ -38,7 +42,11 @@ pub trait CapTypeForTranslationTableObject: CapTypeForObjectOfFixedSize { /// Items describing the layout of address translation structures for this kernel configuration. pub mod vspace_levels { - use crate::{FrameObjectType, TranslationTableObjectType, sel4_cfg}; + use crate::{ + FrameObjectType, + TranslationTableObjectType, + sel4_cfg, + }; /// The maximum number of levels of translation tables for this kernel configuration. pub use crate::arch::vspace_levels::NUM_LEVELS; diff --git a/crates/sel4/sys/build/bf/mod.rs b/crates/sel4/sys/build/bf/mod.rs index bec38428a..1af121df2 100644 --- a/crates/sel4/sys/build/bf/mod.rs +++ b/crates/sel4/sys/build/bf/mod.rs @@ -4,11 +4,19 @@ // SPDX-License-Identifier: BSD-2-Clause // -use std::fs; -use std::path::Path; - -use proc_macro2::{Literal, TokenStream}; -use quote::{format_ident, quote}; +use std::{ + fs, + path::Path, +}; + +use proc_macro2::{ + Literal, + TokenStream, +}; +use quote::{ + format_ident, + quote, +}; use syn::Ident; mod parser; diff --git a/crates/sel4/sys/build/bf/parser/mod.rs b/crates/sel4/sys/build/bf/parser/mod.rs index de7ae8b6d..6be43ea89 100644 --- a/crates/sel4/sys/build/bf/parser/mod.rs +++ b/crates/sel4/sys/build/bf/parser/mod.rs @@ -4,7 +4,10 @@ // SPDX-License-Identifier: BSD-2-Clause // -use pest::{Parser, iterators::Pair}; +use pest::{ + Parser, + iterators::Pair, +}; use pest_derive::Parser; use regex::Regex; diff --git a/crates/sel4/sys/build/bf/simplified.rs b/crates/sel4/sys/build/bf/simplified.rs index 024ef7770..4d6e640c1 100644 --- a/crates/sel4/sys/build/bf/simplified.rs +++ b/crates/sel4/sys/build/bf/simplified.rs @@ -4,8 +4,10 @@ // SPDX-License-Identifier: BSD-2-Clause // -use std::collections::BTreeSet; -use std::ops::Range; +use std::{ + collections::BTreeSet, + ops::Range, +}; use super::parser::ast; diff --git a/crates/sel4/sys/build/c.rs b/crates/sel4/sys/build/c.rs index a6dec8d86..aba499ba5 100644 --- a/crates/sel4/sys/build/c.rs +++ b/crates/sel4/sys/build/c.rs @@ -4,8 +4,10 @@ // SPDX-License-Identifier: BSD-2-Clause // -use std::env; -use std::path::Path; +use std::{ + env, + path::Path, +}; #[rustfmt::skip] const BLOCKLIST: &[&str] = &[ diff --git a/crates/sel4/sys/build/main.rs b/crates/sel4/sys/build/main.rs index 96b3437d3..712781652 100644 --- a/crates/sel4/sys/build/main.rs +++ b/crates/sel4/sys/build/main.rs @@ -4,14 +4,22 @@ // SPDX-License-Identifier: BSD-2-Clause // -use std::env; -use std::fs; -use std::path::{Path, PathBuf}; +use std::{ + env, + fs, + path::{ + Path, + PathBuf, + }, +}; use glob::glob; use proc_macro2::TokenStream; -use sel4_build_env::{find_in_libsel4_include_dirs, get_libsel4_include_dirs}; +use sel4_build_env::{ + find_in_libsel4_include_dirs, + get_libsel4_include_dirs, +}; mod bf; mod c; diff --git a/crates/sel4/sys/build/xml/condition.rs b/crates/sel4/sys/build/xml/condition.rs index 8dcefb2b6..e3b3cb841 100644 --- a/crates/sel4/sys/build/xml/condition.rs +++ b/crates/sel4/sys/build/xml/condition.rs @@ -4,7 +4,10 @@ // SPDX-License-Identifier: BSD-2-Clause // -use xmltree::{Element, XMLNode}; +use xmltree::{ + Element, + XMLNode, +}; use sel4_config_data::Configuration; diff --git a/crates/sel4/sys/build/xml/invocations/mod.rs b/crates/sel4/sys/build/xml/invocations/mod.rs index 13d4640b3..423851ea0 100644 --- a/crates/sel4/sys/build/xml/invocations/mod.rs +++ b/crates/sel4/sys/build/xml/invocations/mod.rs @@ -7,17 +7,28 @@ #![allow(clippy::eq_op)] #![allow(clippy::nonminimal_bool)] -use std::collections::BTreeMap; -use std::fmt::Write; -use std::ops::Range; -use std::path::Path; - -use proc_macro2::{Ident, TokenStream}; -use quote::{format_ident, quote}; +use std::{ + collections::BTreeMap, + fmt::Write, + ops::Range, + path::Path, +}; + +use proc_macro2::{ + Ident, + TokenStream, +}; +use quote::{ + format_ident, + quote, +}; use sel4_config::sel4_cfg_bool; -use super::{Condition, parse_xml}; +use super::{ + Condition, + parse_xml, +}; mod parse; use parse::*; diff --git a/crates/sel4/sys/build/xml/invocations/parse.rs b/crates/sel4/sys/build/xml/invocations/parse.rs index 991848dd5..25a464631 100644 --- a/crates/sel4/sys/build/xml/invocations/parse.rs +++ b/crates/sel4/sys/build/xml/invocations/parse.rs @@ -4,7 +4,10 @@ // SPDX-License-Identifier: BSD-2-Clause // -use xmltree::{Element, XMLNode}; +use xmltree::{ + Element, + XMLNode, +}; use crate::xml::Condition; diff --git a/crates/sel4/sys/build/xml/mod.rs b/crates/sel4/sys/build/xml/mod.rs index bb9568822..a0ceb1d14 100644 --- a/crates/sel4/sys/build/xml/mod.rs +++ b/crates/sel4/sys/build/xml/mod.rs @@ -4,8 +4,10 @@ // SPDX-License-Identifier: BSD-2-Clause // -use std::fs; -use std::path::Path; +use std::{ + fs, + path::Path, +}; use xmltree::Element; diff --git a/crates/sel4/sys/build/xml/syscalls/mod.rs b/crates/sel4/sys/build/xml/syscalls/mod.rs index 816de904f..3678aaa84 100644 --- a/crates/sel4/sys/build/xml/syscalls/mod.rs +++ b/crates/sel4/sys/build/xml/syscalls/mod.rs @@ -7,9 +7,15 @@ use std::path::Path; use proc_macro2::TokenStream; -use quote::{format_ident, quote}; +use quote::{ + format_ident, + quote, +}; -use super::{Condition, parse_xml}; +use super::{ + Condition, + parse_xml, +}; mod parse; diff --git a/crates/sel4/sys/build/xml/syscalls/parse.rs b/crates/sel4/sys/build/xml/syscalls/parse.rs index 19816a64e..bbcef2741 100644 --- a/crates/sel4/sys/build/xml/syscalls/parse.rs +++ b/crates/sel4/sys/build/xml/syscalls/parse.rs @@ -4,7 +4,10 @@ // SPDX-License-Identifier: BSD-2-Clause // -use xmltree::{Element, XMLNode}; +use xmltree::{ + Element, + XMLNode, +}; use crate::xml::Condition; diff --git a/crates/sel4/sys/src/fault/arch/aarch32.rs b/crates/sel4/sys/src/fault/arch/aarch32.rs index 720bf8ef3..2a540a981 100644 --- a/crates/sel4/sys/src/fault/arch/aarch32.rs +++ b/crates/sel4/sys/src/fault/arch/aarch32.rs @@ -4,8 +4,10 @@ // SPDX-License-Identifier: BSD-2-Clause // -use crate::bf::*; -use crate::c::*; +use crate::{ + bf::*, + c::*, +}; use sel4_config::sel4_cfg_wrap_match; diff --git a/crates/sel4/sys/src/fault/arch/aarch64.rs b/crates/sel4/sys/src/fault/arch/aarch64.rs index 294eb7012..07cf6b18e 100644 --- a/crates/sel4/sys/src/fault/arch/aarch64.rs +++ b/crates/sel4/sys/src/fault/arch/aarch64.rs @@ -4,8 +4,10 @@ // SPDX-License-Identifier: BSD-2-Clause // -use crate::bf::*; -use crate::c::*; +use crate::{ + bf::*, + c::*, +}; use sel4_config::sel4_cfg_wrap_match; diff --git a/crates/sel4/sys/src/fault/arch/riscv.rs b/crates/sel4/sys/src/fault/arch/riscv.rs index 94eb6f46c..909d98530 100644 --- a/crates/sel4/sys/src/fault/arch/riscv.rs +++ b/crates/sel4/sys/src/fault/arch/riscv.rs @@ -4,8 +4,10 @@ // SPDX-License-Identifier: BSD-2-Clause // -use crate::bf::*; -use crate::c::*; +use crate::{ + bf::*, + c::*, +}; use sel4_config::sel4_cfg_wrap_match; diff --git a/crates/sel4/sys/src/fault/arch/x86_64.rs b/crates/sel4/sys/src/fault/arch/x86_64.rs index 00b5f1ce0..197a6103b 100644 --- a/crates/sel4/sys/src/fault/arch/x86_64.rs +++ b/crates/sel4/sys/src/fault/arch/x86_64.rs @@ -4,8 +4,10 @@ // SPDX-License-Identifier: BSD-2-Clause // -use crate::bf::*; -use crate::c::*; +use crate::{ + bf::*, + c::*, +}; use sel4_config::sel4_cfg_wrap_match; diff --git a/crates/sel4/sys/src/fault/mod.rs b/crates/sel4/sys/src/fault/mod.rs index 48c38dda5..8449b0d21 100644 --- a/crates/sel4/sys/src/fault/mod.rs +++ b/crates/sel4/sys/src/fault/mod.rs @@ -4,8 +4,10 @@ // SPDX-License-Identifier: BSD-2-Clause // -use crate::bf::*; -use crate::c::*; +use crate::{ + bf::*, + c::*, +}; use sel4_config::sel4_cfg_wrap_match; diff --git a/crates/sel4/sys/src/invocations.rs b/crates/sel4/sys/src/invocations.rs index 62c41070f..82f817c29 100644 --- a/crates/sel4/sys/src/invocations.rs +++ b/crates/sel4/sys/src/invocations.rs @@ -4,8 +4,10 @@ // SPDX-License-Identifier: BSD-2-Clause // -use crate::bf::*; -use crate::c::*; +use crate::{ + bf::*, + c::*, +}; pub mod invocation_label { include!(concat!(env!("OUT_DIR"), "/invocation_labels.rs")); diff --git a/crates/sel4/sys/src/ipc_buffer.rs b/crates/sel4/sys/src/ipc_buffer.rs index 7d5a127b4..271bdab41 100644 --- a/crates/sel4/sys/src/ipc_buffer.rs +++ b/crates/sel4/sys/src/ipc_buffer.rs @@ -4,13 +4,25 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::mem; -use core::ops::Range; -use core::slice; +use core::{ + mem, + ops::Range, + slice, +}; -use sel4_bitfield_ops::{PrimInt, UnsignedPrimInt, get_bits, set_bits, set_bits_from_slice}; +use sel4_bitfield_ops::{ + PrimInt, + UnsignedPrimInt, + get_bits, + set_bits, + set_bits_from_slice, +}; -use crate::{seL4_CPtr, seL4_IPCBuffer, seL4_Word}; +use crate::{ + seL4_CPtr, + seL4_IPCBuffer, + seL4_Word, +}; impl seL4_IPCBuffer { pub(crate) fn get_mr(&self, i: usize) -> seL4_Word { diff --git a/crates/sel4/sys/src/syscalls/calls.rs b/crates/sel4/sys/src/syscalls/calls.rs index 35e3423ac..aafff8d1d 100644 --- a/crates/sel4/sys/src/syscalls/calls.rs +++ b/crates/sel4/sys/src/syscalls/calls.rs @@ -4,15 +4,29 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::ffi::c_int; -use core::sync::atomic::{Ordering, compiler_fence}; +use core::{ + ffi::c_int, + sync::atomic::{ + Ordering, + compiler_fence, + }, +}; -use sel4_config::{sel4_cfg, sel4_cfg_if}; +use sel4_config::{ + sel4_cfg, + sel4_cfg_if, +}; #[allow(unused_imports)] use crate::{ - ReplyAuthority, WaitMessageInfo, seL4_CPtr, seL4_IPCBuffer, seL4_MessageInfo, seL4_Uint32, - seL4_Word, syscall_id, + ReplyAuthority, + WaitMessageInfo, + seL4_CPtr, + seL4_IPCBuffer, + seL4_MessageInfo, + seL4_Uint32, + seL4_Word, + syscall_id, }; #[allow(unused_imports)] diff --git a/crates/sel4/sys/src/syscalls/helpers/arch/aarch32.rs b/crates/sel4/sys/src/syscalls/helpers/arch/aarch32.rs index 5e4931d1b..d5fbbfc94 100644 --- a/crates/sel4/sys/src/syscalls/helpers/arch/aarch32.rs +++ b/crates/sel4/sys/src/syscalls/helpers/arch/aarch32.rs @@ -4,13 +4,18 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::arch::asm; -use core::ffi::c_int; +use core::{ + arch::asm, + ffi::c_int, +}; use sel4_config::sel4_cfg; use super::sys_id_to_word; -use crate::{seL4_MessageInfo, seL4_Word}; +use crate::{ + seL4_MessageInfo, + seL4_Word, +}; // NOTE // asm!() does not allow r6 to be used for input or output operands, because it's sometimes used by LLVM. diff --git a/crates/sel4/sys/src/syscalls/helpers/arch/aarch64.rs b/crates/sel4/sys/src/syscalls/helpers/arch/aarch64.rs index 371c01b84..be505b54b 100644 --- a/crates/sel4/sys/src/syscalls/helpers/arch/aarch64.rs +++ b/crates/sel4/sys/src/syscalls/helpers/arch/aarch64.rs @@ -4,13 +4,18 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::arch::asm; -use core::ffi::c_int; +use core::{ + arch::asm, + ffi::c_int, +}; use sel4_config::sel4_cfg; use super::sys_id_to_word; -use crate::{seL4_MessageInfo, seL4_Word}; +use crate::{ + seL4_MessageInfo, + seL4_Word, +}; pub fn sys_send( sys: c_int, diff --git a/crates/sel4/sys/src/syscalls/helpers/arch/riscv.rs b/crates/sel4/sys/src/syscalls/helpers/arch/riscv.rs index 2334b7a1b..422a1aca3 100644 --- a/crates/sel4/sys/src/syscalls/helpers/arch/riscv.rs +++ b/crates/sel4/sys/src/syscalls/helpers/arch/riscv.rs @@ -4,13 +4,18 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::arch::asm; -use core::ffi::c_int; +use core::{ + arch::asm, + ffi::c_int, +}; use sel4_config::sel4_cfg; use super::sys_id_to_word; -use crate::{seL4_MessageInfo, seL4_Word}; +use crate::{ + seL4_MessageInfo, + seL4_Word, +}; pub fn sys_send( sys: c_int, diff --git a/crates/sel4/sys/src/syscalls/helpers/arch/x86_64.rs b/crates/sel4/sys/src/syscalls/helpers/arch/x86_64.rs index f6fd3c62e..a394cb1df 100644 --- a/crates/sel4/sys/src/syscalls/helpers/arch/x86_64.rs +++ b/crates/sel4/sys/src/syscalls/helpers/arch/x86_64.rs @@ -4,13 +4,18 @@ // SPDX-License-Identifier: BSD-2-Clause // -use core::arch::asm; -use core::ffi::c_int; +use core::{ + arch::asm, + ffi::c_int, +}; use sel4_config::sel4_cfg; use super::sys_id_to_word; -use crate::{seL4_MessageInfo, seL4_Word}; +use crate::{ + seL4_MessageInfo, + seL4_Word, +}; #[sel4_cfg(not(SYSCALL))] compile_error!("unsupported configuration"); diff --git a/crates/sel4/sys/src/syscalls/helpers/mod.rs b/crates/sel4/sys/src/syscalls/helpers/mod.rs index 8b6694255..1d0c59954 100644 --- a/crates/sel4/sys/src/syscalls/helpers/mod.rs +++ b/crates/sel4/sys/src/syscalls/helpers/mod.rs @@ -6,7 +6,10 @@ use crate::bf::SeL4Bitfield; -use crate::{seL4_MessageInfo, seL4_Word}; +use crate::{ + seL4_MessageInfo, + seL4_Word, +}; mod arch; diff --git a/hacking/cargo-manifest-management/tool/crates/manage-cargo-manifests/src/main.rs b/hacking/cargo-manifest-management/tool/crates/manage-cargo-manifests/src/main.rs index d6db465e3..369a4dffc 100644 --- a/hacking/cargo-manifest-management/tool/crates/manage-cargo-manifests/src/main.rs +++ b/hacking/cargo-manifest-management/tool/crates/manage-cargo-manifests/src/main.rs @@ -4,18 +4,32 @@ // SPDX-License-Identifier: BSD-2-Clause // -use std::fs::{self, File}; -use std::path::PathBuf; -use std::result::Result as StdResult; -use std::str; +use std::{ + fs::{ + self, + File, + }, + path::PathBuf, + result::Result as StdResult, + str, +}; -use anyhow::{Context, Result, bail}; +use anyhow::{ + Context, + Result, + bail, +}; use clap::Parser; use serde::Deserialize; use similar::TextDiff; use toml::Table as TomlTable; -use toml_normalize::{Error as TomlNormalizeError, Formatter, Policy, builtin_policies}; +use toml_normalize::{ + Error as TomlNormalizeError, + Formatter, + Policy, + builtin_policies, +}; #[derive(Debug, Parser)] struct Args { diff --git a/hacking/cargo-manifest-management/tool/crates/manage-direct-dependency-allow-list/src/main.rs b/hacking/cargo-manifest-management/tool/crates/manage-direct-dependency-allow-list/src/main.rs index b70578a37..024ecfd00 100644 --- a/hacking/cargo-manifest-management/tool/crates/manage-direct-dependency-allow-list/src/main.rs +++ b/hacking/cargo-manifest-management/tool/crates/manage-direct-dependency-allow-list/src/main.rs @@ -4,15 +4,36 @@ // SPDX-License-Identifier: BSD-2-Clause // -use std::collections::{BTreeMap, BTreeSet, HashMap}; -use std::fs; -use std::path::PathBuf; +use std::{ + collections::{ + BTreeMap, + BTreeSet, + HashMap, + }, + fs, + path::PathBuf, +}; use anyhow::bail; -use cargo_metadata::semver::{Version, VersionReq}; -use cargo_metadata::{Metadata, MetadataCommand}; -use clap::{Parser, Subcommand}; -use toml_edit::{Document, Formatted, Item, Table, Value}; +use cargo_metadata::{ + Metadata, + MetadataCommand, + semver::{ + Version, + VersionReq, + }, +}; +use clap::{ + Parser, + Subcommand, +}; +use toml_edit::{ + Document, + Formatted, + Item, + Table, + Value, +}; #[derive(Debug, Parser)] struct Cli { diff --git a/hacking/cargo-manifest-management/tool/crates/toml-normalize/src/builtin_policies.rs b/hacking/cargo-manifest-management/tool/crates/toml-normalize/src/builtin_policies.rs index a3dd2576a..bbb47cf28 100644 --- a/hacking/cargo-manifest-management/tool/crates/toml-normalize/src/builtin_policies.rs +++ b/hacking/cargo-manifest-management/tool/crates/toml-normalize/src/builtin_policies.rs @@ -6,7 +6,11 @@ use toml_path_regex::PathRegex; -use crate::{KeyOrdering, Policy, TableRule}; +use crate::{ + KeyOrdering, + Policy, + TableRule, +}; pub fn cargo_manifest_policy() -> Policy { Policy { diff --git a/hacking/cargo-manifest-management/tool/crates/toml-normalize/src/format.rs b/hacking/cargo-manifest-management/tool/crates/toml-normalize/src/format.rs index 3a85621c1..f754e5de9 100644 --- a/hacking/cargo-manifest-management/tool/crates/toml-normalize/src/format.rs +++ b/hacking/cargo-manifest-management/tool/crates/toml-normalize/src/format.rs @@ -4,17 +4,34 @@ // SPDX-License-Identifier: BSD-2-Clause // -use std::cmp::Ordering; -use std::fmt; -use std::mem; +use std::{ + cmp::Ordering, + fmt, + mem, +}; use thiserror::Error; use toml::value::{ - Array as UnformattedArray, Table as UnformattedTable, Value as UnformattedValue, + Array as UnformattedArray, + Table as UnformattedTable, + Value as UnformattedValue, +}; +use toml_edit::{ + Array, + ArrayOfTables, + Document, + Formatted, + InlineTable, + Item, + Key, + Table, + Value, }; -use toml_edit::{Array, ArrayOfTables, Document, Formatted, InlineTable, Item, Key, Table, Value}; -use toml_path_regex::{Path, PathSegment}; +use toml_path_regex::{ + Path, + PathSegment, +}; pub trait AbstractPolicy { fn max_width(&self) -> usize; diff --git a/hacking/cargo-manifest-management/tool/crates/toml-normalize/src/lib.rs b/hacking/cargo-manifest-management/tool/crates/toml-normalize/src/lib.rs index 6a05a925c..db1376ac2 100644 --- a/hacking/cargo-manifest-management/tool/crates/toml-normalize/src/lib.rs +++ b/hacking/cargo-manifest-management/tool/crates/toml-normalize/src/lib.rs @@ -9,5 +9,13 @@ mod policy; pub mod builtin_policies; -pub use format::{AbstractPolicy, Error, Formatter}; -pub use policy::{KeyOrdering, Policy, TableRule}; +pub use format::{ + AbstractPolicy, + Error, + Formatter, +}; +pub use policy::{ + KeyOrdering, + Policy, + TableRule, +}; diff --git a/hacking/cargo-manifest-management/tool/crates/toml-normalize/src/main.rs b/hacking/cargo-manifest-management/tool/crates/toml-normalize/src/main.rs index 7f6edf2d2..a9b965f8b 100644 --- a/hacking/cargo-manifest-management/tool/crates/toml-normalize/src/main.rs +++ b/hacking/cargo-manifest-management/tool/crates/toml-normalize/src/main.rs @@ -4,13 +4,26 @@ // SPDX-License-Identifier: BSD-2-Clause // -use std::fs; -use std::io::{Read, Write}; -use std::path::PathBuf; - -use clap::{CommandFactory, FromArgMatches, Parser}; - -use toml_normalize::{Formatter, Policy, builtin_policies}; +use std::{ + fs, + io::{ + Read, + Write, + }, + path::PathBuf, +}; + +use clap::{ + CommandFactory, + FromArgMatches, + Parser, +}; + +use toml_normalize::{ + Formatter, + Policy, + builtin_policies, +}; #[derive(Debug, Parser)] struct Args { diff --git a/hacking/cargo-manifest-management/tool/crates/toml-normalize/src/policy.rs b/hacking/cargo-manifest-management/tool/crates/toml-normalize/src/policy.rs index 05865f375..015949de8 100644 --- a/hacking/cargo-manifest-management/tool/crates/toml-normalize/src/policy.rs +++ b/hacking/cargo-manifest-management/tool/crates/toml-normalize/src/policy.rs @@ -4,12 +4,24 @@ // SPDX-License-Identifier: BSD-2-Clause // -use std::cmp::{Ordering, Reverse}; - -use serde::{Deserialize, Serialize}; -use serde_with::{DisplayFromStr, serde_as}; - -use toml_path_regex::{PathRegex, PathSegment}; +use std::cmp::{ + Ordering, + Reverse, +}; + +use serde::{ + Deserialize, + Serialize, +}; +use serde_with::{ + DisplayFromStr, + serde_as, +}; + +use toml_path_regex::{ + PathRegex, + PathSegment, +}; use crate::AbstractPolicy; diff --git a/hacking/cargo-manifest-management/tool/crates/toml-path-regex/src/generic_regex.rs b/hacking/cargo-manifest-management/tool/crates/toml-path-regex/src/generic_regex.rs index a17c3278e..9ddad2b42 100644 --- a/hacking/cargo-manifest-management/tool/crates/toml-path-regex/src/generic_regex.rs +++ b/hacking/cargo-manifest-management/tool/crates/toml-path-regex/src/generic_regex.rs @@ -4,8 +4,10 @@ // SPDX-License-Identifier: BSD-2-Clause // -use std::borrow::Borrow; -use std::rc::Rc; +use std::{ + borrow::Borrow, + rc::Rc, +}; // TODO mitigate regex size explosion with smart constructors diff --git a/hacking/cargo-manifest-management/tool/crates/toml-path-regex/src/lib.rs b/hacking/cargo-manifest-management/tool/crates/toml-path-regex/src/lib.rs index 2d0c2b539..5d76a1de8 100644 --- a/hacking/cargo-manifest-management/tool/crates/toml-path-regex/src/lib.rs +++ b/hacking/cargo-manifest-management/tool/crates/toml-path-regex/src/lib.rs @@ -4,11 +4,16 @@ // SPDX-License-Identifier: BSD-2-Clause // -use std::borrow::Borrow; -use std::fmt; -use std::str::FromStr; - -use pest::error::{Error as PestError, ErrorVariant}; +use std::{ + borrow::Borrow, + fmt, + str::FromStr, +}; + +use pest::error::{ + Error as PestError, + ErrorVariant, +}; use regex::Regex; mod generic_regex; @@ -17,10 +22,17 @@ mod path; mod path_segment_predicate; use generic_regex::GenericRegex; -use parse::{Expr, Rule, parse}; +use parse::{ + Expr, + Rule, + parse, +}; use path_segment_predicate::PathSegmentPredicate; -pub use path::{Path, PathSegment}; +pub use path::{ + Path, + PathSegment, +}; pub type Error = PestError; diff --git a/hacking/cargo-manifest-management/tool/crates/toml-path-regex/src/parse.rs b/hacking/cargo-manifest-management/tool/crates/toml-path-regex/src/parse.rs index 9f2282e2e..02f6a0f7a 100644 --- a/hacking/cargo-manifest-management/tool/crates/toml-path-regex/src/parse.rs +++ b/hacking/cargo-manifest-management/tool/crates/toml-path-regex/src/parse.rs @@ -5,10 +5,15 @@ // use pest::{ - Parser, Span, + Parser, + Span, error::Error, iterators::Pair, - pratt_parser::{Assoc, Op, PrattParser}, + pratt_parser::{ + Assoc, + Op, + PrattParser, + }, }; use pest_derive::Parser; diff --git a/hacking/cargo-manifest-management/tool/crates/toml-path-regex/src/path_segment_predicate.rs b/hacking/cargo-manifest-management/tool/crates/toml-path-regex/src/path_segment_predicate.rs index 39fc45306..fba403228 100644 --- a/hacking/cargo-manifest-management/tool/crates/toml-path-regex/src/path_segment_predicate.rs +++ b/hacking/cargo-manifest-management/tool/crates/toml-path-regex/src/path_segment_predicate.rs @@ -7,7 +7,11 @@ use rangemap::inclusive_set::RangeInclusiveSet; use regex::Regex; -use super::{PathSegment, generic_regex::Predicate, parse::IndexRange}; +use super::{ + PathSegment, + generic_regex::Predicate, + parse::IndexRange, +}; pub struct PathSegmentPredicate { inner: Inner, diff --git a/hacking/vscode/create-vscode-workspace/src/main.rs b/hacking/vscode/create-vscode-workspace/src/main.rs index b47bd669a..f7c05bf41 100644 --- a/hacking/vscode/create-vscode-workspace/src/main.rs +++ b/hacking/vscode/create-vscode-workspace/src/main.rs @@ -4,17 +4,38 @@ // SPDX-License-Identifier: BSD-2-Clause // -use std::collections::{BTreeMap, BTreeSet}; -use std::env; -use std::fs::{self, File}; -use std::io::{Write, stdout}; -use std::path::PathBuf; -use std::process::{Command, Output}; - -use cargo_metadata::{Metadata, MetadataCommand, PackageName}; +use std::{ + collections::{ + BTreeMap, + BTreeSet, + }, + env, + fs::{ + self, + File, + }, + io::{ + Write, + stdout, + }, + path::PathBuf, + process::{ + Command, + Output, + }, +}; + +use cargo_metadata::{ + Metadata, + MetadataCommand, + PackageName, +}; use clap::Parser; use regex::Regex; -use serde_json::{Value, json}; +use serde_json::{ + Value, + json, +}; // HACK fn project_root() -> PathBuf { diff --git a/rustfmt.toml b/rustfmt.toml index d5f95c885..f526c4eb6 100644 --- a/rustfmt.toml +++ b/rustfmt.toml @@ -4,6 +4,9 @@ # SPDX-License-Identifier: BSD-2-Clause # +imports_layout = "Vertical" +imports_granularity = "Crate" + ignore = [ "/tmp/", ]