Skip to content
GitLab
Projects
Groups
Snippets
Help
Loading...
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in / Register
Toggle navigation
R
redoxfs
Project overview
Project overview
Details
Activity
Releases
Repository
Repository
Files
Commits
Branches
Tags
Contributors
Graph
Compare
Issues
5
Issues
5
List
Boards
Labels
Service Desk
Milestones
Merge Requests
3
Merge Requests
3
CI / CD
CI / CD
Pipelines
Jobs
Schedules
Operations
Operations
Incidents
Environments
Packages & Registries
Packages & Registries
Container Registry
Analytics
Analytics
CI / CD
Repository
Value Stream
Wiki
Wiki
Snippets
Snippets
Members
Members
Collapse sidebar
Close sidebar
Activity
Graph
Create a new issue
Jobs
Commits
Issue Boards
Open sidebar
redox-os
redoxfs
Commits
80e3a346
Commit
80e3a346
authored
Jan 20, 2020
by
Jeremy Soller
Browse files
Options
Browse Files
Download
Plain Diff
Merge branch 'format' into 'master'
Format the codebase See merge request
!49
parents
a6af6a92
58f2d28f
Pipeline
#6873
passed with stages
in 2 minutes and 17 seconds
Changes
17
Pipelines
1
Expand all
Hide whitespace changes
Inline
Side-by-side
Showing
17 changed files
with
800 additions
and
459 deletions
+800
-459
src/archive.rs
src/archive.rs
+27
-22
src/bin/ar.rs
src/bin/ar.rs
+20
-8
src/bin/mkfs.rs
src/bin/mkfs.rs
+25
-8
src/bin/mount.rs
src/bin/mount.rs
+95
-64
src/disk/cache.rs
src/disk/cache.rs
+9
-9
src/disk/file.rs
src/disk/file.rs
+18
-16
src/disk/sparse.rs
src/disk/sparse.rs
+16
-12
src/ex_node.rs
src/ex_node.rs
+15
-7
src/extent.rs
src/extent.rs
+10
-7
src/filesystem.rs
src/filesystem.rs
+86
-31
src/header.rs
src/header.rs
+8
-6
src/mount/fuse.rs
src/mount/fuse.rs
+194
-78
src/mount/redox/mod.rs
src/mount/redox/mod.rs
+13
-11
src/mount/redox/resource.rs
src/mount/redox/resource.rs
+43
-19
src/mount/redox/scheme.rs
src/mount/redox/scheme.rs
+172
-125
src/node.rs
src/node.rs
+24
-10
src/tests.rs
src/tests.rs
+25
-26
No files found.
src/archive.rs
View file @
80e3a346
use
std
::
fs
;
use
std
::
io
;
use
std
::
path
::
Path
;
use
std
::
os
::
unix
::
ffi
::
OsStrExt
;
use
std
::
os
::
unix
::
fs
::
MetadataExt
;
use
std
::
path
::
Path
;
use
crate
::{
BLOCK_SIZE
,
Disk
,
Extent
,
FileSystem
,
Node
};
use
crate
::{
Disk
,
Extent
,
FileSystem
,
Node
,
BLOCK_SIZE
};
fn
syscall_err
(
err
:
syscall
::
Error
)
->
io
::
Error
{
io
::
Error
::
from_raw_os_error
(
err
.errno
)
}
pub
fn
archive_at
<
D
:
Disk
,
P
:
AsRef
<
Path
>>
(
fs
:
&
mut
FileSystem
<
D
>
,
parent_path
:
P
,
parent_block
:
u64
)
->
io
::
Result
<
()
>
{
pub
fn
archive_at
<
D
:
Disk
,
P
:
AsRef
<
Path
>>
(
fs
:
&
mut
FileSystem
<
D
>
,
parent_path
:
P
,
parent_block
:
u64
,
)
->
io
::
Result
<
()
>
{
for
entry_res
in
fs
::
read_dir
(
parent_path
)
?
{
let
entry
=
entry_res
?
;
let
metadata
=
entry
.metadata
()
?
;
let
file_type
=
metadata
.file_type
();
let
name
=
entry
.file_name
()
.into_string
()
.map_err
(|
_
|
io
::
Error
::
new
(
io
::
ErrorKind
::
InvalidData
,
"filename is not valid UTF-8"
)
)
?
;
let
name
=
entry
.file_name
()
.into_string
()
.map_err
(|
_
|
{
io
::
Error
::
new
(
io
::
ErrorKind
::
InvalidData
,
"filename is not valid UTF-8"
)
})
?
;
let
mode_type
=
if
file_type
.is_dir
()
{
Node
::
MODE_DIR
...
...
@@ -33,18 +34,20 @@ pub fn archive_at<D: Disk, P: AsRef<Path>>(fs: &mut FileSystem<D>, parent_path:
}
else
{
return
Err
(
io
::
Error
::
new
(
io
::
ErrorKind
::
Other
,
format!
(
"Does not support parsing {:?}"
,
file_type
)
format!
(
"Does not support parsing {:?}"
,
file_type
)
,
));
};
let
mode
=
mode_type
|
(
metadata
.mode
()
as
u16
&
Node
::
MODE_PERM
);
let
mut
node
=
fs
.create_node
(
mode
,
&
name
,
parent_block
,
metadata
.ctime
()
as
u64
,
metadata
.ctime_nsec
()
as
u32
)
.map_err
(
syscall_err
)
?
;
let
mut
node
=
fs
.create_node
(
mode
,
&
name
,
parent_block
,
metadata
.ctime
()
as
u64
,
metadata
.ctime_nsec
()
as
u32
,
)
.map_err
(
syscall_err
)
?
;
node
.1
.uid
=
metadata
.uid
();
node
.1
.gid
=
metadata
.gid
();
fs
.write_at
(
node
.0
,
&
node
.1
)
.map_err
(
syscall_err
)
?
;
...
...
@@ -59,8 +62,9 @@ pub fn archive_at<D: Disk, P: AsRef<Path>>(fs: &mut FileSystem<D>, parent_path:
0
,
&
data
,
metadata
.mtime
()
as
u64
,
metadata
.mtime_nsec
()
as
u32
)
.map_err
(
syscall_err
)
?
;
metadata
.mtime_nsec
()
as
u32
,
)
.map_err
(
syscall_err
)
?
;
}
else
if
file_type
.is_symlink
()
{
let
destination
=
fs
::
read_link
(
path
)
?
;
let
data
=
destination
.as_os_str
()
.as_bytes
();
...
...
@@ -69,12 +73,13 @@ pub fn archive_at<D: Disk, P: AsRef<Path>>(fs: &mut FileSystem<D>, parent_path:
0
,
&
data
,
metadata
.mtime
()
as
u64
,
metadata
.mtime_nsec
()
as
u32
)
.map_err
(
syscall_err
)
?
;
metadata
.mtime_nsec
()
as
u32
,
)
.map_err
(
syscall_err
)
?
;
}
else
{
return
Err
(
io
::
Error
::
new
(
io
::
ErrorKind
::
Other
,
format!
(
"Does not support creating {:?}"
,
file_type
)
format!
(
"Does not support creating {:?}"
,
file_type
)
,
));
}
}
...
...
src/bin/ar.rs
View file @
80e3a346
...
...
@@ -2,11 +2,11 @@ extern crate redoxfs;
extern
crate
syscall
;
extern
crate
uuid
;
use
std
::{
env
,
fs
,
process
};
use
std
::
io
::
Read
;
use
std
::
time
::{
SystemTime
,
UNIX_EPOCH
};
use
std
::{
env
,
fs
,
process
};
use
redoxfs
::{
DiskSparse
,
FileSystem
,
archive
};
use
redoxfs
::{
archive
,
DiskSparse
,
FileSystem
};
use
uuid
::
Uuid
;
fn
main
()
{
...
...
@@ -44,12 +44,18 @@ fn main() {
Ok
(
mut
file
)
=>
match
file
.read_to_end
(
&
mut
bootloader
)
{
Ok
(
_
)
=>
(),
Err
(
err
)
=>
{
println!
(
"redoxfs-ar: failed to read bootloader {}: {}"
,
bootloader_path
,
err
);
println!
(
"redoxfs-ar: failed to read bootloader {}: {}"
,
bootloader_path
,
err
);
process
::
exit
(
1
);
}
},
Err
(
err
)
=>
{
println!
(
"redoxfs-ar: failed to open bootloader {}: {}"
,
bootloader_path
,
err
);
println!
(
"redoxfs-ar: failed to open bootloader {}: {}"
,
bootloader_path
,
err
);
process
::
exit
(
1
);
}
}
...
...
@@ -67,7 +73,10 @@ fn main() {
};
if
let
Err
(
err
)
=
fs
.disk.file
.set_len
(
size
)
{
println!
(
"redoxfs-ar: failed to truncate {} to {}: {}"
,
disk_path
,
size
,
err
);
println!
(
"redoxfs-ar: failed to truncate {} to {}: {}"
,
disk_path
,
size
,
err
);
process
::
exit
(
1
);
}
...
...
@@ -76,12 +85,15 @@ fn main() {
"redoxfs-ar: created filesystem on {}, reserved {} blocks, size {} MB, uuid {}"
,
disk_path
,
fs
.block
,
fs
.header
.1
.size
/
1000
/
1000
,
fs
.header
.1
.size
/
1000
/
1000
,
uuid
.hyphenated
()
);
}
,
}
Err
(
err
)
=>
{
println!
(
"redoxfs-ar: failed to create filesystem on {}: {}"
,
disk_path
,
err
);
println!
(
"redoxfs-ar: failed to create filesystem on {}: {}"
,
disk_path
,
err
);
process
::
exit
(
1
);
}
};
...
...
src/bin/mkfs.rs
View file @
80e3a346
extern
crate
redoxfs
;
extern
crate
uuid
;
use
std
::{
env
,
fs
,
process
,
time
};
use
std
::
io
::
Read
;
use
std
::{
env
,
fs
,
process
,
time
};
use
redoxfs
::{
FileSystem
,
DiskFile
};
use
redoxfs
::{
DiskFile
,
FileSystem
};
use
uuid
::
Uuid
;
fn
main
()
{
...
...
@@ -34,25 +34,42 @@ fn main() {
Ok
(
mut
file
)
=>
match
file
.read_to_end
(
&
mut
bootloader
)
{
Ok
(
_
)
=>
(),
Err
(
err
)
=>
{
println!
(
"redoxfs-mkfs: failed to read bootloader {}: {}"
,
bootloader_path
,
err
);
println!
(
"redoxfs-mkfs: failed to read bootloader {}: {}"
,
bootloader_path
,
err
);
process
::
exit
(
1
);
}
},
Err
(
err
)
=>
{
println!
(
"redoxfs-mkfs: failed to open bootloader {}: {}"
,
bootloader_path
,
err
);
println!
(
"redoxfs-mkfs: failed to open bootloader {}: {}"
,
bootloader_path
,
err
);
process
::
exit
(
1
);
}
}
};
let
ctime
=
time
::
SystemTime
::
now
()
.duration_since
(
time
::
UNIX_EPOCH
)
.unwrap
();
let
ctime
=
time
::
SystemTime
::
now
()
.duration_since
(
time
::
UNIX_EPOCH
)
.unwrap
();
match
FileSystem
::
create_reserved
(
disk
,
&
bootloader
,
ctime
.as_secs
(),
ctime
.subsec_nanos
())
{
Ok
(
filesystem
)
=>
{
let
uuid
=
Uuid
::
from_bytes
(
&
filesystem
.header
.1
.uuid
)
.unwrap
();
println!
(
"redoxfs-mkfs: created filesystem on {}, reserved {} blocks, size {} MB, uuid {}"
,
disk_path
,
filesystem
.block
,
filesystem
.header
.1
.size
/
1000
/
1000
,
uuid
.hyphenated
());
},
println!
(
"redoxfs-mkfs: created filesystem on {}, reserved {} blocks, size {} MB, uuid {}"
,
disk_path
,
filesystem
.block
,
filesystem
.header
.1
.size
/
1000
/
1000
,
uuid
.hyphenated
()
);
}
Err
(
err
)
=>
{
println!
(
"redoxfs-mkfs: failed to create filesystem on {}: {}"
,
disk_path
,
err
);
println!
(
"redoxfs-mkfs: failed to create filesystem on {}: {}"
,
disk_path
,
err
);
process
::
exit
(
1
);
}
}
...
...
src/bin/mount.rs
View file @
80e3a346
...
...
@@ -15,7 +15,7 @@ use std::io::{Read, Write};
use
std
::
os
::
unix
::
io
::{
FromRawFd
,
RawFd
};
use
std
::
process
;
use
redoxfs
::{
DiskCache
,
DiskFile
,
mount
};
use
redoxfs
::{
mount
,
DiskCache
,
DiskFile
};
use
uuid
::
Uuid
;
#[cfg(target_os
=
"redox"
)]
...
...
@@ -33,7 +33,7 @@ fn setsig() {
let
sig_action
=
SigAction
{
sa_handler
:
unmount_handler
,
sa_mask
:
[
0
,
0
],
sa_mask
:
[
0
,
0
],
sa_flags
:
0
,
};
...
...
@@ -94,17 +94,19 @@ fn disk_paths(paths: &mut Vec<String>) {
let
mut
schemes
=
vec!
[];
match
fs
::
read_dir
(
":"
)
{
Ok
(
entries
)
=>
for
entry_res
in
entries
{
if
let
Ok
(
entry
)
=
entry_res
{
if
let
Ok
(
path
)
=
entry
.path
()
.into_os_string
()
.into_string
()
{
let
scheme
=
path
.trim_start_matches
(
':'
)
.trim_matches
(
'/'
);
if
scheme
.starts_with
(
"disk"
)
{
println!
(
"redoxfs: found scheme {}"
,
scheme
);
schemes
.push
(
format!
(
"{}:"
,
scheme
));
Ok
(
entries
)
=>
{
for
entry_res
in
entries
{
if
let
Ok
(
entry
)
=
entry_res
{
if
let
Ok
(
path
)
=
entry
.path
()
.into_os_string
()
.into_string
()
{
let
scheme
=
path
.trim_start_matches
(
':'
)
.trim_matches
(
'/'
);
if
scheme
.starts_with
(
"disk"
)
{
println!
(
"redoxfs: found scheme {}"
,
scheme
);
schemes
.push
(
format!
(
"{}:"
,
scheme
));
}
}
}
}
}
,
}
Err
(
err
)
=>
{
println!
(
"redoxfs: failed to list schemes: {}"
,
err
);
}
...
...
@@ -112,14 +114,16 @@ fn disk_paths(paths: &mut Vec<String>) {
for
scheme
in
schemes
{
match
fs
::
read_dir
(
&
scheme
)
{
Ok
(
entries
)
=>
for
entry_res
in
entries
{
if
let
Ok
(
entry
)
=
entry_res
{
if
let
Ok
(
path
)
=
entry
.path
()
.into_os_string
()
.into_string
()
{
println!
(
"redoxfs: found path {}"
,
path
);
paths
.push
(
path
);
Ok
(
entries
)
=>
{
for
entry_res
in
entries
{
if
let
Ok
(
entry
)
=
entry_res
{
if
let
Ok
(
path
)
=
entry
.path
()
.into_os_string
()
.into_string
()
{
println!
(
"redoxfs: found path {}"
,
path
);
paths
.push
(
path
);
}
}
}
}
,
}
Err
(
err
)
=>
{
println!
(
"redoxfs: failed to list '{}': {}"
,
scheme
,
err
);
}
...
...
@@ -136,11 +140,11 @@ fn daemon(disk_id: &DiskId, mountpoint: &str, block_opt: Option<u64>, mut write:
match
*
disk_id
{
DiskId
::
Path
(
ref
path
)
=>
{
paths
.push
(
path
.clone
());
}
,
}
DiskId
::
Uuid
(
ref
uuid
)
=>
{
disk_paths
(
&
mut
paths
);
uuid_opt
=
Some
(
uuid
.clone
());
}
,
}
}
for
path
in
paths
{
...
...
@@ -148,15 +152,28 @@ fn daemon(disk_id: &DiskId, mountpoint: &str, block_opt: Option<u64>, mut write:
match
DiskFile
::
open
(
&
path
)
.map
(|
image
|
DiskCache
::
new
(
image
))
{
Ok
(
disk
)
=>
match
redoxfs
::
FileSystem
::
open
(
disk
,
block_opt
)
{
Ok
(
filesystem
)
=>
{
println!
(
"redoxfs: opened filesystem on {} with uuid {}"
,
path
,
Uuid
::
from_bytes
(
&
filesystem
.header
.1
.uuid
)
.unwrap
()
.hyphenated
());
println!
(
"redoxfs: opened filesystem on {} with uuid {}"
,
path
,
Uuid
::
from_bytes
(
&
filesystem
.header
.1
.uuid
)
.unwrap
()
.hyphenated
()
);
let
matches
=
if
let
Some
(
uuid
)
=
uuid_opt
{
if
&
filesystem
.header
.1
.uuid
==
uuid
.as_bytes
()
{
println!
(
"redoxfs: filesystem on {} matches uuid {}"
,
path
,
uuid
.hyphenated
());
println!
(
"redoxfs: filesystem on {} matches uuid {}"
,
path
,
uuid
.hyphenated
()
);
true
}
else
{
println!
(
"redoxfs: filesystem on {} does not match uuid {}"
,
path
,
uuid
.hyphenated
());
println!
(
"redoxfs: filesystem on {} does not match uuid {}"
,
path
,
uuid
.hyphenated
()
);
false
}
}
else
{
...
...
@@ -167,31 +184,38 @@ fn daemon(disk_id: &DiskId, mountpoint: &str, block_opt: Option<u64>, mut write:
match
mount
(
filesystem
,
&
mountpoint
,
|
mounted_path
|
{
capability_mode
();
println!
(
"redoxfs: mounted filesystem on {} to {}"
,
path
,
mounted_path
.display
());
println!
(
"redoxfs: mounted filesystem on {} to {}"
,
path
,
mounted_path
.display
()
);
let
_
=
write
.write
(
&
[
0
]);
})
{
Ok
(())
=>
{
process
::
exit
(
0
);
}
,
}
Err
(
err
)
=>
{
println!
(
"redoxfs: failed to mount {} to {}: {}"
,
path
,
mountpoint
,
err
);
println!
(
"redoxfs: failed to mount {} to {}: {}"
,
path
,
mountpoint
,
err
);
}
}
}
}
,
Err
(
err
)
=>
println!
(
"redoxfs: failed to open filesystem {}: {}"
,
path
,
err
)
}
Err
(
err
)
=>
println!
(
"redoxfs: failed to open filesystem {}: {}"
,
path
,
err
)
,
},
Err
(
err
)
=>
println!
(
"redoxfs: failed to open image {}: {}"
,
path
,
err
)
Err
(
err
)
=>
println!
(
"redoxfs: failed to open image {}: {}"
,
path
,
err
)
,
}
}
match
*
disk_id
{
DiskId
::
Path
(
ref
path
)
=>
{
println!
(
"redoxfs: not able to mount path {}"
,
path
);
}
,
}
DiskId
::
Uuid
(
ref
uuid
)
=>
{
println!
(
"redoxfs: not able to mount uuid {}"
,
uuid
.hyphenated
());
}
,
}
}
let
_
=
write
.write
(
&
[
1
]);
...
...
@@ -202,11 +226,16 @@ fn print_uuid(path: &str) {
match
DiskFile
::
open
(
&
path
)
.map
(|
image
|
DiskCache
::
new
(
image
))
{
Ok
(
disk
)
=>
match
redoxfs
::
FileSystem
::
open
(
disk
,
None
)
{
Ok
(
filesystem
)
=>
{
println!
(
"{}"
,
Uuid
::
from_bytes
(
&
filesystem
.header
.1
.uuid
)
.unwrap
()
.hyphenated
());
},
Err
(
err
)
=>
println!
(
"redoxfs: failed to open filesystem {}: {}"
,
path
,
err
)
println!
(
"{}"
,
Uuid
::
from_bytes
(
&
filesystem
.header
.1
.uuid
)
.unwrap
()
.hyphenated
()
);
}
Err
(
err
)
=>
println!
(
"redoxfs: failed to open filesystem {}: {}"
,
path
,
err
),
},
Err
(
err
)
=>
println!
(
"redoxfs: failed to open image {}: {}"
,
path
,
err
)
Err
(
err
)
=>
println!
(
"redoxfs: failed to open image {}: {}"
,
path
,
err
)
,
}
}
...
...
@@ -214,39 +243,41 @@ fn main() {
let
mut
args
=
env
::
args
()
.skip
(
1
);
let
disk_id
=
match
args
.next
()
{
Some
(
arg
)
=>
if
arg
==
"--uuid"
{
let
uuid
=
match
args
.next
()
{
Some
(
arg
)
=>
match
Uuid
::
parse_str
(
&
arg
)
{
Ok
(
uuid
)
=>
uuid
,
Err
(
err
)
=>
{
println!
(
"redoxfs: invalid uuid '{}': {}"
,
arg
,
err
);
Some
(
arg
)
=>
{
if
arg
==
"--uuid"
{
let
uuid
=
match
args
.next
()
{
Some
(
arg
)
=>
match
Uuid
::
parse_str
(
&
arg
)
{
Ok
(
uuid
)
=>
uuid
,
Err
(
err
)
=>
{
println!
(
"redoxfs: invalid uuid '{}': {}"
,
arg
,
err
);
usage
();
process
::
exit
(
1
);
}
},
None
=>
{
println!
(
"redoxfs: no uuid provided"
);
usage
();
process
::
exit
(
1
);
}
},
None
=>
{
println!
(
"redoxfs: no uuid provided"
);
usage
();
process
::
exit
(
1
);
}
};
DiskId
::
Uuid
(
uuid
)
}
else
if
arg
==
"--get-uuid"
{
match
args
.next
()
{
Some
(
arg
)
=>
{
print_uuid
(
&
arg
);
process
::
exit
(
1
);
},
None
=>
{
println!
(
"redoxfs: no disk provided"
);
usage
();
process
::
exit
(
1
);
},
};
}
else
{
DiskId
::
Path
(
arg
)
},
};
DiskId
::
Uuid
(
uuid
)
}
else
if
arg
==
"--get-uuid"
{
match
args
.next
()
{
Some
(
arg
)
=>
{
print_uuid
(
&
arg
);
process
::
exit
(
1
);
}
None
=>
{
println!
(
"redoxfs: no disk provided"
);
usage
();
process
::
exit
(
1
);
}
};
}
else
{
DiskId
::
Path
(
arg
)
}
}
None
=>
{
println!
(
"redoxfs: no disk provided"
);
usage
();
...
...
src/disk/cache.rs
View file @
80e3a346
use
std
::{
cmp
,
ptr
};
use
std
::
collections
::{
HashMap
,
VecDeque
};
use
std
::{
cmp
,
ptr
};
use
syscall
::
error
::
Result
;
use
BLOCK_SIZE
;
use
disk
::
Disk
;
use
BLOCK_SIZE
;
fn
copy_memory
(
src
:
&
[
u8
],
dest
:
&
mut
[
u8
])
->
usize
{
let
len
=
cmp
::
min
(
src
.len
(),
dest
.len
());
...
...
@@ -45,16 +45,16 @@ impl<T: Disk> Disk for DiskCache<T> {
let
mut
read
=
0
;
let
mut
failed
=
false
;
for
i
in
0
..
(
buffer
.len
()
+
BLOCK_SIZE
as
usize
-
1
)
/
(
BLOCK_SIZE
as
usize
)
{
for
i
in
0
..
(
buffer
.len
()
+
BLOCK_SIZE
as
usize
-
1
)
/
(
BLOCK_SIZE
as
usize
)
{
let
block_i
=
block
+
i
as
u64
;
let
buffer_i
=
i
*
BLOCK_SIZE
as
usize
;
let
buffer_j
=
cmp
::
min
(
buffer_i
+
BLOCK_SIZE
as
usize
,
buffer
.len
());
let
buffer_slice
=
&
mut
buffer
[
buffer_i
..
buffer_j
];
let
buffer_slice
=
&
mut
buffer
[
buffer_i
..
buffer_j
];
if
let
Some
(
cache_buf
)
=
self
.cache
.get_mut
(
&
block_i
)
{
read
+=
copy_memory
(
cache_buf
,
buffer_slice
);
}
else
{
}
else
{
failed
=
true
;
break
;
}
...
...
@@ -64,12 +64,12 @@ impl<T: Disk> Disk for DiskCache<T> {
self
.inner
.read_at
(
block
,
buffer
)
?
;
read
=
0
;
for
i
in
0
..
(
buffer
.len
()
+
BLOCK_SIZE
as
usize
-
1
)
/
(
BLOCK_SIZE
as
usize
)
{
for
i
in
0
..
(
buffer
.len
()
+
BLOCK_SIZE
as
usize
-
1
)
/
(
BLOCK_SIZE
as
usize
)
{
let
block_i
=
block
+
i
as
u64
;
let
buffer_i
=
i
*
BLOCK_SIZE
as
usize
;
let
buffer_j
=
cmp
::
min
(
buffer_i
+
BLOCK_SIZE
as
usize
,
buffer
.len
());
let
buffer_slice
=
&
buffer
[
buffer_i
..
buffer_j
];
let
buffer_slice
=
&
buffer
[
buffer_i
..
buffer_j
];
let
mut
cache_buf
=
[
0
;
BLOCK_SIZE
as
usize
];
read
+=
copy_memory
(
buffer_slice
,
&
mut
cache_buf
);
...
...
@@ -87,12 +87,12 @@ impl<T: Disk> Disk for DiskCache<T> {
self
.inner
.write_at
(
block
,
buffer
)
?
;
let
mut
written
=
0
;
for
i
in
0
..
(
buffer
.len
()
+
BLOCK_SIZE
as
usize
-
1
)
/
(
BLOCK_SIZE
as
usize
)
{
for
i
in
0
..
(
buffer
.len
()
+
BLOCK_SIZE
as
usize
-
1
)
/
(
BLOCK_SIZE
as
usize
)
{
let
block_i
=
block
+
i
as
u64
;
let
buffer_i
=
i
*
BLOCK_SIZE
as
usize
;
let
buffer_j
=
cmp
::
min
(
buffer_i
+
BLOCK_SIZE
as
usize
,
buffer
.len
());
let
buffer_slice
=
&
buffer
[
buffer_i
..
buffer_j
];
let
buffer_slice
=
&
buffer
[
buffer_i
..
buffer_j
];
let
mut
cache_buf
=
[
0
;
BLOCK_SIZE
as
usize
];
written
+=
copy_memory
(
buffer_slice
,
&
mut
cache_buf
);
...
...
src/disk/file.rs
View file @
80e3a346
use
std
::
fs
::{
File
,
OpenOptions
};
use
std
::
io
::{
Read
,
Write
,
Seek
,
SeekFrom
};
use
std
::
io
::{
Read
,
Seek
,
SeekFrom
,
Write
};
use
std
::
path
::
Path
;
use
syscall
::
error
::{
Error
,
Result
,
EIO
};
use
BLOCK_SIZE
;
use
disk
::
Disk
;
use
BLOCK_SIZE
;
macro_rules!
try_disk
{
(
$expr:expr
)
=>
(
match
$expr
{
Ok
(
val
)
=>
val
,
Err
(
err
)
=>
{
eprintln!
(
"Disk I/O Error: {}"
,
err
);
return
Err
(
Error
::
new
(
EIO
));
(
$expr:expr
)
=>
{
match
$expr
{
Ok
(
val
)
=>
val
,
Err
(
err
)
=>
{
eprintln!
(
"Disk I/O Error: {}"
,
err
);
return
Err
(
Error
::
new
(
EIO
));
}
}
}
)
}
;
}
pub
struct
DiskFile
{
pub
file
:
File
pub
file
:
File
,
}
impl
DiskFile
{
pub
fn
open
<
P
:
AsRef
<
Path
>>
(
path
:
P
)
->
Result
<
DiskFile
>
{
let
file
=
try_disk!
(
OpenOptions
::
new
()
.read
(
true
)
.write
(
true
)
.open
(
path
));
Ok
(
DiskFile
{
file
:
file
})
Ok
(
DiskFile
{
file
:
file
})
}
pub
fn
create
<
P
:
AsRef
<
Path
>>
(
path
:
P
,
size
:
u64
)
->
Result
<
DiskFile
>
{
let
file
=
try_disk!
(
OpenOptions
::
new
()
.read
(
true
)
.write
(
true
)
.create
(
true
)
.open
(
path
));
let
file
=
try_disk!
(
OpenOptions
::
new
()
.read
(
true
)
.write
(
true
)
.create
(
true
)
.open
(
path
));
try_disk!
(
file
.set_len
(
size
));
Ok
(
DiskFile
{
file
:
file
})
Ok
(
DiskFile
{
file
:
file
})
}
}
...
...
src/disk/sparse.rs
View file @
80e3a346
use
std
::
fs
::{
File
,
OpenOptions
};
use
std
::
io
::{
Read
,
Write
,
Seek
,
SeekFrom
};
use
std
::
io
::{
Read
,
Seek
,
SeekFrom
,
Write
};
use
std
::
path
::
Path
;
use
std
::
u64
;
use
syscall
::
error
::{
Error
,
Result
,
EIO
};
use
BLOCK_SIZE
;
use
disk
::
Disk
;
use
BLOCK_SIZE
;
macro_rules!
try_disk
{
(
$expr:expr
)
=>
(
match
$expr
{
Ok
(
val
)
=>
val
,
Err
(
err
)
=>
{
eprintln!
(
"Disk I/O Error: {}"
,
err
);
return
Err
(
Error
::
new
(
EIO
));
(
$expr:expr
)
=>
{
match
$expr
{