Samuka007/asterinas
1
0
Fork 0
mirror of https://github.com/asterinas/asterinas.git synced 2025-06-21 00:06:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

Refactor the API of spinlocks

Browse Source
This commit is contained in:
Cautreoxit
2024-08-09 03:32:27 +00:00
committed by Tate, Hongliang Tian
parent 0160a85ccd
commit c44447d54b
38 changed files with 345 additions and 259 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
kernel/comps/virtio/src/device/block/device.rs
View File

@ -174,7 +174,7 @@ impl DeviceInner {
info!("Virtio block device handle irq");
// When we enter the IRQs handling function,
// IRQs have already been disabled,
// so there is no need to call `lock_irq_disabled`.
// so there is no need to call `disable_irq`.
loop {
// Pops the complete request
let complete_request = {
@ -221,7 +221,7 @@ impl DeviceInner {
// TODO: Most logic is the same as read and write, there should be a refactor.
// TODO: Should return an Err instead of panic if the device fails.
fn request_device_id(&self) -> String {
let id = self.id_allocator.lock_irq_disabled().alloc().unwrap();
let id = self.id_allocator.disable_irq().lock().alloc().unwrap();
let req_slice = {
let req_slice = DmaStreamSlice::new(&self.block_requests, id * REQ_SIZE, REQ_SIZE);
let req = BlockReq {
@ -250,7 +250,7 @@ impl DeviceInner {
let device_id_slice = DmaStreamSlice::new(&device_id_stream, 0, MAX_ID_LENGTH);
let outputs = vec![&device_id_slice, &resp_slice];
let mut queue = self.queue.lock_irq_disabled();
let mut queue = self.queue.disable_irq().lock();
let token = queue
.add_dma_buf(&[&req_slice], outputs.as_slice())
.expect("add queue failed");
@ -263,7 +263,7 @@ impl DeviceInner {
queue.pop_used_with_token(token).expect("pop used failed");
resp_slice.sync().unwrap();
self.id_allocator.lock_irq_disabled().free(id);
self.id_allocator.disable_irq().lock().free(id);
let resp: BlockResp = resp_slice.read_val(0).unwrap();
match RespStatus::try_from(resp.status).unwrap() {
RespStatus::Ok => {}
@ -288,7 +288,7 @@ impl DeviceInner {
fn read(&self, bio_request: BioRequest) {
let dma_streams = Self::dma_stream_map(&bio_request);
let id = self.id_allocator.lock_irq_disabled().alloc().unwrap();
let id = self.id_allocator.disable_irq().lock().alloc().unwrap();
let req_slice = {
let req_slice = DmaStreamSlice::new(&self.block_requests, id * REQ_SIZE, REQ_SIZE);
let req = BlockReq {
@ -325,7 +325,7 @@ impl DeviceInner {
}
loop {
let mut queue = self.queue.lock_irq_disabled();
let mut queue = self.queue.disable_irq().lock();
if num_used_descs > queue.available_desc() {
continue;
}
@ -339,7 +339,8 @@ impl DeviceInner {
// Records the submitted request
let submitted_request = SubmittedRequest::new(id as u16, bio_request, dma_streams);
self.submitted_requests
.lock_irq_disabled()
.disable_irq()
.lock()
.insert(token, submitted_request);
return;
}
@ -349,7 +350,7 @@ impl DeviceInner {
fn write(&self, bio_request: BioRequest) {
let dma_streams = Self::dma_stream_map(&bio_request);
let id = self.id_allocator.lock_irq_disabled().alloc().unwrap();
let id = self.id_allocator.disable_irq().lock().alloc().unwrap();
let req_slice = {
let req_slice = DmaStreamSlice::new(&self.block_requests, id * REQ_SIZE, REQ_SIZE);
let req = BlockReq {
@ -385,7 +386,7 @@ impl DeviceInner {
panic!("The request size surpasses the queue size");
}
loop {
let mut queue = self.queue.lock_irq_disabled();
let mut queue = self.queue.disable_irq().lock();
if num_used_descs > queue.available_desc() {
continue;
}
@ -399,7 +400,8 @@ impl DeviceInner {
// Records the submitted request
let submitted_request = SubmittedRequest::new(id as u16, bio_request, dma_streams);
self.submitted_requests
.lock_irq_disabled()
.disable_irq()
.lock()
.insert(token, submitted_request);
return;
}

8
kernel/comps/virtio/src/device/console/device.rs
View File

@ -32,7 +32,7 @@ pub struct ConsoleDevice {
impl AnyConsoleDevice for ConsoleDevice {
fn send(&self, value: &[u8]) {
let mut transmit_queue = self.transmit_queue.lock_irq_disabled();
let mut transmit_queue = self.transmit_queue.disable_irq().lock();
let mut reader = VmReader::from(value);
while reader.remain() > 0 {
@ -106,10 +106,10 @@ impl ConsoleDevice {
callbacks: RwLock::new(Vec::new()),
});
device.activate_receive_buffer(&mut device.receive_queue.lock_irq_disabled());
device.activate_receive_buffer(&mut device.receive_queue.disable_irq().lock());
// Register irq callbacks
let mut transport = device.transport.lock_irq_disabled();
let mut transport = device.transport.disable_irq().lock();
let handle_console_input = {
let device = device.clone();
move |_: &TrapFrame| device.handle_recv_irq()
@ -129,7 +129,7 @@ impl ConsoleDevice {
}
fn handle_recv_irq(&self) {
let mut receive_queue = self.receive_queue.lock_irq_disabled();
let mut receive_queue = self.receive_queue.disable_irq().lock();
let Ok((_, len)) = receive_queue.pop_used() else {
return;

4
kernel/comps/virtio/src/device/input/device.rs
View File

@ -122,7 +122,7 @@ impl InputDevice {
let input_prop = InputProp::from_bits(prop[0]).unwrap();
debug!("input device prop:{:?}", input_prop);
let mut transport = device.transport.lock_irq_disabled();
let mut transport = device.transport.disable_irq().lock();
fn config_space_change(_: &TrapFrame) {
debug!("input device config space change");
}
@ -148,7 +148,7 @@ impl InputDevice {
/// Pop the pending event.
fn pop_pending_events(&self, handle_event: &impl Fn(&EventBuf) -> bool) {
let mut event_queue = self.event_queue.lock_irq_disabled();
let mut event_queue = self.event_queue.disable_irq().lock();
// one interrupt may contain several input events, so it should loop
while let Ok((token, _)) = event_queue.pop_used() {

15
kernel/comps/virtio/src/device/socket/mod.rs
View File

@ -21,18 +21,19 @@ pub fn register_device(name: String, device: Arc<SpinLock<SocketDevice>>) {
VSOCK_DEVICE_TABLE
.get()
.unwrap()
.lock_irq_disabled()
.disable_irq()
.lock()
.insert(name, (Arc::new(SpinLock::new(Vec::new())), device));
}
pub fn get_device(str: &str) -> Option<Arc<SpinLock<SocketDevice>>> {
let lock = VSOCK_DEVICE_TABLE.get().unwrap().lock_irq_disabled();
let lock = VSOCK_DEVICE_TABLE.get().unwrap().disable_irq().lock();
let (_, device) = lock.get(str)?;
Some(device.clone())
}
pub fn all_devices() -> Vec<(String, Arc<SpinLock<SocketDevice>>)> {
let vsock_devs = VSOCK_DEVICE_TABLE.get().unwrap().lock_irq_disabled();
let vsock_devs = VSOCK_DEVICE_TABLE.get().unwrap().disable_irq().lock();
vsock_devs
.iter()
.map(|(name, (_, device))| (name.clone(), device.clone()))
@ -40,19 +41,19 @@ pub fn all_devices() -> Vec<(String, Arc<SpinLock<SocketDevice>>)> {
}
pub fn register_recv_callback(name: &str, callback: impl VsockDeviceIrqHandler) {
let lock = VSOCK_DEVICE_TABLE.get().unwrap().lock_irq_disabled();
let lock = VSOCK_DEVICE_TABLE.get().unwrap().disable_irq().lock();
let Some((callbacks, _)) = lock.get(name) else {
return;
};
callbacks.lock_irq_disabled().push(Arc::new(callback));
callbacks.disable_irq().lock().push(Arc::new(callback));
}
pub fn handle_recv_irq(name: &str) {
let lock = VSOCK_DEVICE_TABLE.get().unwrap().lock_irq_disabled();
let lock = VSOCK_DEVICE_TABLE.get().unwrap().disable_irq().lock();
let Some((callbacks, _)) = lock.get(name) else {
return;
};
let lock = callbacks.lock_irq_disabled();
let lock = callbacks.disable_irq().lock();
for callback in lock.iter() {
callback.call(())
}