Skip to content
Snippets Groups Projects
Commit 51e03715 authored by Jeremy Soller's avatar Jeremy Soller
Browse files

Merge branch 'master' of https://github.com/redox-os/redoxfs

parents 856db3e2 1a58014d
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
scheme/main.rs
+ 4
− 318
View file @ 51e03715
......@@ -2,335 +2,21 @@ extern crate redoxfs;
extern crate system;
use std::cmp::{min, max};
use std::collections::BTreeMap;
use std::env;
use std::fs::File;
use std::io::{Read, Write};
use std::mem::size_of;
use image::Image;
use scheme::FileScheme;
use redoxfs::{FileSystem, Node};
use redoxfs::FileSystem;
use system::error::{Error, Result, EEXIST, EISDIR, ENOTDIR, EPERM, ENOENT, EBADF, EINVAL};
use system::scheme::{Packet, Scheme};
use system::syscall::{Stat, O_CREAT, SEEK_SET, SEEK_CUR, SEEK_END};
pub mod image;
struct FileResource {
path: String,
data: Vec<u8>,
seek: usize,
}
impl FileResource {
fn new(path: &str, data: Vec<u8>) -> FileResource {
FileResource {
path: path.to_string(),
data: data,
seek: 0,
}
}
fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
let mut i = 0;
while i < buf.len() && self.seek < self.data.len() {
buf[i] = self.data[self.seek];
i += 1;
self.seek += 1;
}
Ok(i)
}
fn write(&mut self, buf: &[u8]) -> Result<usize> {
let mut i = 0;
while i < buf.len() && self.seek < self.data.len() {
self.data[self.seek] = buf[i];
i += 1;
self.seek += 1;
}
Ok(i)
}
fn seek(&mut self, offset: usize, whence: usize) -> Result<usize> {
match whence {
SEEK_SET => {
self.seek = min(0, max(self.data.len() as isize, offset as isize)) as usize;
Ok(self.seek)
},
SEEK_CUR => {
self.seek = min(0, max(self.data.len() as isize, self.seek as isize + offset as isize)) as usize;
Ok(self.seek)
},
SEEK_END => {
self.seek = min(0, max(self.data.len() as isize, self.data.len() as isize + offset as isize)) as usize;
Ok(self.seek)
},
_ => Err(Error::new(EINVAL))
}
}
fn path(&self, buf: &mut [u8]) -> Result<usize> {
let mut i = 0;
let path = self.path.as_bytes();
while i < buf.len() && i < path.len() {
buf[i] = path[i];
i += 1;
}
Ok(i)
}
fn stat(&self, _stat: &mut Stat) -> Result<usize> {
Ok(0)
}
fn sync(&mut self) -> Result<usize> {
Ok(0)
}
fn truncate(&mut self, len: usize) -> Result<usize> {
Ok(0)
}
}
struct FileScheme {
fs: FileSystem,
next_id: isize,
files: BTreeMap<usize, FileResource>
}
impl FileScheme {
fn new(fs: FileSystem) -> FileScheme {
FileScheme {
fs: fs,
next_id: 1,
files: BTreeMap::new()
}
}
fn path_nodes(&mut self, path: &str, nodes: &mut Vec<(u64, Node)>) -> Result<(u64, Node)> {
let mut block = self.fs.header.1.root;
nodes.push(try!(self.fs.node(block)));
for part in path.split('/') {
if ! part.is_empty() {
let node = try!(self.fs.find_node(part, block));
block = node.0;
nodes.push(node);
}
}
Ok(nodes.pop().unwrap())
}
}
impl Scheme for FileScheme {
fn open(&mut self, url: &str, flags: usize, _mode: usize) -> Result<usize> {
let path = url.split(':').nth(1).unwrap_or("").trim_matches('/');
let mut nodes = Vec::new();
let node_result = self.path_nodes(path, &mut nodes);
let mut data = Vec::new();
match node_result {
Ok(node) => if node.1.is_dir() {
let mut children = Vec::new();
try!(self.fs.child_nodes(&mut children, node.0));
for child in children.iter() {
if let Ok(name) = child.1.name() {
if ! data.is_empty() {
data.push('\n' as u8);
}
data.extend_from_slice(&name.as_bytes());
if child.1.is_dir() {
data.push(b'/');
}
}
}
} else {
for i in 0..try!(self.fs.node_len(node.0)) {
let mut sector = [0; 512];
try!(self.fs.read_node(node.0, i as usize * 512, &mut sector));
data.extend_from_slice(&sector);
}
},
Err(err) => if err.errno == ENOENT && flags & O_CREAT == O_CREAT {
let mut last_part = String::new();
for part in path.split('/') {
if ! part.is_empty() {
last_part = part.to_string();
}
}
if ! last_part.is_empty() {
if let Some(parent) = nodes.last() {
try!(self.fs.create_node(Node::MODE_FILE, &last_part, parent.0));
} else {
return Err(Error::new(EPERM));
}
} else {
return Err(Error::new(EPERM));
}
} else {
return Err(err);
}
}
/*
if let Some(arg) = args.next() {
match {
Ok(node) => println!("{}: {:#?}", node.0, node.1),
Err(err) => println!("mk: failed to create {}: {}", arg, err)
}
} else {
println!("mk <file>");
}
*/
let id = self.next_id as usize;
self.next_id += 1;
if self.next_id < 0 {
self.next_id = 1;
}
self.files.insert(id, FileResource::new(url, data));
Ok(id)
}
fn mkdir(&mut self, url: &str, _mode: usize) -> Result<usize> {
let path = url.split(':').nth(1).unwrap_or("").trim_matches('/');
let mut nodes = Vec::new();
match self.path_nodes(path, &mut nodes) {
Ok(_node) => Err(Error::new(EEXIST)),
Err(err) => if err.errno == ENOENT {
let mut last_part = String::new();
for part in path.split('/') {
if ! part.is_empty() {
last_part = part.to_string();
}
}
if ! last_part.is_empty() {
if let Some(parent) = nodes.last() {
self.fs.create_node(Node::MODE_DIR, &last_part, parent.0).and(Ok(0))
} else {
Err(Error::new(EPERM))
}
} else {
Err(Error::new(EPERM))
}
} else {
Err(err)
}
}
}
fn rmdir(&mut self, url: &str) -> Result<usize> {
let path = url.split(':').nth(1).unwrap_or("").trim_matches('/');
let mut nodes = Vec::new();
let child = try!(self.path_nodes(path, &mut nodes));
if let Some(parent) = nodes.last() {
if child.1.is_dir() {
if let Ok(child_name) = child.1.name() {
self.fs.remove_node(Node::MODE_DIR, child_name, parent.0).and(Ok(0))
} else {
Err(Error::new(ENOENT))
}
} else {
Err(Error::new(ENOTDIR))
}
} else {
Err(Error::new(EPERM))
}
}
fn unlink(&mut self, url: &str) -> Result<usize> {
let path = url.split(':').nth(1).unwrap_or("").trim_matches('/');
let mut nodes = Vec::new();
let child = try!(self.path_nodes(path, &mut nodes));
if let Some(parent) = nodes.last() {
if ! child.1.is_dir() {
if let Ok(child_name) = child.1.name() {
self.fs.remove_node(Node::MODE_FILE, child_name, parent.0).and(Ok(0))
} else {
Err(Error::new(ENOENT))
}
} else {
Err(Error::new(EISDIR))
}
} else {
Err(Error::new(EPERM))
}
}
/* Resource operations */
#[allow(unused_variables)]
fn read(&mut self, id: usize, buf: &mut [u8]) -> Result<usize> {
if let Some(mut file) = self.files.get_mut(&id) {
file.read(buf)
} else {
Err(Error::new(EBADF))
}
}
fn write(&mut self, id: usize, buf: &[u8]) -> Result<usize> {
if let Some(mut file) = self.files.get_mut(&id) {
file.write(buf)
} else {
Err(Error::new(EBADF))
}
}
fn seek(&mut self, id: usize, pos: usize, whence: usize) -> Result<usize> {
if let Some(mut file) = self.files.get_mut(&id) {
file.seek(pos, whence)
} else {
Err(Error::new(EBADF))
}
}
fn fpath(&self, id: usize, buf: &mut [u8]) -> Result<usize> {
if let Some(file) = self.files.get(&id) {
file.path(buf)
} else {
Err(Error::new(EBADF))
}
}
fn fstat(&self, id: usize, stat: &mut Stat) -> Result<usize> {
println!("fstat {}, {:X}", id, stat as *mut Stat as usize);
if let Some(file) = self.files.get(&id) {
file.stat(stat)
} else {
Err(Error::new(EBADF))
}
}
fn fsync(&mut self, id: usize) -> Result<usize> {
if let Some(mut file) = self.files.get_mut(&id) {
file.sync()
} else {
Err(Error::new(EBADF))
}
}
fn ftruncate(&mut self, id: usize, len: usize) -> Result<usize> {
if let Some(mut file) = self.files.get_mut(&id) {
file.truncate(len)
} else {
Err(Error::new(EBADF))
}
}
fn close(&mut self, id: usize) -> Result<usize> {
if self.files.remove(&id).is_some() {
Ok(0)
} else {
Err(Error::new(EBADF))
}
}
}
pub mod resource;
pub mod scheme;
fn scheme(fs: FileSystem) {
//In order to handle example:, we create :example
......
scheme/resource.rs 0 → 100644
+ 80
− 0
View file @ 51e03715
use std::cmp::{min, max};
use system::error::{Error, Result, EINVAL};
use system::syscall::{Stat, SEEK_SET, SEEK_CUR, SEEK_END};
pub struct FileResource {
path: String,
data: Vec<u8>,
seek: usize,
}
impl FileResource {
pub fn new(path: &str, data: Vec<u8>) -> FileResource {
FileResource {
path: path.to_string(),
data: data,
seek: 0,
}
}
pub fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
let mut i = 0;
while i < buf.len() && self.seek < self.data.len() {
buf[i] = self.data[self.seek];
i += 1;
self.seek += 1;
}
Ok(i)
}
pub fn write(&mut self, buf: &[u8]) -> Result<usize> {
let mut i = 0;
while i < buf.len() && self.seek < self.data.len() {
self.data[self.seek] = buf[i];
i += 1;
self.seek += 1;
}
Ok(i)
}
pub fn seek(&mut self, offset: usize, whence: usize) -> Result<usize> {
match whence {
SEEK_SET => {
self.seek = min(0, max(self.data.len() as isize, offset as isize)) as usize;
Ok(self.seek)
},
SEEK_CUR => {
self.seek = min(0, max(self.data.len() as isize, self.seek as isize + offset as isize)) as usize;
Ok(self.seek)
},
SEEK_END => {
self.seek = min(0, max(self.data.len() as isize, self.data.len() as isize + offset as isize)) as usize;
Ok(self.seek)
},
_ => Err(Error::new(EINVAL))
}
}
pub fn path(&self, buf: &mut [u8]) -> Result<usize> {
let mut i = 0;
let path = self.path.as_bytes();
while i < buf.len() && i < path.len() {
buf[i] = path[i];
i += 1;
}
Ok(i)
}
pub fn stat(&self, _stat: &mut Stat) -> Result<usize> {
Ok(0)
}
pub fn sync(&mut self) -> Result<usize> {
Ok(0)
}
pub fn truncate(&mut self, len: usize) -> Result<usize> {
Ok(0)
}
}
scheme/scheme.rs 0 → 100644
+ 246
− 0
View file @ 51e03715
use resource::FileResource;
use redoxfs::{FileSystem, Node};
use std::collections::BTreeMap;
use system::error::{Error, Result, EEXIST, EISDIR, ENOTDIR, EPERM, ENOENT, EBADF};
use system::scheme::Scheme;
use system::syscall::{Stat, O_CREAT};
pub struct FileScheme {
fs: FileSystem,
next_id: isize,
files: BTreeMap<usize, FileResource>
}
impl FileScheme {
pub fn new(fs: FileSystem) -> FileScheme {
FileScheme {
fs: fs,
next_id: 1,
files: BTreeMap::new()
}
}
fn path_nodes(&mut self, path: &str, nodes: &mut Vec<(u64, Node)>) -> Result<(u64, Node)> {
let mut block = self.fs.header.1.root;
nodes.push(try!(self.fs.node(block)));
for part in path.split('/') {
if ! part.is_empty() {
let node = try!(self.fs.find_node(part, block));
block = node.0;
nodes.push(node);
}
}
Ok(nodes.pop().unwrap())
}
}
impl Scheme for FileScheme {
fn open(&mut self, url: &str, flags: usize, _mode: usize) -> Result<usize> {
let path = url.split(':').nth(1).unwrap_or("").trim_matches('/');
let mut nodes = Vec::new();
let node_result = self.path_nodes(path, &mut nodes);
let mut data = Vec::new();
match node_result {
Ok(node) => if node.1.is_dir() {
let mut children = Vec::new();
try!(self.fs.child_nodes(&mut children, node.0));
for child in children.iter() {
if let Ok(name) = child.1.name() {
if ! data.is_empty() {
data.push('\n' as u8);
}
data.extend_from_slice(&name.as_bytes());
if child.1.is_dir() {
data.push(b'/');
}
}
}
} else {
for i in 0..try!(self.fs.node_len(node.0)) {
let mut sector = [0; 512];
try!(self.fs.read_node(node.0, i as usize * 512, &mut sector));
data.extend_from_slice(&sector);
}
},
Err(err) => if err.errno == ENOENT && flags & O_CREAT == O_CREAT {
let mut last_part = String::new();
for part in path.split('/') {
if ! part.is_empty() {
last_part = part.to_string();
}
}
if ! last_part.is_empty() {
if let Some(parent) = nodes.last() {
try!(self.fs.create_node(Node::MODE_FILE, &last_part, parent.0));
} else {
return Err(Error::new(EPERM));
}
} else {
return Err(Error::new(EPERM));
}
} else {
return Err(err);
}
}
/*
if let Some(arg) = args.next() {
match {
Ok(node) => println!("{}: {:#?}", node.0, node.1),
Err(err) => println!("mk: failed to create {}: {}", arg, err)
}
} else {
println!("mk <file>");
}
*/
let id = self.next_id as usize;
self.next_id += 1;
if self.next_id < 0 {
self.next_id = 1;
}
self.files.insert(id, FileResource::new(url, data));
Ok(id)
}
fn mkdir(&mut self, url: &str, _mode: usize) -> Result<usize> {
let path = url.split(':').nth(1).unwrap_or("").trim_matches('/');
let mut nodes = Vec::new();
match self.path_nodes(path, &mut nodes) {
Ok(_node) => Err(Error::new(EEXIST)),
Err(err) => if err.errno == ENOENT {
let mut last_part = String::new();
for part in path.split('/') {
if ! part.is_empty() {
last_part = part.to_string();
}
}
if ! last_part.is_empty() {
if let Some(parent) = nodes.last() {
self.fs.create_node(Node::MODE_DIR, &last_part, parent.0).and(Ok(0))
} else {
Err(Error::new(EPERM))
}
} else {
Err(Error::new(EPERM))
}
} else {
Err(err)
}
}
}
fn rmdir(&mut self, url: &str) -> Result<usize> {
let path = url.split(':').nth(1).unwrap_or("").trim_matches('/');
let mut nodes = Vec::new();
let child = try!(self.path_nodes(path, &mut nodes));
if let Some(parent) = nodes.last() {
if child.1.is_dir() {
if let Ok(child_name) = child.1.name() {
self.fs.remove_node(Node::MODE_DIR, child_name, parent.0).and(Ok(0))
} else {
Err(Error::new(ENOENT))
}
} else {
Err(Error::new(ENOTDIR))
}
} else {
Err(Error::new(EPERM))
}
}
fn unlink(&mut self, url: &str) -> Result<usize> {
let path = url.split(':').nth(1).unwrap_or("").trim_matches('/');
let mut nodes = Vec::new();
let child = try!(self.path_nodes(path, &mut nodes));
if let Some(parent) = nodes.last() {
if ! child.1.is_dir() {
if let Ok(child_name) = child.1.name() {
self.fs.remove_node(Node::MODE_FILE, child_name, parent.0).and(Ok(0))
} else {
Err(Error::new(ENOENT))
}
} else {
Err(Error::new(EISDIR))
}
} else {
Err(Error::new(EPERM))
}
}
/* Resource operations */
#[allow(unused_variables)]
fn read(&mut self, id: usize, buf: &mut [u8]) -> Result<usize> {
if let Some(mut file) = self.files.get_mut(&id) {
file.read(buf)
} else {
Err(Error::new(EBADF))
}
}
fn write(&mut self, id: usize, buf: &[u8]) -> Result<usize> {
if let Some(mut file) = self.files.get_mut(&id) {
file.write(buf)
} else {
Err(Error::new(EBADF))
}
}
fn seek(&mut self, id: usize, pos: usize, whence: usize) -> Result<usize> {
if let Some(mut file) = self.files.get_mut(&id) {
file.seek(pos, whence)
} else {
Err(Error::new(EBADF))
}
}
fn fpath(&self, id: usize, buf: &mut [u8]) -> Result<usize> {
if let Some(file) = self.files.get(&id) {
file.path(buf)
} else {
Err(Error::new(EBADF))
}
}
fn fstat(&self, id: usize, stat: &mut Stat) -> Result<usize> {
println!("fstat {}, {:X}", id, stat as *mut Stat as usize);
if let Some(file) = self.files.get(&id) {
file.stat(stat)
} else {
Err(Error::new(EBADF))
}
}
fn fsync(&mut self, id: usize) -> Result<usize> {
if let Some(mut file) = self.files.get_mut(&id) {
file.sync()
} else {
Err(Error::new(EBADF))
}
}
fn ftruncate(&mut self, id: usize, len: usize) -> Result<usize> {
if let Some(mut file) = self.files.get_mut(&id) {
file.truncate(len)
} else {
Err(Error::new(EBADF))
}
}
fn close(&mut self, id: usize) -> Result<usize> {
if self.files.remove(&id).is_some() {
Ok(0)
} else {
Err(Error::new(EBADF))
}
}
}
src/ex_node.rs
+ 1
− 1
View file @ 51e03715
......@@ -56,5 +56,5 @@ impl ops::DerefMut for ExNode {
#[test]
fn ex_node_size_test(){
assert!(mem::size_of::<ExNode>() <= 512);
assert_eq!(mem::size_of::<ExNode>(), 512);
}
src/node.rs
+ 20
− 8
View file @ 51e03715
......@@ -8,10 +8,13 @@ use super::Extent;
#[repr(packed)]
pub struct Node {
pub mode: u16,
pub name: [u8; 254],
pub user: u16,
pub group: u16,
pub size: u64,
pub name: [u8; 258],
pub parent: u64,
pub next: u64,
pub extents: [Extent; 15],
pub extents: [Extent; 14],
}
impl Node {
......@@ -24,25 +27,31 @@ impl Node {
pub fn default() -> Node {
Node {
mode: 0,
name: [0; 254],
user: 0,
group: 0,
size: 0,
name: [0; 258],
parent: 0,
next: 0,
extents: [Extent::default(); 15]
extents: [Extent::default(); 14],
}
}
pub fn new(mode: u16, name: &str, parent: u64) -> Node {
let mut bytes = [0; 254];
let mut bytes = [0; 258];
for (mut b, c) in bytes.iter_mut().zip(name.bytes()) {
*b = c;
}
Node {
mode: mode,
user: 0,
group: 0,
size: 0,
name: bytes,
parent: parent,
next: 0,
extents: [Extent::default(); 15]
extents: [Extent::default(); 14],
}
}
......@@ -76,8 +85,11 @@ impl fmt::Debug for Node {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let extents: Vec<&Extent> = self.extents.iter().filter(|extent| -> bool { extent.length > 0 }).collect();
f.debug_struct("Node")
.field("name", &self.name())
.field("mode", &self.mode)
.field("user", &self.user)
.field("group", &self.group)
.field("size", &self.size)
.field("name", &self.name())
.field("next", &self.next)
.field("extents", &extents)
.finish()
......@@ -103,5 +115,5 @@ impl ops::DerefMut for Node {
#[test]
fn node_size_test(){
assert!(mem::size_of::<Node>() <= 512);
assert_eq!(mem::size_of::<Node>(), 512);
}
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment