updates

src/filesys/filesys.c

@@ -2,12 +2,12 @@
 #include <debug.h>
 #include <stdio.h>
 #include <string.h>
-#include "filesys/file.h"
-#include "filesys/free-map.h"
-#include "filesys/inode.h"
-#include "filesys/directory.h"
-#include "devices/disk.h"
-#include "threads/synch.h"
+#include "../filesys/file.h"
+#include "../filesys/free-map.h"
+#include "../filesys/inode.h"
+#include "../filesys/directory.h"
+#include "../devices/disk.h"
+#include "../threads/synch.h"
 
 /* The disk that contains the file system. */
 struct disk *filesys_disk;
@@ -75,6 +75,7 @@ struct file *
 filesys_open (const char *name)
 {
   lock_acquire(&lock_filesys);
+
   struct dir *dir = dir_open_root ();
   struct inode *inode = NULL;
 
@@ -83,6 +84,7 @@ filesys_open (const char *name)
   dir_close (dir);
 
   struct file *file = file_open(inode);
+
   lock_release(&lock_filesys);
   return file;
 }

src/filesys/free-map.c

@@ -8,7 +8,7 @@
 
 static struct file *free_map_file;   /* Free map file. */
 static struct bitmap *free_map;      /* Free map, one bit per disk sector. */
-struct lock map_lock;
+struct lock lock;
 /* Initializes the free map. */
 void
 free_map_init (void)
@@ -18,7 +18,7 @@ free_map_init (void)
     PANIC ("bitmap creation failed--disk is too large");
   bitmap_mark (free_map, FREE_MAP_SECTOR);
   bitmap_mark (free_map, ROOT_DIR_SECTOR);
-  lock_init(&map_lock);
+  lock_init(&lock);
 }
 
 /* Allocates CNT consecutive sectors from the free map and stores
@@ -28,7 +28,8 @@ free_map_init (void)
 bool
 free_map_allocate (size_t cnt, disk_sector_t *sectorp)
 {
-  lock_acquire(&map_lock);
+  lock_acquire(&lock);
+
   disk_sector_t sector = bitmap_scan_and_flip (free_map, 0, cnt, false);
   if (sector != BITMAP_ERROR
       && free_map_file != NULL
@@ -37,17 +38,13 @@ free_map_allocate (size_t cnt, disk_sector_t *sectorp)
       bitmap_set_multiple (free_map, sector, cnt, false);
       sector = BITMAP_ERROR;
     }
-  bool sector_error = sector == BITMAP_ERROR;
-    if (!sector_error)
+
+    if (sector != BITMAP_ERROR)
       *sectorp = sector;
 
-  lock_release(&map_lock);
-  return !sector_error;
+  lock_release(&lock);
+  return (sector != BITMAP_ERROR);
 
-  /*if (sector != BITMAP_ERROR)
-    *sectorp = sector;
-  lock_release(&map_lock);
-  return sector != BITMAP_ERROR;*/
 }
 
 /* Makes CNT sectors starting at SECTOR available for use. */
@@ -55,10 +52,12 @@ void
 free_map_release (disk_sector_t sector, size_t cnt)
 {
   ASSERT (bitmap_all (free_map, sector, cnt));
-  lock_acquire(&map_lock);
+  lock_acquire(&lock);
+
   bitmap_set_multiple (free_map, sector, cnt, false);
   bitmap_write (free_map, free_map_file);
-  lock_release(&map_lock);
+
+  lock_release(&lock);
 }
 
 /* Opens the free map file and reads it from disk. */

src/filesys/inode.c

@@ -41,10 +41,9 @@ struct inode
 
     //labb6
     int read;                           // Holds the amount of readers/
+    struct semaphore sema_file_access;  // Semaphore to handle the access to resources
     struct lock read_count_lock;        // lock to handle the access to /*read*/
     struct lock file_queue_lock;        // lock queue to prevent starvation
