vasilito/RedBear-OS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Properly pass POSITIONED new fd flag.

Browse Source
This commit is contained in:
4lDO2
2024-06-12 17:45:24 +02:00
parent 0058d7c948
commit 2b146f8778
4 changed files with 127 additions and 139 deletions
Download Patch File Download Diff File Expand all files Collapse all files
storage/ahcid/src/scheme.rs
+52 -61
View File
@@ -3,11 +3,12 @@ use std::str;
use std::fmt::Write;
use driver_block::{Disk, DiskWrapper};
use syscall::schemev2::NewFdFlags;
use syscall::{
Error, EACCES, EBADF, EINVAL, EISDIR, ENOENT, ENOLCK, EOVERFLOW, Result, Io, Stat, MODE_DIR,
MODE_FILE, O_DIRECTORY, O_STAT,
};
use redox_scheme::SchemeBlockMut;
use redox_scheme::{CallerCtx, OpenResult, SchemeBlockMut};
use crate::ahci::hba::HbaMem;
@@ -81,74 +82,64 @@ impl DiskScheme {
}
impl SchemeBlockMut for DiskScheme {
fn open(&mut self, path: &str, flags: usize, uid: u32, _gid: u32) -> Result<Option<usize>> {
if uid == 0 {
let path_str = path.trim_matches('/');
if path_str.is_empty() {
if flags & O_DIRECTORY == O_DIRECTORY || flags & O_STAT == O_STAT {
let mut list = String::new();
fn xopen(&mut self, path: &str, flags: usize, ctx: &CallerCtx) -> Result<Option<OpenResult>> {
if ctx.uid != 0 {
return Err(Error::new(EACCES));
}
let path_str = path.trim_matches('/');
for (disk_index, disk) in self.disks.iter().enumerate() {
write!(list, "{}\n", disk_index).unwrap();
let handle = if path_str.is_empty() {
if flags & O_DIRECTORY != O_DIRECTORY && flags & O_STAT != O_STAT {
return Err(Error::new(EISDIR));
}
let mut list = String::new();
if disk.pt.is_none() {
continue
}
for part_index in 0..disk.pt.as_ref().unwrap().partitions.len() {
write!(list, "{}p{}\n", disk_index, part_index).unwrap();
}
}
for (disk_index, disk) in self.disks.iter().enumerate() {
write!(list, "{}\n", disk_index).unwrap();
let id = self.next_id;
self.next_id += 1;
self.handles.insert(id, Handle::List(list.into_bytes()));
Ok(Some(id))
} else {
Err(Error::new(EISDIR))
if disk.pt.is_none() {
continue
}
} else if let Some(p_pos) = path_str.chars().position(|c| c == 'p') {
let disk_id_str = &path_str[..p_pos];
if p_pos + 1 >= path_str.len() {
return Err(Error::new(ENOENT));
}
let part_id_str = &path_str[p_pos + 1..];
let i = disk_id_str.parse::<usize>().or(Err(Error::new(ENOENT)))?;
let p = part_id_str.parse::<u32>().or(Err(Error::new(ENOENT)))?;
if let Some(disk) = self.disks.get(i) {
if disk.pt.is_none() || disk.pt.as_ref().unwrap().partitions.get(p as usize).is_none() {
return Err(Error::new(ENOENT));
}
self.check_locks(i, Some(p))?;
let id = self.next_id;
self.next_id += 1;
self.handles.insert(id, Handle::Partition(i, p));
Ok(Some(id))
} else {
Err(Error::new(ENOENT))
}
} else {
let i = path_str.parse::<usize>().or(Err(Error::new(ENOENT)))?;
if self.disks.get(i).is_some() {
self.check_locks(i, None)?;
let id = self.next_id;
self.next_id += 1;
self.handles.insert(id, Handle::Disk(i));
Ok(Some(id))
} else {
Err(Error::new(ENOENT))
for part_index in 0..disk.pt.as_ref().unwrap().partitions.len() {
write!(list, "{}p{}\n", disk_index, part_index).unwrap();
}
}
Handle::List(list.into_bytes())
} else if let Some(p_pos) = path_str.chars().position(|c| c == 'p') {
let disk_id_str = &path_str[..p_pos];
if p_pos + 1 >= path_str.len() {
return Err(Error::new(ENOENT));
}
let part_id_str = &path_str[p_pos + 1..];
let i = disk_id_str.parse::<usize>().or(Err(Error::new(ENOENT)))?;
let p = part_id_str.parse::<u32>().or(Err(Error::new(ENOENT)))?;
let disk = self.disks.get(i).ok_or(Error::new(ENOENT))?;
if disk.pt.is_none() || disk.pt.as_ref().unwrap().partitions.get(p as usize).is_none() {
return Err(Error::new(ENOENT));
}
self.check_locks(i, Some(p))?;
Handle::Partition(i, p)
} else {
Err(Error::new(EACCES))
}
let i = path_str.parse::<usize>().or(Err(Error::new(ENOENT)))?;
if self.disks.get(i).is_none() {
return Err(Error::new(ENOENT));
}
self.check_locks(i, None)?;
Handle::Disk(i)
};
let id = self.next_id;
self.next_id += 1;
self.handles.insert(id, handle);
Ok(Some(OpenResult::ThisScheme { number: id, flags: NewFdFlags::POSITIONED }))
}
fn dup(&mut self, id: usize, buf: &[u8]) -> Result<Option<usize>> {
fn xdup(&mut self, id: usize, buf: &[u8], _: &CallerCtx) -> Result<Option<OpenResult>> {
if ! buf.is_empty() {
return Err(Error::new(EINVAL));
}
@@ -161,7 +152,7 @@ impl SchemeBlockMut for DiskScheme {
let new_id = self.next_id;
self.next_id += 1;
self.handles.insert(new_id, new_handle);
Ok(Some(new_id))
Ok(Some(OpenResult::ThisScheme { number: new_id, flags: NewFdFlags::POSITIONED }))
}
fn fstat(&mut self, id: usize, stat: &mut Stat) -> Result<Option<usize>> {
storage/nvmed/src/scheme.rs
+61 -67
View File
@@ -6,11 +6,12 @@ use std::io::prelude::*;
use std::sync::Arc;
use std::{cmp, str};
use syscall::schemev2::NewFdFlags;
use syscall::{
Error, Io, Result, Stat, EACCES, EBADF, EINVAL, EISDIR, ENOENT, ENOLCK, EOVERFLOW, MODE_DIR,
MODE_FILE, O_DIRECTORY, O_STAT, SEEK_CUR, SEEK_END, SEEK_SET,
};
use redox_scheme::SchemeBlockMut;
use redox_scheme::{CallerCtx, OpenResult, SchemeBlockMut};
use crate::nvme::{Nvme, NvmeNamespace};
@@ -184,82 +185,75 @@ impl DiskScheme {
}
impl SchemeBlockMut for DiskScheme {
fn open(&mut self, path_str: &str, flags: usize, uid: u32, _gid: u32) -> Result<Option<usize>> {
if uid == 0 {
let path_str = path_str
.trim_matches('/');
if path_str.is_empty() {
if flags & O_DIRECTORY == O_DIRECTORY || flags & O_STAT == O_STAT {
let mut list = String::new();
fn xopen(&mut self, path_str: &str, flags: usize, ctx: &CallerCtx) -> Result<Option<OpenResult>> {
if ctx.uid != 0 {
return Err(Error::new(EACCES));
}
let path_str = path_str
.trim_matches('/');
for (nsid, disk) in self.disks.iter() {
write!(list, "{}\n", nsid).unwrap();
let handle = if path_str.is_empty() {
if flags & O_DIRECTORY == O_DIRECTORY || flags & O_STAT == O_STAT {
let mut list = String::new();
if disk.pt.is_none() {
continue;
}
for part_num in 0..disk.pt.as_ref().unwrap().partitions.len() {
write!(list, "{}p{}\n", nsid, part_num).unwrap();
}
for (nsid, disk) in self.disks.iter() {
write!(list, "{}\n", nsid).unwrap();
if disk.pt.is_none() {
continue;
}
for part_num in 0..disk.pt.as_ref().unwrap().partitions.len() {
write!(list, "{}p{}\n", nsid, part_num).unwrap();
}
let id = self.next_id;
self.next_id += 1;
self.handles.insert(id, Handle::List(list.into_bytes()));
Ok(Some(id))
} else {
Err(Error::new(EISDIR))
}
} else if let Some(p_pos) = path_str.chars().position(|c| c == 'p') {
let nsid_str = &path_str[..p_pos];
if p_pos + 1 >= path_str.len() {
Handle::List(list.into_bytes())
} else {
return Err(Error::new(EISDIR));
}
} else if let Some(p_pos) = path_str.chars().position(|c| c == 'p') {
let nsid_str = &path_str[..p_pos];
if p_pos + 1 >= path_str.len() {
return Err(Error::new(ENOENT));
}
let part_num_str = &path_str[p_pos + 1..];
let nsid = nsid_str.parse::<u32>().or(Err(Error::new(ENOENT)))?;
let part_num = part_num_str.parse::<u32>().or(Err(Error::new(ENOENT)))?;
if let Some(disk) = self.disks.get(&nsid) {
if disk
.pt
.as_ref()
.ok_or(Error::new(ENOENT))?
.partitions
.get(part_num as usize)
.is_some()
{
self.check_locks(nsid, Some(part_num))?;
Handle::Partition(nsid, part_num)
} else {
return Err(Error::new(ENOENT));
}
let part_num_str = &path_str[p_pos + 1..];
let nsid = nsid_str.parse::<u32>().or(Err(Error::new(ENOENT)))?;
let part_num = part_num_str.parse::<u32>().or(Err(Error::new(ENOENT)))?;
if let Some(disk) = self.disks.get(&nsid) {
if disk
.pt
.as_ref()
.ok_or(Error::new(ENOENT))?
.partitions
.get(part_num as usize)
.is_some()
{
self.check_locks(nsid, Some(part_num))?;
let id = self.next_id;
self.next_id += 1;
self.handles
.insert(id, Handle::Partition(nsid, part_num));
Ok(Some(id))
} else {
Err(Error::new(ENOENT))
}
} else {
Err(Error::new(ENOENT))
}
} else {
let nsid = path_str.parse::<u32>().or(Err(Error::new(ENOENT)))?;
if self.disks.contains_key(&nsid) {
self.check_locks(nsid, None)?;
let id = self.next_id;
self.next_id += 1;
self.handles.insert(id, Handle::Disk(nsid));
Ok(Some(id))
} else {
Err(Error::new(ENOENT))
}
return Err(Error::new(ENOENT));
}
} else {
Err(Error::new(EACCES))
}
let nsid = path_str.parse::<u32>().or(Err(Error::new(ENOENT)))?;
if self.disks.contains_key(&nsid) {
self.check_locks(nsid, None)?;
Handle::Disk(nsid)
} else {
return Err(Error::new(ENOENT));
}
};
let id = self.next_id;
self.next_id += 1;
self.handles.insert(id, handle);
Ok(Some(OpenResult::ThisScheme { number: id, flags: NewFdFlags::POSITIONED }))
}
fn dup(&mut self, id: usize, buf: &[u8]) -> Result<Option<usize>> {
storage/usbscsid/src/scheme.rs
+5 -4
View File
@@ -4,12 +4,13 @@ use std::{cmp, str};
use crate::protocol::Protocol;
use crate::scsi::Scsi;
use redox_scheme::SchemeMut;
use redox_scheme::{CallerCtx, OpenResult, SchemeMut};
use syscall::error::{Error, Result};
use syscall::error::{EACCES, EBADF, EINVAL, EIO, ENOENT, ENOSYS};
use syscall::flag::{MODE_CHR, MODE_DIR};
use syscall::flag::{O_DIRECTORY, O_STAT};
use syscall::flag::{SEEK_CUR, SEEK_END, SEEK_SET};
use syscall::schemev2::NewFdFlags;
// TODO: Only one disk, right?
const LIST_CONTENTS: &'static [u8] = b"0\n";
@@ -39,8 +40,8 @@ impl<'a> ScsiScheme<'a> {
}
impl SchemeMut for ScsiScheme<'_> {
fn open(&mut self, path_str: &str, flags: usize, uid: u32, _gid: u32) -> Result<usize> {
if uid != 0 {
fn xopen(&mut self, path_str: &str, flags: usize, ctx: &CallerCtx) -> Result<OpenResult> {
if ctx.uid != 0 {
return Err(Error::new(EACCES));
}
if flags & O_DIRECTORY != 0 && flags & O_STAT == 0 {
@@ -59,7 +60,7 @@ impl SchemeMut for ScsiScheme<'_> {
};
self.next_fd += 1;
self.handles.insert(self.next_fd, handle);
Ok(self.next_fd)
Ok(OpenResult::ThisScheme { number: self.next_fd, flags: NewFdFlags::POSITIONED })
}
fn fstat(&mut self, fd: usize, stat: &mut syscall::Stat) -> Result<usize> {
match self.handles.get(&fd).ok_or(Error::new(EBADF))? {
storage/virtio-blkd/src/scheme.rs
+9 -7
View File
@@ -11,9 +11,12 @@ use common::dma::Dma;
use partitionlib::LogicalBlockSize;
use partitionlib::PartitionTable;
use redox_scheme::CallerCtx;
use redox_scheme::OpenResult;
use redox_scheme::SchemeBlockMut;
use syscall::flag::*;
use syscall::error::*;
use syscall::schemev2::NewFdFlags;
use virtio_core::spec::{Buffer, ChainBuilder, DescriptorFlags};
use virtio_core::transport::Queue;
@@ -190,13 +193,12 @@ impl<'a> DiskScheme<'a> {
}
impl<'a> SchemeBlockMut for DiskScheme<'a> {
fn open(
fn xopen(
&mut self,
path: &str,
flags: usize,
_uid: u32,
_gid: u32,
) -> syscall::Result<Option<usize>> {
_ctx: &CallerCtx,
) -> syscall::Result<Option<OpenResult>> {
log::info!("virtiod: open: {}", path);
let path_str = path.trim_matches('/');
@@ -222,7 +224,7 @@ impl<'a> SchemeBlockMut for DiskScheme<'a> {
},
);
Ok(Some(id))
Ok(Some(OpenResult::ThisScheme { number: id, flags: NewFdFlags::POSITIONED }))
} else {
return Err(syscall::Error::new(EISDIR));
}
@@ -247,7 +249,7 @@ impl<'a> SchemeBlockMut for DiskScheme<'a> {
},
);
Ok(Some(id))
Ok(Some(OpenResult::ThisScheme { number: id, flags: NewFdFlags::POSITIONED }))
} else {
let nsid = path_str.parse::<u32>().unwrap();
assert_eq!(nsid, 0);
@@ -255,7 +257,7 @@ impl<'a> SchemeBlockMut for DiskScheme<'a> {
let id = self.next_id;
self.next_id += 1;
self.handles.insert(id, Handle::Disk);
Ok(Some(id))
Ok(Some(OpenResult::ThisScheme { number: id, flags: NewFdFlags::POSITIONED }))
}
}