adding filesys & drvdisk in params of filesys and fsmisc

src/filesys/directory.rs

@@ -55,7 +55,6 @@ impl Directory {
             table_size: size, 
             table: tmp,
             drv_disk: drv_disk_,
-
         }
     }
 
@@ -74,10 +73,10 @@ impl Directory {
     ///
     /// ### Parameters
     ///	- **name** the file name to look up
-    pub fn find_index(&self, name: char) -> i32 {
+    pub fn find_index(&self, name: String) -> i32 {
         for i in 0..self.table_size {
             if self.table[i as usize].in_use && self.table[i as usize].name.starts_with(&self.table[i as usize].name) {
-                 return i;
+                return i;
             }
         }
 
@@ -94,7 +93,7 @@ impl Directory {
     /// ### Parameters
     /// 
     ///	- **name** the file name to look up
-    pub fn find(&self, name: char) -> i32 {
+    pub fn find(&self, name: String) -> i32 {
         let i = self.find_index(name);
         if i != -1 {
             return self.table[i as usize].sector;
@@ -109,7 +108,7 @@ impl Directory {
     /// - **new_sector** the disk sector containing the added file's header
     /// 
     /// return NO_ERROR, ALREADY_IN_DIRECTORY or NOSPACE_IN_DIRECTORY.
-    pub fn add(&self, name: char, new_sector: i32) -> Result<(), ErrorCode> {
+    pub fn add(&self, name: String, new_sector: i32) -> Result<(), ErrorCode> {
         if self.find_index(name) != -1 {
             return Err(ErrorCode::AlreadyInDirectory);
         }
@@ -131,7 +130,7 @@ impl Directory {
     ///	- **name** the file name to be removed
     /// return NO_ERROR, or INEXIST_DIRECTORY_ERROR
     
-    pub fn remove(&self, name: char) -> Result<(), ErrorCode> {
+    pub fn remove(&self, name: String) -> Result<(), ErrorCode> {
         let i = self.find_index(name);
         if i == -1 {
             return Err(ErrorCode::InexistDirectoryError);

src/filesys/filesys.rs

@@ -1,6 +1,6 @@
-use crate::{kernel::mgerror::ErrorCode, simulator::disk, utility::bitmap::BitMap};
+use crate::{kernel::mgerror::ErrorCode, simulator::disk, utility::bitmap::BitMap, drivers::drv_disk::DrvDisk};
 
-use super::filehdr::FileHdr;
+use super::{filehdr::FileHdr, openfile::OpenFile, directory::Directory};
 
 pub const ERROR: i32 = -1;
 pub const FREE_MAP_SECTOR: i32 = 0;
@@ -55,9 +55,9 @@ pub fn decomp_name(origin_path: String, head: &mut String, tail: &mut String) ->
 ///
 /// - **name** is the complete name (relatively to the root directory).
 ///            its content will be modified!
-pub fn find_dir(name: &mut String) -> i32 {
+pub fn find_dir(name: &mut String, file_sys : Filesys, drv_disk : DrvDisk) -> i32 {
-    let directory = Directory::init_directory(config.num_dir_entries);
+    let directory = Directory::init_directory(NUM_DIR_ENTRIES, drv_disk);
-    directory.fetch_from(filesys::get_dir_file());
+    directory.fetch_from(file_sys.get_dir_file());
 
     let mut sector = DIRECTORY_SECTOR;
     let mut dirname = String::from("");
@@ -72,9 +72,9 @@ pub fn find_dir(name: &mut String) -> i32 {
             return -1; // This file/directory does not exist
         }
 
-        let file = OpenFile::init_open_file(sector);
+        let file = OpenFile::open_file(sector);
         if file.get_file_header().is_dir() {
-            directory.fetch_from(&file);
+            directory.fetch_from(file);
         } else {
             return -1;
         }
@@ -101,10 +101,10 @@ impl Filesys {
     ///  ### parameters
     ///
     /// - **format** should we initialize the disk?
-    pub fn init_filesys(format: bool) -> Filesys {
+    pub fn init_filesys(format: bool, drv_isk : DrvDisk) -> Filesys {
         if format {
             let free_map = BitMap::init_bitmap(disk::NUM_SECTORS as usize);
-            let directory = Directory::init_directory(NUM_DIR_ENTRIES);
+            let directory = Directory::init_directory(NUM_DIR_ENTRIES, drv_isk);
 
             free_map.mark(FREE_MAP_SECTOR as usize);
             free_map.mark(DIRECTORY_SECTOR as usize);
@@ -120,8 +120,8 @@ impl Filesys {
             map_header.write_back(FREE_MAP_SECTOR);
             dir_header.write_back(DIRECTORY_SECTOR);
 
-            let free_map_file = OpenFile::init_open_file(FREE_MAP_SECTOR);
+            let free_map_file = OpenFile::open_file(FREE_MAP_SECTOR);
-            let directory_file = OpenFile::init_open_file(DIRECTORY_SECTOR);
+            let directory_file = OpenFile::open_file(DIRECTORY_SECTOR);
 
             free_map.write_back(free_map_file);
             directory.write_back(directory_file);
@@ -132,8 +132,8 @@ impl Filesys {
             }
         } else {
             Filesys {
-                free_map_file: OpenFile::init_open_file(FREE_MAP_SECTOR),
+                free_map_file: OpenFile::open_file(FREE_MAP_SECTOR),
-                directory_file: OpenFile::init_open_file(DIRECTORY_SECTOR),
+                directory_file: OpenFile::open_file(DIRECTORY_SECTOR),
             }
         }
     }
@@ -163,23 +163,23 @@ impl Filesys {
     ///
     ///	- **name** is the name of file to be created (NOT MODIFIED)
     ///	- **initialSize** is the size of file to be created
-    pub fn create(self, name: String, initial_size: i32) -> Result<(), ErrorCode> {
+    pub fn create(self, name: String, initial_size: i32, file_sys : Filesys, drv_disk : DrvDisk) -> Result<(), ErrorCode> {
-        lock.acquire();
+        //lock.acquire();
 
         let mut dir_name = name.clone();
 
-        let dir_sector = find_dir(&mut dir_name);
+        let dir_sector = find_dir(&mut dir_name, file_sys, drv_disk);
         if dir_sector == ERROR {
-            lock.release();
+            //lock.release();
             return Err(ErrorCode::InexistFileError);
         }
 
-        let dir_file = OpenFile::init_open_file(dir_sector);
+        let dir_file = OpenFile::open_file(dir_sector);
-        let directory = Directory::init_directory(NUM_DIR_ENTRIES);
+        let directory = Directory::init_directory(NUM_DIR_ENTRIES, drv_disk);
-        directory.fetch_from(&dir_file);
+        directory.fetch_from(dir_file);
 
         if directory.find(dir_name) != ERROR {
-            lock.release();
+            //lock.release();
             return Err(ErrorCode::AlreadyInDirectory);
         }
 
@@ -190,7 +190,7 @@ impl Filesys {
         // Find a sector to hold the file header
         let sector = free_map.find();
         if sector == ERROR {
-            lock.release();
+            //lock.release();
             return Err(ErrorCode::OutOfDisk);
         }
 
@@ -198,27 +198,27 @@ impl Filesys {
         let add_result = directory.add(dir_name, sector);
         match add_result {
             Err(e) => {
-                lock.release();
+                //lock.release();
                 return Err(e);
             }
             _ => {}
         }
 
         // Indicate that this is a file, not a directory
-        let hdr = FileHdr::init_file_hdr();
+        let hdr = FileHdr::init_file_hdr(drv_disk);
         hdr.set_file();
 
         if !hdr.allocate(free_map, initial_size) {
-            lock.release();
+            //lock.release();
             return Err(ErrorCode::OutOfDisk);
         }
 
         // everthing worked, flush all changes back to disk
         hdr.write_back(sector);
-        directory.write_back(&dir_file);
+        directory.write_back(dir_file);
         free_map.write_back(self.free_map_file);
 
-        lock.release();
+        //lock.release();
 
         Ok(())
     }
@@ -231,32 +231,32 @@ impl Filesys {
     /// ### parameters
     ///
     ///	- **name** the text name of the file to be opened (NOT MODIFIED)
-    pub fn open(name: String) -> Option<OpenFile> {
+    pub fn open(self, name: String, file_sys : Filesys, drv_disk : DrvDisk) -> Option<&mut OpenFile> {
-        let open_file: OpenFile;
+        let mut open_file: OpenFile;
         let mut dir_name = name.clone();
 
         // Find the directory containing the file
-        let dir_sector = find_dir(&mut dir_name);
+        let dir_sector = find_dir(&mut dir_name, file_sys, drv_disk);
         if dir_sector == ERROR {
             return None;
         }
 
         // Read the directory from disk
-        let dir_file = OpenFile::init_open_file(dir_sector);
+        let dir_file = OpenFile::open_file(dir_sector);
-        let directory = Directory::init_directory(NUM_DIR_ENTRIES);
+        let directory = Directory::init_directory(NUM_DIR_ENTRIES, drv_disk);
-        directory.fetch_from(&directory);
+        directory.fetch_from(dir_file);
 
         // Find the file in the directory
         let sector = directory.find(dir_name);
         if sector >= 0 {
-            open_file = OpenFile::init_open_file(sector);
+            open_file = OpenFile::open_file(sector);
             open_file.set_name(name);
             if open_file.is_dir() {
                 return None;
             }
         }
 
-        Some(open_file)
+        Some(&mut open_file)
     }
 
     /// Delete a file from the file system.  
@@ -269,11 +269,11 @@ impl Filesys {
     /// ### parameters
     ///
     ///	- **name** the text name of the file to be removed (NOT MODIFIED)
-    pub fn remove(self, name: String) -> Result<(), ErrorCode> {
+    pub fn remove(self, name: String, file_sys : Filesys, drv_disk : DrvDisk) -> Result<(), ErrorCode> {
         let mut dir_name = name.clone();
 
         // Get the sector number of the parent directory
-        let dir_sector = find_dir(&mut dir_name);
+        let dir_sector = find_dir(&mut dir_name, file_sys, drv_disk);
 
         // Check if the path is correct
         if dir_sector == ERROR {
@@ -281,9 +281,9 @@ impl Filesys {
         }
 
         // Fetch the directory from the disk
-        let dir_file = OpenFile::init_open_file(dir_sector);
+        let dir_file = OpenFile::open_file(dir_sector);
-        let directory = Directory::init_directory(NUM_DIR_ENTRIES);
+        let directory = Directory::init_directory(NUM_DIR_ENTRIES, drv_disk);
-        directory.fetch_from(&dir_file);
+        directory.fetch_from(dir_file);
 
         // Look for the file in the directory
         let sector = directory.find(dir_name);
@@ -308,7 +308,7 @@ impl Filesys {
 
         // Indicate that sectors are deallocated in the freemap
         file_hdr.deallocate(free_map);
-        free_map.clear(sector);
+        free_map.clear(sector as usize);
 
         // Remove the file from the directory
         directory.remove(dir_name);
@@ -364,18 +364,18 @@ impl Filesys {
     /// ### parameters
     ///
     ///	- **name** is the name of directory to be created (NOT MODIFIED)
-    pub fn mkdir(self, name: String) -> Result<(), ErrorCode> {
+    pub fn mkdir(self, name: String, file_sys : Filesys, drv_disk : DrvDisk) -> Result<(), ErrorCode> {
         let mut dir_name = name.clone();
 
         // Lokk for the sector number of the parent directory
-        let parent_sector = find_dir(&mut dir_name);
+        let parent_sector = find_dir(&mut dir_name, file_sys, drv_disk);
         if parent_sector < 0 {
             return Err(ErrorCode::InexistDirectoryError);
         }
 
         // Fetch it from disk
-        let parent_dir_file = OpenFile::init_open_file(parent_sector);
+        let parent_dir_file = OpenFile::open_file(parent_sector);
-        let parent_dir = Directory::init_directory(NUM_DIR_ENTRIES);
+        let parent_dir = Directory::init_directory(NUM_DIR_ENTRIES, drv_disk);
         parent_dir.fetch_from(parent_dir_file);
 
         // Check that the directory does not exit yet
@@ -413,8 +413,8 @@ impl Filesys {
         hdr.write_back(hdr_sector);
 
         // New directory (initially empty)
-        let new_dir_file = OpenFile::init_open_file(hdr_sector as usize);
+        let new_dir_file = OpenFile::open_file(hdr_sector);
-        let new_dir = Directory::init_directory(NUM_DIR_ENTRIES);
+        let new_dir = Directory::init_directory(NUM_DIR_ENTRIES, drv_disk);
         new_dir.write_back(new_dir_file);
 
         // Parent directory
@@ -436,18 +436,18 @@ impl Filesys {
     /// ### parameters
     ///
     ///	- **name** the text name of the directory to be removed (NOT MODIFIED)
-    pub fn rmdir(self, name: String) -> Result<(), ErrorCode> {
+    pub fn rmdir(self, name: String, file_sys : Filesys, drv_disk : DrvDisk) -> Result<(), ErrorCode> {
         let mut dir_name = name.clone();
 
         // Get the sector number of the parent directory
-        let parent_sector = find_dir(&mut dir_name);
+        let parent_sector = find_dir(&mut dir_name, file_sys, drv_disk);
         if parent_sector < 0 {
             return Err(ErrorCode::InexistDirectoryError);
         }
 
         // Fetch it from disk
-        let parent_dir_file = OpenFile::init_open_file(parent_sector);
+        let parent_dir_file = OpenFile::open_file(parent_sector);
-        let parent_dir = Directory::init_directory(NUM_DIR_ENTRIES);
+        let parent_dir = Directory::init_directory(NUM_DIR_ENTRIES, drv_disk);
         parent_dir.fetch_from(parent_dir_file);
 
         // Check that the directory to be removed exist
@@ -466,8 +466,8 @@ impl Filesys {
         }
 
         // Fetch its contents from the disk
-        let the_dir_file = OpenFile::init_open_file(the_dir_sector);
+        let the_dir_file = OpenFile::open_file(the_dir_sector);
-        let the_dir = Directory::init_directory(NUM_DIR_ENTRIES);
+        let the_dir = Directory::init_directory(NUM_DIR_ENTRIES, drv_disk);
         the_dir.fetch_from(the_dir_file);
 
         // Check that is is empty
@@ -483,7 +483,7 @@ impl Filesys {
         the_dir_header.deallocate(free_map);
 
         // Deallocate the sector containing the directory header
-        free_map.clear(the_dir_sector);
+        free_map.clear(the_dir_sector as usize);
 
         // We remove the directory from its parent directory
         parent_dir.remove(dir_name);

src/filesys/fsmisc.rs

@@ -3,11 +3,13 @@ use std::{
     io::{Read, Seek, SeekFrom},
 };
 
-use super::filesys;
+use crate::drivers::drv_disk::DrvDisk;
+
+use super::{filesys::Filesys, openfile::OpenFile};
 
 pub const TRANSFER_SIZE: usize = 10;
 
-/// copy the contents of the UNIX file "from" to the Nachos file "to"
+/// copy the contents of the UNIX file "from" to the BurritOS file "to"
 ///
 /// `panic!` when the file from doesn't exist
 ///
@@ -15,7 +17,7 @@ pub const TRANSFER_SIZE: usize = 10;
 ///
 /// - **from** file UNIX
 /// - **to** BurritOS file
-pub fn copy(from: &str, to: &str) {
+pub fn copy(from: String, to: String, file_sys : Filesys, mut drv_disk : DrvDisk) {
     let file_from_opt = File::options().read(true).open(from);
     let mut file_from: File;
     match file_from_opt {
@@ -34,15 +36,22 @@ pub fn copy(from: &str, to: &str) {
     file_from.seek(SeekFrom::Start(0));
     let file_length = file_length_buf[0];
 
-    filesys::create(to, file_length);
+    file_sys.create(to, file_length as i32, file_sys, drv_disk);
-    let open_file = filesys::open(to);
+    let open_file_opt = file_sys.open(to, file_sys, drv_disk);
+    let open_file : &mut OpenFile;
+    match open_file_opt {
+        Some(f) => {
+            open_file = f;
+        },
+        None => return
+    }
 
-    let mut buffer = [0; TRANSFER_SIZE];
+    let mut buffer = Vec::new();
     loop {
         let amount_read = file_from
             .read(&mut buffer)
             .expect("copy : couldn't read the UNIX file");
-        open_file.write(&buffer[..amount_read]);
+        OpenFile::write(&mut drv_disk, open_file, &mut buffer, TRANSFER_SIZE as i32);
 
         if amount_read != TRANSFER_SIZE {
             break;
@@ -50,24 +59,31 @@ pub fn copy(from: &str, to: &str) {
     }
 }
 
-/// Print the contents of the Nachos file "name".
+/// Print the contents of the BurritOS file "name".
 ///
-/// `panic!` when the file name doewn't exist
+/// `panic!` when the file name doesn't exist
 ///
 /// ### parameters
 ///
 /// - **name** of the BurritOS file
-pub fn print(name: &str) {
+pub fn print(name: String, file_sys : Filesys, mut drv_disk : DrvDisk) {
-    let open_file = filesys::open(name);
+    let open_file_opt = file_sys.open(name, file_sys, drv_disk);
+    let open_file : &mut OpenFile;
+    match open_file_opt {
+        Some(f) => {
+            open_file = f;
+        },
+        None => return
+    }
 
-    let mut buffer = [0; TRANSFER_SIZE];
+    let mut buffer = Vec::new();
     loop {
-        let amount_read = open_file.read(&mut buffer);
+        let amount_read = OpenFile::read(&mut drv_disk, open_file, &mut buffer, TRANSFER_SIZE as i32);
         for i in 0..amount_read {
-            print!("{:1x} ", buffer[i]);
+            print!("{:1x} ", buffer[i as usize]);
         }
 
-        if amount_read != TRANSFER_SIZE {
+        if amount_read != TRANSFER_SIZE as i32 {
             break;
         }
     }

src/simulator/disk.rs

@@ -109,10 +109,10 @@ impl Disk {
         }
 
         disk.active = true;
-        disk.disk_file
+        disk.disk_file.seek(SeekFrom::Start((sector_number * SECTOR_SIZE) as u64));
-            .seek(SeekFrom::Start((sector_number * SECTOR_SIZE) as u64))?;
+
         let mut buffer = [0; SECTOR_SIZE as usize];
-        disk.disk_file.read(&mut buffer)?;
+        disk.disk_file.read(&mut buffer);
         for byte in buffer {
             data.push(byte);
         }