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

   1 #include "filesys/inode.h"
   2 #include <list.h>
   3 #include <debug.h>
   4 #include <round.h>
   5 #include <string.h>
   6 #include "filesys/filesys.h"
   7 #include "filesys/free-map.h"
   8 #include "threads/malloc.h"
   9
  10 /* Identifies an inode. */
  11 #define INODE_MAGIC 0x494e4f44
  12
  13 /* On-disk inode.
  14    Must be exactly DISK_SECTOR_SIZE bytes long. */
  15 struct inode_disk
  16   {
  17     disk_sector_t start;                /* First data sector. */
  18     off_t length;                       /* File size in bytes. */
  19     unsigned magic;                     /* Magic number. */
  20     uint32_t unused[125];               /* Not used. */
  21   };
  22
  23 /* Returns the number of sectors to allocate for an inode SIZE
  24    bytes long. */
  25 static inline size_t
  26 bytes_to_sectors (off_t size)
  27 {
  28   return DIV_ROUND_UP (size, DISK_SECTOR_SIZE);
  29 }
  30
  31 /* In-memory inode. */
  32 struct inode
  33   {
  34     struct list_elem elem;              /* Element in inode list. */
  35     disk_sector_t sector;               /* Sector number of disk location. */
  36     int open_cnt;                       /* Number of openers. */
  37     bool removed;                       /* True if deleted, false otherwise. */
  38     int deny_write_cnt;                 /* 0: writes ok, >0: deny writes. */
  39     struct inode_disk data;             /* Inode content. */
  40   };
  41
  42 /* Returns the disk sector that contains byte offset POS within
  43    INODE.
  44    Returns -1 if INODE does not contain data for a byte at offset
  45    POS. */
  46 static disk_sector_t
  47 byte_to_sector (const struct inode *inode, off_t pos)
  48 {
  49   ASSERT (inode != NULL);
  50   if (pos < inode->data.length)
  51     return inode->data.start + pos / DISK_SECTOR_SIZE;
  52   else
  53     return -1;
  54 }
  55
  56 /* List of open inodes, so that opening a single inode twice
  57    returns the same `struct inode'. */
  58 static struct list open_inodes;
  59
  60 /* Initializes the inode module. */
  61 void
  62 inode_init (void)
  63 {
  64   list_init (&open_inodes);
  65 }
  66
  67 /* Initializes an inode with LENGTH bytes of data and
  68    writes the new inode to sector SECTOR on the file system
  69    disk.
  70    Returns true if successful.
  71    Returns false if memory or disk allocation fails. */
  72 bool
  73 inode_create (disk_sector_t sector, off_t length)
  74 {
  75   struct inode_disk *disk_inode = NULL;
  76   bool success = false;
  77
  78   ASSERT (length >= 0);
  79
  80   /* If this assertion fails, the inode structure is not exactly
  81      one sector in size, and you should fix that. */
  82   ASSERT (sizeof *disk_inode == DISK_SECTOR_SIZE);
  83
  84   disk_inode = calloc (1, sizeof *disk_inode);
  85   if (disk_inode != NULL)
  86     {
  87       size_t sectors = bytes_to_sectors (length);
  88       disk_inode->length = length;
  89       disk_inode->magic = INODE_MAGIC;
  90       if (free_map_allocate (sectors, &disk_inode->start))
  91         {
  92           disk_write (filesys_disk, sector, disk_inode);
  93           if (sectors > 0)
  94             {
  95               static char zeros[DISK_SECTOR_SIZE];
  96               size_t i;
  97
  98               for (i = 0; i < sectors; i++)
  99                 disk_write (filesys_disk, disk_inode->start + i, zeros);
 100             }
 101           success = true;
 102         }
 103       free (disk_inode);
 104     }
 105   return success;
 106 }
 107
 108 /* Reads an inode from SECTOR
 109    and returns a `struct inode' that contains it.
 110    Returns a null pointer if memory allocation fails. */
 111 struct inode *
 112 inode_open (disk_sector_t sector)
 113 {
 114   struct list_elem *e;
 115   struct inode *inode;
 116
 117   /* Check whether this inode is already open. */
 118   for (e = list_begin (&open_inodes); e != list_end (&open_inodes);
 119        e = list_next (e))
 120     {
 121       inode = list_entry (e, struct inode, elem);
 122       if (inode->sector == sector)
 123         {
 124           inode_reopen (inode);
 125           return inode;
 126         }
 127     }
 128
 129   /* Allocate memory. */
 130   inode = malloc (sizeof *inode);
 131   if (inode == NULL)
 132     return NULL;
 133
 134   /* Initialize. */
 135   list_push_front (&open_inodes, &inode->elem);
 136   inode->sector = sector;
 137   inode->open_cnt = 1;
 138   inode->deny_write_cnt = 0;
 139   inode->removed = false;
 140   disk_read (filesys_disk, inode->sector, &inode->data);
 141   return inode;
 142 }
 143
 144 /* Reopens and returns INODE. */
 145 struct inode *
 146 inode_reopen (struct inode *inode)
 147 {
 148   if (inode != NULL)
 149     inode->open_cnt++;
 150   return inode;
 151 }
 152
 153 /* Returns INODE's inode number. */
 154 disk_sector_t
 155 inode_get_inumber (const struct inode *inode)
 156 {
 157   return inode->sector;
 158 }
 159
 160 /* Closes INODE and writes it to disk.
 161    If this was the last reference to INODE, frees its memory.
 162    If INODE was also a removed inode, frees its blocks. */
 163 void
 164 inode_close (struct inode *inode)
 165 {
 166   /* Ignore null pointer. */
 167   if (inode == NULL)
 168     return;
 169
 170   /* Release resources if this was the last opener. */
 171   if (--inode->open_cnt == 0)
 172     {
 173       /* Remove from inode list and release lock. */
 174       list_remove (&inode->elem);
 175
 176       /* Deallocate blocks if removed. */
 177       if (inode->removed)
 178         {
 179           free_map_release (inode->sector, 1);
 180           free_map_release (inode->data.start,
 181                             bytes_to_sectors (inode->data.length));
 182         }
 183
 184       free (inode);
 185     }
 186 }
 187
 188 /* Marks INODE to be deleted when it is closed by the last caller who
 189    has it open. */
 190 void
 191 inode_remove (struct inode *inode)
 192 {
 193   ASSERT (inode != NULL);
 194   inode->removed = true;
 195 }
 196
 197 /* Reads SIZE bytes from INODE into BUFFER, starting at position OFFSET.
 198    Returns the number of bytes actually read, which may be less
 199    than SIZE if an error occurs or end of file is reached. */
 200 off_t
 201 inode_read_at (struct inode *inode, void *buffer_, off_t size, off_t offset)
 202 {
 203   uint8_t *buffer = buffer_;
 204   off_t bytes_read = 0;
 205   uint8_t *bounce = NULL;
 206
 207   while (size > 0)
 208     {
 209       /* Disk sector to read, starting byte offset within sector. */
 210       disk_sector_t sector_idx = byte_to_sector (inode, offset);
 211       int sector_ofs = offset % DISK_SECTOR_SIZE;
 212
 213       /* Bytes left in inode, bytes left in sector, lesser of the two. */
 214       off_t inode_left = inode_length (inode) - offset;
 215       int sector_left = DISK_SECTOR_SIZE - sector_ofs;
 216       int min_left = inode_left < sector_left ? inode_left : sector_left;
 217
 218       /* Number of bytes to actually copy out of this sector. */
 219       int chunk_size = size < min_left ? size : min_left;
 220       if (chunk_size <= 0)
 221         break;
 222
 223       if (sector_ofs == 0 && chunk_size == DISK_SECTOR_SIZE)
 224         {
 225           /* Read full sector directly into caller's buffer. */
 226           disk_read (filesys_disk, sector_idx, buffer + bytes_read);
 227         }
 228       else
 229         {
 230           /* Read sector into bounce buffer, then partially copy
 231              into caller's buffer. */
 232           if (bounce == NULL)
 233             {
 234               bounce = malloc (DISK_SECTOR_SIZE);
 235               if (bounce == NULL)
 236                 break;
 237             }
 238           disk_read (filesys_disk, sector_idx, bounce);
 239           memcpy (buffer + bytes_read, bounce + sector_ofs, chunk_size);
 240         }
 241
 242       /* Advance. */
 243       size -= chunk_size;
 244       offset += chunk_size;
 245       bytes_read += chunk_size;
 246     }
 247   free (bounce);
 248
 249   return bytes_read;
 250 }
 251
 252 /* Writes SIZE bytes from BUFFER into INODE, starting at OFFSET.
 253    Returns the number of bytes actually written, which may be
 254    less than SIZE if end of file is reached or an error occurs.
 255    (Normally a write at end of file would extend the inode, but
 256    growth is not yet implemented.) */
 257 off_t
 258 inode_write_at (struct inode *inode, const void *buffer_, off_t size,
 259                 off_t offset)
 260 {
 261   const uint8_t *buffer = buffer_;
 262   off_t bytes_written = 0;
 263   uint8_t *bounce = NULL;
 264
 265   if (inode->deny_write_cnt)
 266     return 0;
 267
 268   while (size > 0)
 269     {
 270       /* Sector to write, starting byte offset within sector. */
 271       disk_sector_t sector_idx = byte_to_sector (inode, offset);
 272       int sector_ofs = offset % DISK_SECTOR_SIZE;
 273
 274       /* Bytes left in inode, bytes left in sector, lesser of the two. */
 275       off_t inode_left = inode_length (inode) - offset;
 276       int sector_left = DISK_SECTOR_SIZE - sector_ofs;
 277       int min_left = inode_left < sector_left ? inode_left : sector_left;
 278
 279       /* Number of bytes to actually write into this sector. */
 280       int chunk_size = size < min_left ? size : min_left;
 281       if (chunk_size <= 0)
 282         break;
 283
 284       if (sector_ofs == 0 && chunk_size == DISK_SECTOR_SIZE)
 285         {
 286           /* Write full sector directly to disk. */
 287           disk_write (filesys_disk, sector_idx, buffer + bytes_written);
 288         }
 289       else
 290         {
 291           /* We need a bounce buffer. */
 292           if (bounce == NULL)
 293             {
 294               bounce = malloc (DISK_SECTOR_SIZE);
 295               if (bounce == NULL)
 296                 break;
 297             }
 298
 299           /* If the sector contains data before or after the chunk
 300              we're writing, then we need to read in the sector
 301              first.  Otherwise we start with a sector of all zeros. */
 302           if (sector_ofs > 0 || chunk_size < sector_left)
 303             disk_read (filesys_disk, sector_idx, bounce);
 304           else
 305             memset (bounce, 0, DISK_SECTOR_SIZE);
 306           memcpy (bounce + sector_ofs, buffer + bytes_written, chunk_size);
 307           disk_write (filesys_disk, sector_idx, bounce);
 308         }
 309
 310       /* Advance. */
 311       size -= chunk_size;
 312       offset += chunk_size;
 313       bytes_written += chunk_size;
 314     }
 315   free (bounce);
 316
 317   return bytes_written;
 318 }
 319
 320 /* Disables writes to INODE.
 321    May be called at most once per inode opener. */
 322 void
 323 inode_deny_write (struct inode *inode)
 324 {
 325   inode->deny_write_cnt++;
 326   ASSERT (inode->deny_write_cnt <= inode->open_cnt);
 327 }
 328
 329 /* Re-enables writes to INODE.
 330    Must be called once by each inode opener who has called
 331    inode_deny_write() on the inode, before closing the inode. */
 332 void
 333 inode_allow_write (struct inode *inode)
 334 {
 335   ASSERT (inode->deny_write_cnt > 0);
 336   ASSERT (inode->deny_write_cnt <= inode->open_cnt);
 337   inode->deny_write_cnt--;
 338 }
 339
 340 /* Returns the length, in bytes, of INODE's data. */
 341 off_t
 342 inode_length (const struct inode *inode)
 343 {
 344   return inode->data.length;
 345 }