Working filesystem.

[pintos-anon] / src / filesys / file.c

diff --git a/src/filesys/file.c b/src/filesys/file.c
index b2a4942f56561a6ee3317d06295e98e3ded8001b..e16ff5fc695630cc55b4571f36d27a9d1f3e3fbb 100644 (file)
--- a/src/filesys/file.c
+++ b/src/filesys/file.c
@@ -1,51 +1,147 @@
 #include "file.h"
+#include "debug.h"
+#include "lib.h"
+#include "malloc.h"
+#include "directory.h"
+#include "filehdr.h"
+#include "filesys.h"
+
+bool
+file_open (struct file *file, disk_sector_no hdr_sector) 
+{
+  file->hdr = filehdr_read (hdr_sector);
+  file->bounce = malloc (DISK_SECTOR_SIZE);
+  file->pos = 0;
+  if (file->hdr != NULL && file->bounce != NULL)
+    return true;
+  else
+    {
+      filehdr_destroy (file->hdr);
+      free (file->bounce);
+      return false;
+    }
+}
+
+void
+file_close (struct file *file) 
+{
+  filehdr_destroy (file->hdr);
+}
 
-#ifdef FILESYS_STUB
 off_t
 file_read (struct file *file, void *buffer, off_t size) 
 {
-  int32_t retval = -1;
-  filesys_stub_send ("s'read' i i", (int32_t) file, (int32_t) size);
-  filesys_stub_receive ("s'read' i", &retval);
-  if (retval > 0) 
+  off_t bytes_read = file_read_at (file, buffer, size, file->pos);
+  file->pos += bytes_read;
+  return bytes_read;
+}
+
+off_t
+file_read_at (struct file *file, void *buffer_, off_t size,
+              off_t file_ofs) 
+{
+  uint8_t *buffer = buffer_;
+  off_t bytes_read = 0;
+
+  while (size > 0) 
     {
-      if (!filesys_stub_receive ("B", buffer, (size_t) retval))
-        retval = -1;
+      /* Disk sector to read, starting byte offset within sector. */
+      off_t sector_idx = filehdr_byte_to_sector (file->hdr, file_ofs);
+      int sector_ofs = file_ofs % DISK_SECTOR_SIZE;
+
+      /* Bytes left in file, bytes left in sector, lesser of the two. */
+      off_t file_left = filehdr_length (file->hdr) - file_ofs;
+      int sector_left = DISK_SECTOR_SIZE - sector_ofs;
+      int min_left = file_left < sector_left ? file_left : sector_left;
+
+      /* Number of bytes to actually copy out of this sector. */
+      int chunk_size = size < min_left ? size : min_left;
+      if (chunk_size == 0)
+        break;
+
+      /* Read sector into bounce buffer, then copy into caller's
+         buffer. */
+      disk_read (filesys_disk, sector_idx, file->bounce);
+      memcpy (buffer + bytes_read, file->bounce + sector_ofs, chunk_size);
+
+      /* Advance. */
+      size -= chunk_size;
+      file_ofs += chunk_size;
+      bytes_read += chunk_size;
     }
-  return retval;
+
+  return bytes_read;
 }
 
 off_t
 file_write (struct file *file, const void *buffer, off_t size) 
 {
-  int32_t retval = -1;
-  filesys_stub_send ("s'write' i B", (int32_t) file, buffer, (size_t) size);
-  filesys_stub_receive ("s'write' i", &retval);
-  return retval;
+  off_t bytes_written = file_write_at (file, buffer, size, file->pos);
+  file->pos += bytes_written;
+  return bytes_written;
+}
+
+off_t
+file_write_at (struct file *file, const void *buffer_, off_t size,
+               off_t file_ofs) 
+{
+  const uint8_t *buffer = buffer_;
+  off_t bytes_written = 0;
+
+  while (size > 0) 
+    {
+      /* Starting byte offset within sector to read. */
+      off_t sector_idx = filehdr_byte_to_sector (file->hdr, file_ofs);
+      int sector_ofs = file_ofs % DISK_SECTOR_SIZE;
+
+      /* Bytes left in file, bytes left in sector, lesser of the two. */
+      off_t file_left = filehdr_length (file->hdr) - file_ofs;
+      int sector_left = DISK_SECTOR_SIZE - sector_ofs;
+      int min_left = file_left < sector_left ? file_left : sector_left;
+
+      /* Number of bytes to actually writen into this sector. */
+      int chunk_size = size < min_left ? size : min_left;
+      if (chunk_size == 0)
+        break;
+
+      /* If the sector contains data before or after the chunk
+         we're writing, then we need to read in the sector
+         first.  Otherwise we start with a sector of all zeros. */
+      if (sector_ofs > 0 || chunk_size < sector_ofs)
+        disk_read (filesys_disk, sector_idx, file->bounce);
+      else
+        memset (file->bounce, 0, DISK_SECTOR_SIZE);
+      memcpy (file->bounce + sector_ofs, buffer + bytes_written, chunk_size);
+      disk_write (filesys_disk, sector_idx, file->bounce);
+
+      /* Advance. */
+      size -= chunk_size;
+      file_ofs += chunk_size;
+      bytes_written += chunk_size;
+    }
+  free (file->bounce);
+
+  return bytes_written;
 }
 
 off_t
 file_length (struct file *file) 
 {
-  int32_t length = -1;
-  filesys_stub_send ("s'length' i", (int32_t) file);
-  filesys_stub_receive ("s'length' i", &length);
-  return length;
+  ASSERT (file != NULL);
+  return filehdr_length (file->hdr);
 }
 
 void
-file_seek (struct file *file, off_t pos) 
+file_seek (struct file *file, off_t file_ofs) 
 {
-  filesys_stub_send ("s'seek' i i", (int32_t) file, (int32_t) pos);
-  filesys_stub_receive ("s'seek'");
+  ASSERT (file != NULL);
+  ASSERT (file_ofs >= 0);
+  file->pos = file_ofs;
 }
 
 off_t
 file_tell (struct file *file) 
 {
-  int32_t pos = -1;
-  filesys_stub_send ("s'tell' i", (int32_t) file);
-  filesys_stub_receive ("s'tell'", &pos);
-  return pos;
+  ASSERT (file != NULL);
+  return file->pos;
 }
-#endif /* FILESYS_STUB */