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

Update spin lock users to lock_irq_disabled()

Browse Source
This commit is contained in:
Chuandong Li
2023-07-02 18:31:53 +08:00
committed by Tate, Hongliang Tian
parent ba4121cd6a
commit 78de1af348
15 changed files with 69 additions and 59 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
services/libs/jinux-std/src/device/tty/driver.rs
View File

@ -30,7 +30,7 @@ impl TtyDriver {
/// Return the tty device in driver's internal table.
pub fn lookup(&self, index: usize) -> Result<Arc<Tty>> {
let ttys = self.ttys.lock();
let ttys = self.ttys.lock_irq_disabled();
// Return the tty device corresponding to idx
if index >= ttys.len() {
return_errno_with_message!(Errno::ENODEV, "lookup failed. No tty device");
@ -43,12 +43,12 @@ impl TtyDriver {
/// Install a new tty into the driver's internal tables.
pub fn install(self: &Arc<Self>, tty: Arc<Tty>) {
tty.set_driver(Arc::downgrade(self));
self.ttys.lock().push(tty);
self.ttys.lock_irq_disabled().push(tty);
}
/// remove a new tty into the driver's internal tables.
pub fn remove(&self, index: usize) -> Result<()> {
let mut ttys = self.ttys.lock();
let mut ttys = self.ttys.lock_irq_disabled();
if index >= ttys.len() {
return_errno_with_message!(Errno::ENODEV, "lookup failed. No tty device");
}
@ -60,7 +60,7 @@ impl TtyDriver {
pub fn receive_char(&self, item: u8) {
// FIXME: should the char send to all ttys?
for tty in &*self.ttys.lock() {
for tty in &*self.ttys.lock_irq_disabled() {
tty.receive_char(item);
}
}

42
services/libs/jinux-std/src/device/tty/line_discipline.rs
View File

@ -75,7 +75,7 @@ impl LineDiscipline {
/// push char to line discipline. This function should be called in input interrupt handler.
pub fn push_char(&self, mut item: u8) {
let termios = self.termios.lock();
let termios = self.termios.lock_irq_disabled();
if termios.contains_icrnl() {
if item == b'\r' {
item = b'\n'
@ -85,7 +85,7 @@ impl LineDiscipline {
if item == *termios.get_special_char(CC_C_CHAR::VINTR) {
// type Ctrl + C, signal SIGINT
if termios.contains_isig() {
if let Some(fg) = *self.foreground.lock() {
if let Some(fg) = *self.foreground.lock_irq_disabled() {
let kernel_signal = KernelSignal::new(SIGINT);
let fg_group = process_table::pgid_to_process_group(fg).unwrap();
fg_group.kernel_signal(kernel_signal);
@ -94,7 +94,7 @@ impl LineDiscipline {
} else if item == *termios.get_special_char(CC_C_CHAR::VQUIT) {
// type Ctrl + \, signal SIGQUIT
if termios.contains_isig() {
if let Some(fg) = *self.foreground.lock() {
if let Some(fg) = *self.foreground.lock_irq_disabled() {
let kernel_signal = KernelSignal::new(SIGQUIT);
let fg_group = process_table::pgid_to_process_group(fg).unwrap();
fg_group.kernel_signal(kernel_signal);
@ -102,29 +102,29 @@ impl LineDiscipline {
}
} else if item == *termios.get_special_char(CC_C_CHAR::VKILL) {
// erase current line
self.current_line.lock().drain();
self.current_line.lock_irq_disabled().drain();
} else if item == *termios.get_special_char(CC_C_CHAR::VERASE) {
// type backspace
let mut current_line = self.current_line.lock();
let mut current_line = self.current_line.lock_irq_disabled();
if !current_line.is_empty() {
current_line.backspace();
}
} else if meet_new_line(item, &termios) {
// a new line was met. We currently add the item to buffer.
// when we read content, the item should be skipped if it's EOF.
let mut current_line = self.current_line.lock();
let mut current_line = self.current_line.lock_irq_disabled();
current_line.push_char(item);
let current_line_chars = current_line.drain();
for char in current_line_chars {
self.read_buffer.lock().push_overwrite(char);
self.read_buffer.lock_irq_disabled().push_overwrite(char);
}
} else if item >= 0x20 && item < 0x7f {
// printable character
self.current_line.lock().push_char(item);
self.current_line.lock_irq_disabled().push_char(item);
}
} else {
// raw mode
self.read_buffer.lock().push_overwrite(item);
self.read_buffer.lock_irq_disabled().push_overwrite(item);
// debug!("push char: {}", char::from(item))
}
@ -139,7 +139,7 @@ impl LineDiscipline {
/// whether self is readable
fn is_readable(&self) -> bool {
!self.read_buffer.lock().is_empty()
!self.read_buffer.lock_irq_disabled().is_empty()
}
// TODO: respect output flags
@ -201,13 +201,13 @@ impl LineDiscipline {
}
let (vmin, vtime) = {
let termios = self.termios.lock();
let termios = self.termios.lock_irq_disabled();
let vmin = *termios.get_special_char(CC_C_CHAR::VMIN);
let vtime = *termios.get_special_char(CC_C_CHAR::VTIME);
(vmin, vtime)
};
let read_len = {
let len = self.read_buffer.lock().len();
let len = self.read_buffer.lock_irq_disabled().len();
let max_read_len = len.min(dst.len());
if vmin == 0 && vtime == 0 {
// poll read
@ -236,7 +236,7 @@ impl LineDiscipline {
/// returns immediately with the lesser of the number of bytes available or the number of bytes requested.
/// If no bytes are available, completes immediately, returning 0.
fn poll_read(&self, dst: &mut [u8]) -> usize {
let mut buffer = self.read_buffer.lock();
let mut buffer = self.read_buffer.lock_irq_disabled();
let len = buffer.len();
let max_read_len = len.min(dst.len());
if max_read_len == 0 {
@ -245,7 +245,7 @@ impl LineDiscipline {
let mut read_len = 0;
for i in 0..max_read_len {
if let Some(next_char) = buffer.pop() {
let termios = self.termios.lock();
let termios = self.termios.lock_irq_disabled();
if termios.is_canonical_mode() {
// canonical mode, read until meet new line
if meet_new_line(next_char, &termios) {
@ -276,7 +276,7 @@ impl LineDiscipline {
// MIN bytes are available, and returns the lesser of the two values.
pub fn block_read(&self, dst: &mut [u8], vmin: u8) -> Result<usize> {
let min_read_len = (vmin as usize).min(dst.len());
let buffer_len = self.read_buffer.lock().len();
let buffer_len = self.read_buffer.lock_irq_disabled().len();
if buffer_len < min_read_len {
return_errno!(Errno::EAGAIN);
}
@ -291,7 +291,7 @@ impl LineDiscipline {
/// whether the current process belongs to foreground process group
fn current_belongs_to_foreground(&self) -> bool {
let current = current!();
if let Some(fg_pgid) = *self.foreground.lock() {
if let Some(fg_pgid) = *self.foreground.lock_irq_disabled() {
if let Some(process_group) = process_table::pgid_to_process_group(fg_pgid) {
if process_group.contains_process(current.pid()) {
return true;
@ -304,7 +304,7 @@ impl LineDiscipline {
/// set foreground process group
pub fn set_fg(&self, fg_pgid: Pgid) {
*self.foreground.lock() = Some(fg_pgid);
*self.foreground.lock_irq_disabled() = Some(fg_pgid);
// Some background processes may be waiting on the wait queue, when set_fg, the background processes may be able to read.
if self.is_readable() {
self.pollee.add_events(IoEvents::IN);
@ -313,20 +313,20 @@ impl LineDiscipline {
/// get foreground process group id
pub fn fg_pgid(&self) -> Option<Pgid> {
*self.foreground.lock()
*self.foreground.lock_irq_disabled()
}
/// whether there is buffered data
pub fn is_empty(&self) -> bool {
self.read_buffer.lock().len() == 0
self.read_buffer.lock_irq_disabled().len() == 0
}
pub fn termios(&self) -> KernelTermios {
*self.termios.lock()
*self.termios.lock_irq_disabled()
}
pub fn set_termios(&self, termios: KernelTermios) {
*self.termios.lock() = termios;
*self.termios.lock_irq_disabled() = termios;
}
}

2
services/libs/jinux-std/src/device/tty/mod.rs
View File

@ -45,7 +45,7 @@ impl Tty {
}
pub fn set_driver(&self, driver: Weak<TtyDriver>) {
*self.driver.lock() = driver;
*self.driver.lock_irq_disabled() = driver;
}
pub fn receive_char(&self, item: u8) {

22
services/libs/jinux-std/src/net/iface/common.rs
View File

@ -38,20 +38,20 @@ impl IfaceCommon {
}
}
pub(super) fn interface(&self) -> SpinLockGuard<smoltcp::iface::Interface> {
self.interface.lock()
pub(super) fn interface(&self) -> SpinLockIrqDisabledGuard<smoltcp::iface::Interface> {
self.interface.lock_irq_disabled()
}
pub(super) fn sockets(&self) -> SpinLockGuard<smoltcp::iface::SocketSet<'static>> {
self.sockets.lock()
pub(super) fn sockets(&self) -> SpinLockIrqDisabledGuard<smoltcp::iface::SocketSet<'static>> {
self.sockets.lock_irq_disabled()
}
pub(super) fn ipv4_addr(&self) -> Option<Ipv4Address> {
self.interface.lock().ipv4_addr()
self.interface.lock_irq_disabled().ipv4_addr()
}
pub(super) fn netmask(&self) -> Option<Ipv4Address> {
let interface = self.interface.lock();
let interface = self.interface.lock_irq_disabled();
let ip_addrs = interface.ip_addrs();
ip_addrs.first().map(|cidr| match cidr {
IpCidr::Ipv4(ipv4_cidr) => ipv4_cidr.netmask(),
@ -113,7 +113,7 @@ impl IfaceCommon {
}
let socket_family = socket.socket_family();
let pollee = socket.pollee();
let mut sockets = self.sockets.lock();
let mut sockets = self.sockets.lock_irq_disabled();
let handle = match socket.raw_socket_family() {
AnyRawSocket::Tcp(tcp_socket) => sockets.add(tcp_socket),
AnyRawSocket::Udp(udp_socket) => sockets.add(udp_socket),
@ -125,14 +125,14 @@ impl IfaceCommon {
/// Remove a socket from the interface
pub(super) fn remove_socket(&self, handle: SocketHandle) {
self.sockets.lock().remove(handle);
self.sockets.lock_irq_disabled().remove(handle);
}
pub(super) fn poll<D: Device + ?Sized>(&self, device: &mut D) {
let mut interface = self.interface.lock();
let mut interface = self.interface.lock_irq_disabled();
let timestamp = get_network_timestamp();
let has_events = {
let mut sockets = self.sockets.lock();
let mut sockets = self.sockets.lock_irq_disabled();
interface.poll(timestamp, device, &mut sockets)
// drop sockets here to avoid deadlock
};
@ -143,7 +143,7 @@ impl IfaceCommon {
});
}
let sockets = self.sockets.lock();
let sockets = self.sockets.lock_irq_disabled();
if let Some(instant) = interface.poll_at(timestamp, &sockets) {
self.next_poll_at_ms
.store(instant.total_millis() as u64, Ordering::SeqCst);

4
services/libs/jinux-std/src/net/iface/mod.rs
View File

@ -65,11 +65,11 @@ mod internal {
pub trait IfaceInternal {
fn common(&self) -> &IfaceCommon;
/// The inner socket set
fn sockets(&self) -> SpinLockGuard<SocketSet<'static>> {
fn sockets(&self) -> SpinLockIrqDisabledGuard<SocketSet<'static>> {
self.common().sockets()
}
/// The inner iface.
fn iface_inner(&self) -> SpinLockGuard<smoltcp::iface::Interface> {
fn iface_inner(&self) -> SpinLockIrqDisabledGuard<smoltcp::iface::Interface> {
self.common().interface()
}
/// The time we should do another poll.

2
services/libs/jinux-std/src/net/iface/virtio.rs
View File

@ -112,7 +112,7 @@ impl Iface for IfaceVirtio {
}
fn poll(&self) {
let mut driver = self.driver.lock();
let mut driver = self.driver.lock_irq_disabled();
self.common.poll(&mut *driver);
self.process_dhcp();
}

2
services/libs/jinux-std/src/prelude.rs
View File

@ -18,7 +18,7 @@ pub(crate) use core::ffi::CStr;
pub(crate) use int_to_c_enum::TryFromInt;
pub(crate) use jinux_frame::config::PAGE_SIZE;
// pub(crate) use jinux_frame::sync::{Mutex, MutexGuard};
pub(crate) use jinux_frame::sync::{SpinLock, SpinLockGuard};
pub(crate) use jinux_frame::sync::{SpinLock, SpinLockGuard, SpinLockIrqDisabledGuard};
pub(crate) use jinux_frame::vm::Vaddr;
pub(crate) use jinux_frame::{print, println};
pub(crate) use log::{debug, error, info, trace, warn};