pintos-os.org Git - pintos-anon/blob - src/filesys/file.c

   1 #include "filesys/file.h"
   2 #include <debug.h>
   3 #include "filesys/inode.h"
   4 #include "threads/malloc.h"
   5
   6 /* An open file. */
   7 struct file
   8   {
   9     struct inode *inode;        /* File's inode. */
  10     off_t pos;                  /* Current position. */
  11     bool deny_write;            /* Has file_deny_write() been called? */
  12   };
  13
  14 /* Opens a file for the given INODE, of which it takes ownership,
  15    and returns the new file.  Returns a null pointer if an
  16    allocation fails or if INODE is null. */
  17 struct file *
  18 file_open (struct inode *inode)
  19 {
  20   struct file *file = calloc (1, sizeof *file);
  21   if (inode != NULL && file != NULL)
  22     {
  23       file->inode = inode;
  24       file->pos = 0;
  25       file->deny_write = false;
  26       return file;
  27     }
  28   else
  29     {
  30       inode_close (inode);
  31       free (file);
  32       return NULL;
  33     }
  34 }
  35
  36 /* Opens and returns a new file for the same inode as FILE.
  37    Returns a null pointer if unsuccessful. */
  38 struct file *
  39 file_reopen (struct file *file)
  40 {
  41   return file_open (inode_reopen (file->inode));
  42 }
  43
  44 /* Closes FILE. */
  45 void
  46 file_close (struct file *file)
  47 {
  48   if (file != NULL)
  49     {
  50       file_allow_write (file);
  51       inode_close (file->inode);
  52       free (file);
  53     }
  54 }
  55
  56 /* Returns the inode encapsulated by FILE. */
  57 struct inode *
  58 file_get_inode (struct file *file)
  59 {
  60   return file->inode;
  61 }
  62
  63 /* Reads SIZE bytes from FILE into BUFFER,
  64    starting at the file's current position.
  65    Returns the number of bytes actually read,
  66    which may be less than SIZE if end of file is reached.
  67    Advances FILE's position by the number of bytes read. */
  68 off_t
  69 file_read (struct file *file, void *buffer, off_t size)
  70 {
  71   off_t bytes_read = inode_read_at (file->inode, buffer, size, file->pos);
  72   file->pos += bytes_read;
  73   return bytes_read;
  74 }
  75
  76 /* Reads SIZE bytes from FILE into BUFFER,
  77    starting at offset FILE_OFS in the file.
  78    Returns the number of bytes actually read,
  79    which may be less than SIZE if end of file is reached.
  80    The file's current position is unaffected. */
  81 off_t
  82 file_read_at (struct file *file, void *buffer, off_t size, off_t file_ofs)
  83 {
  84   return inode_read_at (file->inode, buffer, size, file_ofs);
  85 }
  86
  87 /* Writes SIZE bytes from BUFFER into FILE,
  88    starting at the file's current position.
  89    Returns the number of bytes actually written,
  90    which may be less than SIZE if end of file is reached.
  91    (Normally we'd grow the file in that case, but file growth is
  92    not yet implemented.)
  93    Advances FILE's position by the number of bytes read. */
  94 off_t
  95 file_write (struct file *file, const void *buffer, off_t size)
  96 {
  97   off_t bytes_written = inode_write_at (file->inode, buffer, size, file->pos);
  98   file->pos += bytes_written;
  99   return bytes_written;
 100 }
 101
 102 /* Writes SIZE bytes from BUFFER into FILE,
 103    starting at offset FILE_OFS in the file.
 104    Returns the number of bytes actually written,
 105    which may be less than SIZE if end of file is reached.
 106    (Normally we'd grow the file in that case, but file growth is
 107    not yet implemented.)
 108    The file's current position is unaffected. */
 109 off_t
 110 file_write_at (struct file *file, const void *buffer, off_t size,
 111                off_t file_ofs)
 112 {
 113   return inode_write_at (file->inode, buffer, size, file_ofs);
 114 }
 115
 116 /* Prevents write operations on FILE's underlying inode
 117    until file_allow_write() is called or FILE is closed. */
 118 void
 119 file_deny_write (struct file *file)
 120 {
 121   ASSERT (file != NULL);
 122   if (!file->deny_write)
 123     {
 124       file->deny_write = true;
 125       inode_deny_write (file->inode);
 126     }
 127 }
 128
 129 /* Re-enables write operations on FILE's underlying inode.
 130    (Writes might still be denied by some other file that has the
 131    same inode open.) */
 132 void
 133 file_allow_write (struct file *file)
 134 {
 135   ASSERT (file != NULL);
 136   if (file->deny_write)
 137     {
 138       file->deny_write = false;
 139       inode_allow_write (file->inode);
 140     }
 141 }
 142
 143 /* Returns the size of FILE in bytes. */
 144 off_t
 145 file_length (struct file *file)
 146 {
 147   ASSERT (file != NULL);
 148   return inode_length (file->inode);
 149 }
 150
 151 /* Sets the current position in FILE to NEW_POS bytes from the
 152    start of the file. */
 153 void
 154 file_seek (struct file *file, off_t new_pos)
 155 {
 156   ASSERT (file != NULL);
 157   ASSERT (new_pos >= 0);
 158   file->pos = new_pos;
 159 }
 160
 161 /* Returns the current position in FILE as a byte offset from the
 162    start of the file. */
 163 off_t
 164 file_tell (struct file *file)
 165 {
 166   ASSERT (file != NULL);
 167   return file->pos;
 168 }