alnyan/yggdrasil
1
0
Fork 0
Code Issues 33 Pull Requests Packages Projects Releases Wiki Activity

scsi: support multiple units per single enclosure

Browse Source
This commit is contained in:
Mark Poliakov 2025-02-07 11:34:57 +02:00
parent 7358852f67
commit 80e5e72bb7
4 changed files with 218 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

225
kernel/driver/block/scsi/src/lib.rs
View File

@ -2,7 +2,11 @@
#![allow(incomplete_features)]
#![no_std]
use core::{mem::MaybeUninit, time::Duration};
use core::{
mem::MaybeUninit,
sync::atomic::{AtomicBool, Ordering},
time::Duration,
};
use alloc::{
boxed::Box, collections::btree_map::BTreeMap, format, string::String, sync::Arc, vec::Vec,
@ -11,11 +15,12 @@ use async_trait::async_trait;
use command::{ScsiReadCapacity, ScsiRequestSense, ScsiTestUnitReady};
use device_api::device::Device;
use libk::{
block,
device::{block::BlockDevice, manager::probe_partitions},
dma::{DmaBuffer, DmaSlice, DmaSliceMut},
error::Error,
fs::devfs,
task::runtime,
task::{runtime, sync::AsyncMutex},
};
use libk_mm::{address::PhysicalAddress, table::MapAttributes, PageProvider};
use libk_util::{
@ -31,27 +36,69 @@ pub mod command;
pub mod device;
pub mod transport;
// TODO SCSI detach
pub struct ScsiDevice {
transport: IrqSafeSpinlock<ScsiTransportWrapper>,
pub struct ScsiEnclosure {
transport: AsyncMutex<ScsiTransportWrapper>,
units: Vec<IrqSafeRwLock<Option<Arc<ScsiUnit>>>>,
index: OneTimeInit<u32>,
shutdown: AtomicBool,
}
pub struct ScsiUnit {
enclosure: Arc<ScsiEnclosure>,
lun: u8,
lba_count: u64,
lba_size: usize,
max_lba_per_request: usize,
index: OneTimeInit<u32>,
names: IrqSafeRwLock<Vec<String>>,
}
impl ScsiDevice {
// TODO support LUNs other than 0
pub async fn setup<T: ScsiTransport + 'static>(transport: T) -> Result<Arc<Self>, Error> {
let mut transport = ScsiTransportWrapper::new(transport);
impl ScsiEnclosure {
pub async fn setup(
transport: Box<dyn ScsiTransport>,
lun_count: usize,
) -> Result<Arc<Self>, Error> {
let transport = AsyncMutex::new(ScsiTransportWrapper::new(transport));
let units = (0..lun_count).map(|_| IrqSafeRwLock::new(None)).collect();
let this = Arc::new(Self {
transport,
units,
index: OneTimeInit::new(),
shutdown: AtomicBool::new(false),
});
register_enclosure(this.clone())?;
let mut attempts = 5;
let mut timeout = 100;
// Probe LUNs
for i in 0..lun_count {
if this.probe_lun(i as u8).await {
if let Ok(unit) = ScsiUnit::setup(this.clone(), i as u8).await {
*this.units[i].write() = Some(unit);
}
}
}
// Start enclosure poll task
let enclosure = this.clone();
runtime::spawn(async move {
while !enclosure.shutdown.load(Ordering::Acquire) {
enclosure.poll().await;
runtime::sleep(Duration::from_millis(100)).await;
}
})
.ok();
Ok(this)
}
async fn probe_lun(self: &Arc<Self>, lun: u8) -> bool {
let mut attempts = 3;
let mut timeout = 10;
// TODO get statuses to better see if there's a real error or the LUN is not present
while attempts > 0 {
let mut transport = self.transport.lock().await;
// TEST UNIT READY (6)
if transport
.perform_command(0, ScsiTestUnitReady)
.perform_command(lun, ScsiTestUnitReady)
.await
.is_ok()
{
@ -59,55 +106,109 @@ impl ScsiDevice {
}
// If not, send a REQUEST SENSE (6)
if transport.perform_command(0, ScsiRequestSense).await.is_ok() {
break;
}
transport.perform_command(lun, ScsiRequestSense).await.ok();
log::warn!("scsi: unit not ready [{attempts}/5]");
drop(transport);
runtime::sleep(Duration::from_millis(timeout)).await;
timeout *= 2;
attempts -= 1;
}
if attempts == 0 {
log::error!("scsi: unit not ready");
return Err(Error::DoesNotExist);
false
} else {
true
}
}
async fn poll(self: &Arc<Self>) {
let index = *self.index.get();
for lun in 0..self.units.len() {
let mut slot = self.units[lun].write();
let present = self.probe_lun(lun as u8).await;
if let Some(unit) = slot.as_ref() {
if !present {
log::warn!("scsi{index}u{lun} lost");
unit.detach();
*slot = None;
}
} else if present {
if let Ok(unit) = ScsiUnit::setup(self.clone(), lun as u8).await {
log::info!("scsi{index}u{lun} attached");
*slot = Some(unit);
} else {
log::warn!("scsi{index}u{lun} attached, but could not setup");
}
}
}
}
pub fn detach(&self) {
self.shutdown.store(true, Ordering::Release);
let index = self.index.try_get().copied();
for unit in self.units.iter() {
if let Some(unit) = unit.write().take() {
unit.detach();
}
}
// Deregister the enclosure
if let Some(index) = index {
remove_enclosure(index);
}
}
}
impl ScsiUnit {
pub async fn setup(enclosure: Arc<ScsiEnclosure>, lun: u8) -> Result<Arc<Self>, Error> {
let enclosure_index = *enclosure.index.get();
let mut transport = enclosure.transport.lock().await;
// TODO INQUIRY fails for real USB flash drives
// transport.perform_command(0, ScsiInquiry).await?;
let capacity_info = transport.perform_command(0, ScsiReadCapacity).await?;
let capacity_info = transport.perform_command(lun, ScsiReadCapacity).await?;
let max_lba_per_request =
transport.max_bytes_per_request() / capacity_info.block_size as usize;
log::info!(
"scsi: lba_size={}, lba_count={}, max_lba_per_request={}",
"scsi{enclosure_index}u{lun}: lba_size={}, lba_count={}, max_lba_per_request={}",
capacity_info.block_size,
capacity_info.block_count,
max_lba_per_request
);
Ok(Arc::new(Self {
transport: IrqSafeSpinlock::new(transport),
drop(transport);
let unit = Arc::new(Self {
enclosure,
lun,
lba_count: capacity_info.block_count.into(),
lba_size: capacity_info.block_size as usize,
max_lba_per_request,
index: OneTimeInit::new(),
names: IrqSafeRwLock::new(Vec::new()),
}))
});
register_unit(enclosure_index, lun, unit.clone());
Ok(unit)
}
pub fn detach(&self) {
if let Some(&index) = self.index.try_get() {
detach(index);
fn detach(&self) {
let id = *self.enclosure.index.get();
log::info!("scsi{id}u{} detached", self.lun);
for name in self.names.read().iter() {
devfs::remove_node(name).ok();
}
}
}
#[async_trait]
impl BlockDevice for ScsiDevice {
impl BlockDevice for ScsiUnit {
fn allocate_buffer(&self, size: usize) -> Result<DmaBuffer<[MaybeUninit<u8>]>, Error> {
self.transport.lock().allocate_buffer(size)
block!(self.enclosure.transport.lock().await.allocate_buffer(size))?
}
async fn read_aligned(
@ -133,7 +234,7 @@ impl BlockDevice for ScsiDevice {
let lba_end = lba_start + lba_count as u64;
let mut transport = self.transport.lock();
let mut transport = self.enclosure.transport.lock().await;
// TODO DmaSliceMut subslicing
let (buffer, range) = buffer.into_parts();
@ -146,7 +247,9 @@ impl BlockDevice for ScsiDevice {
let amount = count * self.lba_size;
let dst_slice = buffer.slice_mut(offset..offset + amount);
let len = transport.read(0, lba, count as u16, dst_slice).await?;
let len = transport
.read(self.lun, lba, count as u16, dst_slice)
.await?;
if len != amount {
return Err(Error::InvalidArgument);
}
@ -174,7 +277,7 @@ impl BlockDevice for ScsiDevice {
}
}
impl PageProvider for ScsiDevice {
impl PageProvider for ScsiUnit {
fn get_page(&self, _offset: u64) -> Result<PhysicalAddress, Error> {
Err(Error::NotImplemented)
}
@ -193,53 +296,57 @@ impl PageProvider for ScsiDevice {
}
}
impl Device for ScsiDevice {
impl Device for ScsiUnit {
fn display_name(&self) -> &str {
"SCSI Storage Device"
"SCSI Unit"
}
}
impl Drop for ScsiDevice {
impl Drop for ScsiUnit {
fn drop(&mut self) {
if let Some(index) = self.index.try_get() {
log::info!("scsi{index} dropped");
if let Some(index) = self.enclosure.index.try_get() {
log::info!("scsi{index}u{} dropped", self.lun);
}
}
}
// TODO this is crap
static SCSI_DEVICES: IrqSafeSpinlock<BTreeMap<u32, Arc<ScsiDevice>>> =
static SCSI_ENCLOSURES: IrqSafeSpinlock<BTreeMap<u32, Arc<ScsiEnclosure>>> =
IrqSafeSpinlock::new(BTreeMap::new());
static SCSI_BITMAP: IrqSafeSpinlock<u32> = IrqSafeSpinlock::new(0);
pub fn attach(device: Arc<ScsiDevice>) -> Result<(), Error> {
fn register_enclosure(enclosure: Arc<ScsiEnclosure>) -> Result<(), Error> {
let index = {
let mut bitmap = SCSI_BITMAP.lock();
let index = (0..8)
.position(|p| *bitmap & (1 << p) == 0)
.ok_or(Error::InvalidOperation)
.inspect_err(|_| log::warn!("Cannot attach SCSI device: too many of them"))?
.inspect_err(|_| log::warn!("Cannot attach SCSI enclosure: too many of them"))?
as u32;
let mut devices = SCSI_DEVICES.lock();
let mut devices = SCSI_ENCLOSURES.lock();
*bitmap |= 1 << index;
assert!(!devices.contains_key(&index));
devices.insert(index, device.clone());
devices.insert(index, enclosure.clone());
index
};
let name = format!("scsi{index}");
device.index.init(index);
device.names.write().push(name.clone());
devfs::add_named_block_device(device.clone(), name.clone(), FileMode::new(0o600)).ok();
log::info!("{name} attached");
enclosure.index.init(index);
Ok(())
}
fn register_unit(enclosure_index: u32, lun: u8, unit: Arc<ScsiUnit>) {
let name = format!("scsi{enclosure_index}u{lun}");
unit.names.write().push(name.clone());
devfs::add_named_block_device(unit.clone(), name.clone(), FileMode::new(0o600)).ok();
// TODO this code is repeated everywhere
runtime::spawn(async move {
let name = name;
probe_partitions(device.clone(), |index, partition| {
probe_partitions(unit.clone(), |index, partition| {
let partition_name = format!("{name}p{}", index + 1);
log::info!("{name}: partition {partition_name}");
device.names.write().push(partition_name.clone());
unit.names.write().push(partition_name.clone());
devfs::add_named_block_device(
Arc::new(partition),
partition_name,
@ -251,23 +358,13 @@ pub fn attach(device: Arc<ScsiDevice>) -> Result<(), Error> {
.ok();
})
.ok();
Ok(())
}
pub fn detach(index: u32) {
let mut devices = SCSI_DEVICES.lock();
fn remove_enclosure(index: u32) {
let mut devices = SCSI_ENCLOSURES.lock();
let mut bitmap = SCSI_BITMAP.lock();
if let Some(device) = devices.remove(&index) {
{
let names = device.names.read();
for name in names.iter() {
devfs::remove_node(name).ok();
}
}
*bitmap &= !(1 << index);
log::info!("scsi{index} detached");
}
devices.remove(&index);
log::info!("scsi: enclosure {index} detached");
}

6
kernel/driver/block/scsi/src/transport.rs
View File

@ -29,10 +29,8 @@ pub struct ScsiTransportWrapper {
}
impl ScsiTransportWrapper {
pub fn new<T: ScsiTransport + 'static>(inner: T) -> Self {
Self {
inner: Box::new(inner),
}
pub fn new(inner: Box<dyn ScsiTransport>) -> Self {
Self { inner }
}
pub async fn read(

51
kernel/driver/bus/usb/src/class_driver/mass_storage.rs
View File

@ -7,7 +7,7 @@ use libk::{
dma::{DmaBuffer, DmaSliceMut},
error::Error,
};
use ygg_driver_scsi::{transport::ScsiTransport, ScsiDevice};
use ygg_driver_scsi::{transport::ScsiTransport, ScsiEnclosure};
use crate::{
communication::UsbDirection,
@ -15,7 +15,7 @@ use crate::{
error::UsbError,
info::{UsbDeviceClass, UsbEndpointType},
pipe::{
control::UsbClassSpecificRequest,
control::{ControlTransferSetup, UsbClassSpecificRequest},
normal::{UsbBulkInPipeAccess, UsbBulkOutPipeAccess},
},
};
@ -56,7 +56,7 @@ struct Bbb {
last_tag: u32,
}
struct DetachHandler(Arc<ScsiDevice>);
struct DetachHandler(Arc<ScsiEnclosure>);
impl Bbb {
pub fn new(
@ -122,7 +122,6 @@ impl Bbb {
return Err(Error::InvalidArgument);
}
if csw.status != 0x00 {
log::warn!("msc: csw error status {:#02x}", csw.status);
return Err(Error::InvalidArgument);
}
Ok(())
@ -150,7 +149,6 @@ impl ScsiTransport for Bbb {
Ok(self.in_pipe.allocate_dma_buffer(size)?)
}
// TODO DMA support for SCSI
async fn perform_request_raw(
&mut self,
lun: u8,
@ -185,11 +183,20 @@ impl UsbDeviceDetachHandler for DetachHandler {
#[repr(C)]
pub struct BulkOnlyMassStorageReset;
#[derive(Debug, Pod, Zeroable, Clone, Copy)]
#[repr(C)]
pub struct GetMaxLun;
impl UsbClassSpecificRequest for BulkOnlyMassStorageReset {
const BM_REQUEST_TYPE: u8 = 0b00100001;
const B_REQUEST: u8 = 0b11111111;
}
impl UsbClassSpecificRequest for GetMaxLun {
const BM_REQUEST_TYPE: u8 = 0b10100001;
const B_REQUEST: u8 = 0b11111110;
}
#[async_trait]
impl UsbDriver for UsbMassStorageDriverBulkOnly {
async fn run(self: Arc<Self>, device: Arc<UsbDeviceAccess>) -> Result<(), UsbError> {
@ -197,7 +204,6 @@ impl UsbDriver for UsbMassStorageDriverBulkOnly {
let config = device.select_configuration(|_| true).await?.unwrap();
// Bulk-in, bulk-out
assert_eq!(config.endpoints.len(), 2);
// TODO those indices may be different
let control_pipe = device.control_pipe();
let (in_index, in_info) = config
.find_endpoint(|ep| ep.is(UsbEndpointType::Bulk, UsbDirection::In))
@ -215,21 +221,44 @@ impl UsbDriver for UsbMassStorageDriverBulkOnly {
// Perform a Bulk-Only Mass Storage Reset
// TODO interface id?
control_pipe
.class_specific_request::<BulkOnlyMassStorageReset>(0, 0)
.control_transfer(ControlTransferSetup {
bm_request_type: BulkOnlyMassStorageReset::BM_REQUEST_TYPE,
b_request: BulkOnlyMassStorageReset::B_REQUEST,
w_value: 0,
w_index: 0,
w_length: 0,
})
.await?;
// TODO get max LUN
// Get max LUN
// TODO on devices which do not support multiple LUNs, this command may STALL
let mut buffer = [MaybeUninit::uninit()];
let len = control_pipe
.control_transfer_in(
ControlTransferSetup {
bm_request_type: GetMaxLun::BM_REQUEST_TYPE,
b_request: GetMaxLun::B_REQUEST,
w_value: 0,
w_index: 0,
w_length: 1,
},
&mut buffer,
)
.await?;
let max_lun = if len < 1 {
0
} else {
unsafe { buffer[0].assume_init() }
};
let bbb = Bbb::new(device.clone(), in_pipe, out_pipe)?;
let scsi = ScsiDevice::setup(bbb)
let scsi = ScsiEnclosure::setup(Box::new(bbb), max_lun as usize + 1)
.await
.inspect_err(|error| log::error!("msc: scsi error {error:?}"))
.map_err(|_| UsbError::DriverError)?;
let detach = DetachHandler(scsi.clone());
device.set_detach_handler(Arc::new(detach));
ygg_driver_scsi::attach(scsi).ok();
Ok(())
}

28
kernel/driver/bus/usb/src/pipe/control.rs
View File

@ -273,20 +273,20 @@ impl UsbControlPipeAccess {
.await
}
pub async fn class_specific_request<D: UsbClassSpecificRequest>(
&self,
w_value: u16,
w_index: u16,
) -> Result<(), UsbError> {
self.control_transfer(ControlTransferSetup {
bm_request_type: D::BM_REQUEST_TYPE,
b_request: D::B_REQUEST,
w_value,
w_index,
w_length: 0,
})
.await
}
// pub async fn class_specific_request<D: UsbClassSpecificRequest>(
// &self,
// w_value: u16,
// w_index: u16,
// ) -> Result<usize, UsbError> {
// self.control_transfer(ControlTransferSetup {
// bm_request_type: D::BM_REQUEST_TYPE,
// b_request: D::B_REQUEST,
// w_value,
// w_index,
// w_length: 0,
// })
// .await
// }
pub async fn set_configuration(&self, value: u16) -> Result<(), UsbError> {
self.perform_action::<SetConfiguration>(value, 0).await