#define INODE_MAGIC 0x494e4f44
/* On-disk inode.
- Must be exactly DISK_SECTOR_SIZE bytes long. */
+ Must be exactly BLOCK_SECTOR_SIZE bytes long. */
struct inode_disk
{
- disk_sector_t start; /* First data sector. */
+ block_sector_t start; /* First data sector. */
off_t length; /* File size in bytes. */
unsigned magic; /* Magic number. */
uint32_t unused[125]; /* Not used. */
static inline size_t
bytes_to_sectors (off_t size)
{
- return DIV_ROUND_UP (size, DISK_SECTOR_SIZE);
+ return DIV_ROUND_UP (size, BLOCK_SECTOR_SIZE);
}
/* In-memory inode. */
struct inode
{
struct list_elem elem; /* Element in inode list. */
- disk_sector_t sector; /* Sector number of disk location. */
+ block_sector_t sector; /* Sector number of disk location. */
int open_cnt; /* Number of openers. */
bool removed; /* True if deleted, false otherwise. */
int deny_write_cnt; /* 0: writes ok, >0: deny writes. */
struct inode_disk data; /* Inode content. */
};
-/* Returns the disk sector that contains byte offset POS within
- INODE.
+/* Returns the block device sector that contains byte offset POS
+ within INODE.
Returns -1 if INODE does not contain data for a byte at offset
POS. */
-static disk_sector_t
+static block_sector_t
byte_to_sector (const struct inode *inode, off_t pos)
{
ASSERT (inode != NULL);
if (pos < inode->data.length)
- return inode->data.start + pos / DISK_SECTOR_SIZE;
+ return inode->data.start + pos / BLOCK_SECTOR_SIZE;
else
return -1;
}
/* Initializes an inode with LENGTH bytes of data and
writes the new inode to sector SECTOR on the file system
- disk.
+ device.
Returns true if successful.
Returns false if memory or disk allocation fails. */
bool
-inode_create (disk_sector_t sector, off_t length)
+inode_create (block_sector_t sector, off_t length)
{
struct inode_disk *disk_inode = NULL;
bool success = false;
ASSERT (length >= 0);
- ASSERT (sizeof *disk_inode == DISK_SECTOR_SIZE);
+
+ /* If this assertion fails, the inode structure is not exactly
+ one sector in size, and you should fix that. */
+ ASSERT (sizeof *disk_inode == BLOCK_SECTOR_SIZE);
disk_inode = calloc (1, sizeof *disk_inode);
if (disk_inode != NULL)
size_t sectors = bytes_to_sectors (length);
disk_inode->length = length;
disk_inode->magic = INODE_MAGIC;
- if (free_map_allocate (sectors, &disk_inode->start))
+ if (free_map_allocate (sectors, &disk_inode->start))
{
- disk_write (filesys_disk, sector, disk_inode);
+ block_write (fs_device, sector, disk_inode);
if (sectors > 0)
{
- static char zeros[DISK_SECTOR_SIZE];
+ static char zeros[BLOCK_SECTOR_SIZE];
size_t i;
for (i = 0; i < sectors; i++)
- disk_write (filesys_disk, disk_inode->start + i, zeros);
+ block_write (fs_device, disk_inode->start + i, zeros);
}
success = true;
}
and returns a `struct inode' that contains it.
Returns a null pointer if memory allocation fails. */
struct inode *
-inode_open (disk_sector_t sector)
+inode_open (block_sector_t sector)
{
struct list_elem *e;
struct inode *inode;
inode->open_cnt = 1;
inode->deny_write_cnt = 0;
inode->removed = false;
- disk_read (filesys_disk, inode->sector, &inode->data);
+ block_read (fs_device, inode->sector, &inode->data);
return inode;
}
/* Reopens and returns INODE. */
struct inode *
-inode_reopen (struct inode *inode)
+inode_reopen (struct inode *inode)
{
- if (inode != NULL)
+ if (inode != NULL)
inode->open_cnt++;
return inode;
}
+/* Returns INODE's inode number. */
+block_sector_t
+inode_get_inumber (const struct inode *inode)
+{
+ return inode->sector;
+}
+
/* Closes INODE and writes it to disk.
If this was the last reference to INODE, frees its memory.
If INODE was also a removed inode, frees its blocks. */
while (size > 0)
{
/* Disk sector to read, starting byte offset within sector. */
- disk_sector_t sector_idx = byte_to_sector (inode, offset);
- int sector_ofs = offset % DISK_SECTOR_SIZE;
+ block_sector_t sector_idx = byte_to_sector (inode, offset);
+ int sector_ofs = offset % BLOCK_SECTOR_SIZE;
/* Bytes left in inode, bytes left in sector, lesser of the two. */
off_t inode_left = inode_length (inode) - offset;
- int sector_left = DISK_SECTOR_SIZE - sector_ofs;
+ int sector_left = BLOCK_SECTOR_SIZE - sector_ofs;
int min_left = inode_left < sector_left ? inode_left : sector_left;
/* Number of bytes to actually copy out of this sector. */
if (chunk_size <= 0)
break;
- if (sector_ofs == 0 && chunk_size == DISK_SECTOR_SIZE)
+ if (sector_ofs == 0 && chunk_size == BLOCK_SECTOR_SIZE)
{
/* Read full sector directly into caller's buffer. */
- disk_read (filesys_disk, sector_idx, buffer + bytes_read);
+ block_read (fs_device, sector_idx, buffer + bytes_read);
}
else
{
into caller's buffer. */
if (bounce == NULL)
{
- bounce = malloc (DISK_SECTOR_SIZE);
+ bounce = malloc (BLOCK_SECTOR_SIZE);
if (bounce == NULL)
break;
}
- disk_read (filesys_disk, sector_idx, bounce);
+ block_read (fs_device, sector_idx, bounce);
memcpy (buffer + bytes_read, bounce + sector_ofs, chunk_size);
}
while (size > 0)
{
/* Sector to write, starting byte offset within sector. */
- disk_sector_t sector_idx = byte_to_sector (inode, offset);
- int sector_ofs = offset % DISK_SECTOR_SIZE;
+ block_sector_t sector_idx = byte_to_sector (inode, offset);
+ int sector_ofs = offset % BLOCK_SECTOR_SIZE;
/* Bytes left in inode, bytes left in sector, lesser of the two. */
off_t inode_left = inode_length (inode) - offset;
- int sector_left = DISK_SECTOR_SIZE - sector_ofs;
+ int sector_left = BLOCK_SECTOR_SIZE - sector_ofs;
int min_left = inode_left < sector_left ? inode_left : sector_left;
/* Number of bytes to actually write into this sector. */
if (chunk_size <= 0)
break;
- if (sector_ofs == 0 && chunk_size == DISK_SECTOR_SIZE)
+ if (sector_ofs == 0 && chunk_size == BLOCK_SECTOR_SIZE)
{
/* Write full sector directly to disk. */
- disk_write (filesys_disk, sector_idx, buffer + bytes_written);
+ block_write (fs_device, sector_idx, buffer + bytes_written);
}
else
{
/* We need a bounce buffer. */
if (bounce == NULL)
{
- bounce = malloc (DISK_SECTOR_SIZE);
+ bounce = malloc (BLOCK_SECTOR_SIZE);
if (bounce == NULL)
break;
}
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_left)
- disk_read (filesys_disk, sector_idx, bounce);
+ block_read (fs_device, sector_idx, bounce);
else
- memset (bounce, 0, DISK_SECTOR_SIZE);
+ memset (bounce, 0, BLOCK_SECTOR_SIZE);
memcpy (bounce + sector_ofs, buffer + bytes_written, chunk_size);
- disk_write (filesys_disk, sector_idx, bounce);
+ block_write (fs_device, sector_idx, bounce);
}
/* Advance. */
projects / pintos-anon / blobdiff