andrey/osblog
1
0
Fork 0
mirror of https://github.com/sgmarz/osblog.git synced 2024-11-24 02:16:19 +04:00
Code Issues Projects Releases Wiki Activity

Fix warnings

Browse Source
This commit is contained in:
Stephen Marz 2020-05-15 10:37:40 -04:00
parent 6367e064cf
commit 5b5e5d9e2b
3 changed files with 15 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
risc_v/src/fs.rs
View File

@ -69,7 +69,6 @@ pub struct DirEntry {
/// The MinixFileSystem implements the FileSystem trait for the VFS.
pub struct MinixFileSystem {
bdev: usize,
inode_cache: BTreeMap<String, Inode>
}
@ -163,14 +162,13 @@ impl MinixFileSystem {
// Run this ONLY in a process!
pub fn init(bdev: usize) -> Self {
let mut btm = BTreeMap::new();
let mut cwd = String::from("/");
let cwd = String::from("/");
// Let's look at the root (inode #1)
Self::cache_at(&mut btm, &cwd, 1, bdev);
Self {
bdev,
inode_cache: btm
}
}
@ -194,7 +192,7 @@ impl MinixFileSystem {
let mut blocks_seen = 0u32;
let offset_block = offset / BLOCK_SIZE;
let mut offset_byte = offset % BLOCK_SIZE;
const num_indirect_pointers: usize = BLOCK_SIZE as usize / 4;
const NUM_INDIRECT_POINTERS: usize = BLOCK_SIZE as usize / 4;
// First, the _size parameter (now in bytes_left) is the size of the buffer, not
// necessarily the size of the file. If our buffer is bigger than the file, we're OK.
// If our buffer is smaller than the file, then we can only read up to the buffer size.
@ -283,7 +281,7 @@ impl MinixFileSystem {
if inode.zones[7] != 0 {
syc_read(bdev, indirect_buffer.get_mut(), BLOCK_SIZE, BLOCK_SIZE * inode.zones[7]);
let izones = indirect_buffer.get() as *const u32;
for i in 0..num_indirect_pointers {
for i in 0..NUM_INDIRECT_POINTERS{
// Where do I put unsafe? Dereferencing the pointers and memcpy are the unsafe functions.
unsafe {
if izones.add(i).read() != 0 {
@ -323,10 +321,10 @@ impl MinixFileSystem {
if inode.zones[8] != 0 {
syc_read(bdev, indirect_buffer.get_mut(), BLOCK_SIZE, BLOCK_SIZE * inode.zones[8]);
unsafe {
for i in 0..num_indirect_pointers {
for i in 0..NUM_INDIRECT_POINTERS {
if izones.add(i).read() != 0 {
syc_read(bdev, iindirect_buffer.get_mut(), BLOCK_SIZE, BLOCK_SIZE * izones.add(i).read());
for j in 0..num_indirect_pointers {
for j in 0..NUM_INDIRECT_POINTERS {
if iizones.add(j).read() != 0 {
// Notice that this inner code is the same for all end-zone pointers. I'm thinking about
// moving this out of here into a function of its own, but that might make it harder
@ -369,10 +367,10 @@ impl MinixFileSystem {
if inode.zones[9] != 0 {
syc_read(bdev, indirect_buffer.get_mut(), BLOCK_SIZE, BLOCK_SIZE * inode.zones[9]);
unsafe {
for i in 0..num_indirect_pointers {
for i in 0..NUM_INDIRECT_POINTERS {
if izones.add(i).read() != 0 {
syc_read(bdev, iindirect_buffer.get_mut(), BLOCK_SIZE, BLOCK_SIZE * izones.add(i).read());
for j in 0..num_indirect_pointers {
for j in 0..NUM_INDIRECT_POINTERS {
if iizones.add(j).read() != 0 {
syc_read(
bdev,
@ -380,7 +378,7 @@ impl MinixFileSystem {
BLOCK_SIZE,
BLOCK_SIZE * iizones.add(j,).read(),
);
for k in 0..num_indirect_pointers {
for k in 0..NUM_INDIRECT_POINTERS {
if iiizones.add(k).read() != 0 {
// Hey look! This again.
if offset_block <= blocks_seen {
@ -425,7 +423,7 @@ impl MinixFileSystem {
bytes_read
}
pub fn write(&mut self, desc: &String, _buffer: *const u8, _offset: u32, _size: u32) -> u32 {
pub fn write(&mut self, _desc: &Inode, _buffer: *const u8, _offset: u32, _size: u32) -> u32 {
0
}

5
risc_v/src/gpu.rs
View File

@ -4,10 +4,9 @@
// 12 May 2020
#![allow(dead_code)]
use crate::{kmem::{kfree, kmalloc},
page::{zalloc, PAGE_SIZE},
use crate::{page::{zalloc, PAGE_SIZE},
virtio,
virtio::{Descriptor, MmioOffsets, Queue, StatusField, VIRTIO_RING_SIZE}};
virtio::{MmioOffsets, Queue, StatusField, VIRTIO_RING_SIZE}};
use core::{mem::size_of, ptr::null_mut};
pub struct GpuDevice {

9
risc_v/src/test.rs
View File

@ -16,16 +16,15 @@ use crate::{cpu::{build_satp,
PROCESS_LIST,
PROCESS_LIST_MUTEX,
STACK_ADDR,
STACK_PAGES},
syscall::{syscall_get_pid, syscall_fs_read, syscall_exit}};
STACK_PAGES}};
use alloc::string::String;
/// Test block will load raw binaries into memory to execute them. This function
/// will load ELF files and try to execute them.
pub fn test_elf() {
// This won't be necessary after we connect this to the VFS, but for now, we need it.
const bdev: usize = 8;
let mfs = MinixFileSystem::init(bdev);
const BDEV: usize = 8;
let mfs = MinixFileSystem::init(BDEV);
let desc = mfs.open(&String::from("/helloworld.elf")).ok();
if desc.is_none() {
println!("Error reading /helloworld.elf");
@ -39,7 +38,7 @@ pub fn test_elf() {
// Read the file from the disk. I got the inode by mounting
// the harddrive as a loop on Linux and stat'ing the inode.
let bytes_read = MinixFileSystem::read(bdev, &ino, buffer.get_mut(), ino.size, 0);
let bytes_read = MinixFileSystem::read(BDEV, &ino, buffer.get_mut(), ino.size, 0);
// After compiling our program, I manually looked and saw it was 18,360
// bytes. So, to make sure we got the right one, I do a manual check
// here.