1 #include "filesys/inode.h"
6 #include "filesys/filesys.h"
7 #include "filesys/free-map.h"
8 #include "threads/malloc.h"
10 /* Identifies an inode. */
11 #define INODE_MAGIC 0x494e4f44
14 Must be exactly DISK_SECTOR_SIZE bytes long. */
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. */
23 /* Returns the number of sectors to allocate for an inode SIZE
26 bytes_to_sectors (off_t size)
28 return DIV_ROUND_UP (size, DISK_SECTOR_SIZE);
31 /* In-memory inode. */
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. */
42 /* Returns the disk sector that contains byte offset POS within
44 Returns -1 if INODE does not contain data for a byte at offset
47 byte_to_sector (const struct inode *inode, off_t pos)
49 ASSERT (inode != NULL);
50 if (pos < inode->data.length)
51 return inode->data.start + pos / DISK_SECTOR_SIZE;
56 /* List of open inodes, so that opening a single inode twice
57 returns the same `struct inode'. */
58 static struct list open_inodes;
60 /* Initializes the inode module. */
64 list_init (&open_inodes);
67 /* Initializes an inode with LENGTH bytes of data and
68 writes the new inode to sector SECTOR on the file system
70 Returns true if successful.
71 Returns false if memory or disk allocation fails. */
73 inode_create (disk_sector_t sector, off_t length)
75 struct inode_disk *disk_inode = NULL;
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);
84 disk_inode = calloc (1, sizeof *disk_inode);
85 if (disk_inode != NULL)
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))
92 disk_write (filesys_disk, sector, disk_inode);
95 static char zeros[DISK_SECTOR_SIZE];
98 for (i = 0; i < sectors; i++)
99 disk_write (filesys_disk, disk_inode->start + i, zeros);
108 /* Reads an inode from SECTOR
109 and returns a `struct inode' that contains it.
110 Returns a null pointer if memory allocation fails. */
112 inode_open (disk_sector_t sector)
117 /* Check whether this inode is already open. */
118 for (e = list_begin (&open_inodes); e != list_end (&open_inodes);
121 inode = list_entry (e, struct inode, elem);
122 if (inode->sector == sector)
124 inode_reopen (inode);
129 /* Allocate memory. */
130 inode = malloc (sizeof *inode);
135 list_push_front (&open_inodes, &inode->elem);
136 inode->sector = sector;
138 inode->deny_write_cnt = 0;
139 inode->removed = false;
140 disk_read (filesys_disk, inode->sector, &inode->data);
144 /* Reopens and returns INODE. */
146 inode_reopen (struct inode *inode)
153 /* Returns INODE's inode number. */
155 inode_get_inumber (const struct inode *inode)
157 return inode->sector;
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. */
164 inode_close (struct inode *inode)
166 /* Ignore null pointer. */
170 /* Release resources if this was the last opener. */
171 if (--inode->open_cnt == 0)
173 /* Remove from inode list and release lock. */
174 list_remove (&inode->elem);
176 /* Deallocate blocks if removed. */
179 free_map_release (inode->sector, 1);
180 free_map_release (inode->data.start,
181 bytes_to_sectors (inode->data.length));
188 /* Marks INODE to be deleted when it is closed by the last caller who
191 inode_remove (struct inode *inode)
193 ASSERT (inode != NULL);
194 inode->removed = true;
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. */
201 inode_read_at (struct inode *inode, void *buffer_, off_t size, off_t offset)
203 uint8_t *buffer = buffer_;
204 off_t bytes_read = 0;
205 uint8_t *bounce = NULL;
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;
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;
218 /* Number of bytes to actually copy out of this sector. */
219 int chunk_size = size < min_left ? size : min_left;
223 if (sector_ofs == 0 && chunk_size == DISK_SECTOR_SIZE)
225 /* Read full sector directly into caller's buffer. */
226 disk_read (filesys_disk, sector_idx, buffer + bytes_read);
230 /* Read sector into bounce buffer, then partially copy
231 into caller's buffer. */
234 bounce = malloc (DISK_SECTOR_SIZE);
238 disk_read (filesys_disk, sector_idx, bounce);
239 memcpy (buffer + bytes_read, bounce + sector_ofs, chunk_size);
244 offset += chunk_size;
245 bytes_read += chunk_size;
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.) */
258 inode_write_at (struct inode *inode, const void *buffer_, off_t size,
261 const uint8_t *buffer = buffer_;
262 off_t bytes_written = 0;
263 uint8_t *bounce = NULL;
265 if (inode->deny_write_cnt)
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;
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;
279 /* Number of bytes to actually write into this sector. */
280 int chunk_size = size < min_left ? size : min_left;
284 if (sector_ofs == 0 && chunk_size == DISK_SECTOR_SIZE)
286 /* Write full sector directly to disk. */
287 disk_write (filesys_disk, sector_idx, buffer + bytes_written);
291 /* We need a bounce buffer. */
294 bounce = malloc (DISK_SECTOR_SIZE);
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);
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);
312 offset += chunk_size;
313 bytes_written += chunk_size;
317 return bytes_written;
320 /* Disables writes to INODE.
321 May be called at most once per inode opener. */
323 inode_deny_write (struct inode *inode)
325 inode->deny_write_cnt++;
326 ASSERT (inode->deny_write_cnt <= inode->open_cnt);
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. */
333 inode_allow_write (struct inode *inode)
335 ASSERT (inode->deny_write_cnt > 0);
336 ASSERT (inode->deny_write_cnt <= inode->open_cnt);
337 inode->deny_write_cnt--;
340 /* Returns the length, in bytes, of INODE's data. */
342 inode_length (const struct inode *inode)
344 return inode->data.length;