-    struct semaphore sema_file_access;  // Semaphore to handle the access to resources
-
   };
 
 /* Returns the disk sector that contains byte offset POS within
@@ -64,15 +63,15 @@ byte_to_sector (const struct inode *inode, off_t pos)
 /* List of open inodes, so that opening a single inode twice
    returns the same `struct inode'. */
 static struct list open_inodes;
-// Lock to protect the list of open inodes
-struct lock lock;
+
+struct lock lock_open;
 
 /* Initializes the inode module. */
 void
 inode_init (void)
 {
   list_init (&open_inodes);
-  lock_init(&lock);
+  lock_init(&lock_open);
 }
 
 /* Initializes an inode with LENGTH bytes of data and
@@ -125,7 +124,7 @@ inode_open (disk_sector_t sector)
   struct list_elem *e;
   struct inode *inode;
 
-  lock_acquire(&lock);
+  lock_acquire(&lock_open);
 
   /* Check whether this inode is already open. */
   for (e = list_begin (&open_inodes); e != list_end (&open_inodes);
@@ -135,12 +134,14 @@ inode_open (disk_sector_t sector)
       if (inode->sector == sector)
         {
           if (inode->removed) {
-            lock_release(&lock);
+            lock_release(&lock_open);
+
             return NULL;
           }
+          lock_release(&lock_open);
 
-          lock_release(&lock);
           inode_reopen (inode);
+
           return inode;
         }
     }
@@ -148,7 +149,7 @@ inode_open (disk_sector_t sector)
   /* Allocate memory. */
   inode = malloc (sizeof *inode);
   if (inode == NULL){
-    lock_release(&lock);
+    lock_release(&lock_open);
     return NULL;
   }
 
@@ -160,14 +161,13 @@ inode_open (disk_sector_t sector)
   inode->removed = false;
 
   inode->read = 0;
+  sema_init(&inode->sema_file_access, 1);
   lock_init(&inode->read_count_lock);
   lock_init(&inode->file_queue_lock);
-  sema_init(&inode->sema_file_access, 1);
-
 
 
   disk_read (filesys_disk, inode->sector, &inode->data);
-  lock_release(&lock);
+  lock_release(&lock_open);
   return inode;
 }
 
@@ -175,13 +175,13 @@ inode_open (disk_sector_t sector)
 struct inode *
 inode_reopen (struct inode *inode)
 {
-  lock_acquire(&lock);
+  lock_acquire(&lock_open);
   if (inode != NULL)
     {
       ASSERT(inode->open_cnt != 0);
       inode->open_cnt++;
     }
-  lock_release(&lock);
+  lock_release(&lock_open);
   return inode;
 }
 
@@ -203,7 +203,7 @@ inode_close (struct inode *inode)
   if (inode == NULL)
     return;
 
-  lock_acquire(&lock);
+  lock_acquire(&lock_open);
 
   /* Release resources if this was the last opener. */
   if (--inode->open_cnt == 0)
@@ -222,7 +222,7 @@ inode_close (struct inode *inode)
       free (inode);
     }
 
-  lock_release(&lock);
+  lock_release(&lock_open);
 }
 
 /* Marks INODE to be deleted when it is closed by the last caller who
@@ -297,7 +297,6 @@ inode_read_at (struct inode *inode, void *buffer_, off_t size, off_t offset)
       bytes_read += chunk_size;
     }
   free (bounce);
-
   lock_acquire(&inode->read_count_lock);
   inode->read--;
   if (inode->read == 0){
@@ -322,9 +321,7 @@ inode_write_at (struct inode *inode, const void *buffer_, off_t size,
   uint8_t *bounce = NULL;
 
   lock_acquire(&inode->file_queue_lock);
-
   sema_down(&inode->sema_file_access);
-
   lock_release(&inode->file_queue_lock);
 
   if (inode->deny_write_cnt) {