inode.h File Reference

#include <stdbool.h>
#include "filesys/off_t.h"
#include "devices/disk.h"

Include dependency graph for inode.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	inode_init (void)
bool	inode_create (disk_sector_t, off_t)
struct inode *	inode_open (disk_sector_t)
struct inode *	inode_reopen (struct inode *)
disk_sector_t	inode_get_inumber (const struct inode *)
void	inode_close (struct inode *)
void	inode_remove (struct inode *)
off_t	inode_read_at (struct inode *, void *, off_t size, off_t offset)
off_t	inode_write_at (struct inode *, const void *, off_t size, off_t offset)
void	inode_deny_write (struct inode *)
void	inode_allow_write (struct inode *)
off_t	inode_length (const struct inode *)

Function Documentation

inode_allow_write()

void inode_allow_write

(

struct inode *

inode

)

                                        {
    ASSERT (inode->deny_write_cnt > 0);
    ASSERT (inode->deny_write_cnt <= inode->open_cnt);
    inode->deny_write_cnt--;
}

Here is the caller graph for this function:

inode_close()

void inode_close

(

struct inode *

inode

)

                                  {
    /* Ignore null pointer. */
    if (inode == NULL)
        return;
 
    /* Release resources if this was the last opener. */
    if (--inode->open_cnt == 0) {
        /* Remove from inode list and release lock. */
        list_remove (&inode->elem);
 
        /* Deallocate blocks if removed. */
        if (inode->removed) {
            free_map_release (inode->sector, 1);
            free_map_release (inode->data.start,
                    bytes_to_sectors (inode->data.length)); 
        }
 
        free (inode); 
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

inode_create()

bool inode_create	(	disk_sector_t	sector,
		off_t	length
	)

                                                  {
    struct inode_disk *disk_inode = NULL;
    bool success = false;
 
    ASSERT (length >= 0);
 
    /* If this assertion fails, the inode structure is not exactly
     * one sector in size, and you should fix that. */
    ASSERT (sizeof *disk_inode == DISK_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)) {
            disk_write (filesys_disk, sector, disk_inode);
            if (sectors > 0) {
                static char zeros[DISK_SECTOR_SIZE];
                size_t i;
 
                for (i = 0; i < sectors; i++) 
                    disk_write (filesys_disk, disk_inode->start + i, zeros); 
            }
            success = true; 
        } 
        free (disk_inode);
    }
    return success;
}

Here is the call graph for this function:

Here is the caller graph for this function:

inode_deny_write()

void inode_deny_write

(

struct inode *

inode

)

{
    inode->deny_write_cnt++;
    ASSERT (inode->deny_write_cnt <= inode->open_cnt);
}

Here is the caller graph for this function:

inode_get_inumber()

disk_sector_t inode_get_inumber

(

const struct inode *

inode

)

                                              {
    return inode->sector;
}

inode_init()

void inode_init

(

void

)

                  {
    list_init (&open_inodes);
}

Here is the call graph for this function:

Here is the caller graph for this function:

inode_length()

off_t inode_length

(

const struct inode *

inode

)

                                         {
    return inode->data.length;
}

Here is the caller graph for this function:

inode_open()

struct inode * inode_open

(

disk_sector_t

sector

)

                                  {
    struct list_elem *e;
    struct inode *inode;
 
    /* Check whether this inode is already open. */
    for (e = list_begin (&open_inodes); e != list_end (&open_inodes);
            e = list_next (e)) {
        inode = list_entry (e, struct inode, elem);
        if (inode->sector == sector) {
            inode_reopen (inode);
            return inode; 
        }
    }
 
    /* Allocate memory. */
    inode = malloc (sizeof *inode);
    if (inode == NULL)
        return NULL;
 
    /* Initialize. */
    list_push_front (&open_inodes, &inode->elem);
    inode->sector = sector;
    inode->open_cnt = 1;
    inode->deny_write_cnt = 0;
    inode->removed = false;
    disk_read (filesys_disk, inode->sector, &inode->data);
    return inode;
}

Here is the call graph for this function:

Here is the caller graph for this function:

inode_read_at()

off_t inode_read_at	(	struct inode *	inode,
		void *	buffer_,
		off_t	size,
		off_t	offset
	)

                                                                             {
    uint8_t *buffer = buffer_;
    off_t bytes_read = 0;
    uint8_t *bounce = NULL;
 
    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;
 
        /* 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 min_left = inode_left < sector_left ? inode_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;
 
        if (sector_ofs == 0 && chunk_size == DISK_SECTOR_SIZE) {
            /* Read full sector directly into caller's buffer. */
            disk_read (filesys_disk, sector_idx, buffer + bytes_read); 
        } else {
            /* Read sector into bounce buffer, then partially copy
             * into caller's buffer. */
            if (bounce == NULL) {
                bounce = malloc (DISK_SECTOR_SIZE);
                if (bounce == NULL)
                    break;
            }
            disk_read (filesys_disk, sector_idx, bounce);
            memcpy (buffer + bytes_read, bounce + sector_ofs, chunk_size);
        }
 
        /* Advance. */
        size -= chunk_size;
        offset += chunk_size;
        bytes_read += chunk_size;
    }
    free (bounce);
 
    return bytes_read;
}

Here is the call graph for this function:

Here is the caller graph for this function:

inode_remove()

void inode_remove

(

struct inode *

inode

)

                                   {
    ASSERT (inode != NULL);
    inode->removed = true;
}

Here is the caller graph for this function:

inode_reopen()

struct inode * inode_reopen

(

struct inode *

inode

)

                                   {
    if (inode != NULL)
        inode->open_cnt++;
    return inode;
}

Here is the caller graph for this function:

inode_write_at()

off_t inode_write_at	(	struct inode *	inode,
		const void *	buffer_,
		off_t	size,
		off_t	offset
	)

                      {
    const uint8_t *buffer = buffer_;
    off_t bytes_written = 0;
    uint8_t *bounce = NULL;
 
    if (inode->deny_write_cnt)
        return 0;
 
    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;
 
        /* 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 min_left = inode_left < sector_left ? inode_left : sector_left;
 
        /* Number of bytes to actually write into this sector. */
        int chunk_size = size < min_left ? size : min_left;
        if (chunk_size <= 0)
            break;
 
        if (sector_ofs == 0 && chunk_size == DISK_SECTOR_SIZE) {
            /* Write full sector directly to disk. */
            disk_write (filesys_disk, sector_idx, buffer + bytes_written); 
        } else {
            /* We need a bounce buffer. */
            if (bounce == NULL) {
                bounce = malloc (DISK_SECTOR_SIZE);
                if (bounce == NULL)
                    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_left) 
                disk_read (filesys_disk, sector_idx, bounce);
            else
                memset (bounce, 0, DISK_SECTOR_SIZE);
            memcpy (bounce + sector_ofs, buffer + bytes_written, chunk_size);
            disk_write (filesys_disk, sector_idx, bounce); 
        }
 
        /* Advance. */
        size -= chunk_size;
        offset += chunk_size;
        bytes_written += chunk_size;
    }
    free (bounce);
 
    return bytes_written;
}

Here is the call graph for this function:

Here is the caller graph for this function: