fat.c File Reference

#include "filesys/fat.h"
#include "devices/disk.h"
#include "filesys/filesys.h"
#include "threads/malloc.h"
#include "threads/synch.h"
#include <stdio.h>
#include <string.h>

Include dependency graph for fat.c:

Classes
struct	fat_boot
struct	fat_fs

Functions
void	fat_boot_create (void)
void	fat_fs_init (void)
void	fat_init (void)
void	fat_open (void)
void	fat_close (void)
void	fat_create (void)
cluster_t	fat_create_chain (cluster_t clst)
void	fat_remove_chain (cluster_t clst, cluster_t pclst)
void	fat_put (cluster_t clst, cluster_t val)
cluster_t	fat_get (cluster_t clst)
disk_sector_t	cluster_to_sector (cluster_t clst)

Variables
static struct fat_fs *	fat_fs

Function Documentation

cluster_to_sector()

disk_sector_t cluster_to_sector

(

cluster_t

clst

)

                                   {
    /* TODO: Your code goes here. */
}

Here is the caller graph for this function:

fat_boot_create()

void fat_boot_create

(

void

)

                       {
    unsigned int fat_sectors =
        (disk_size (filesys_disk) - 1)
        / (DISK_SECTOR_SIZE / sizeof (cluster_t) * SECTORS_PER_CLUSTER + 1) + 1;
    fat_fs->bs = (struct fat_boot){
        .magic = FAT_MAGIC,
        .sectors_per_cluster = SECTORS_PER_CLUSTER,
        .total_sectors = disk_size (filesys_disk),
        .fat_start = 1,
        .fat_sectors = fat_sectors,
        .root_dir_cluster = ROOT_DIR_CLUSTER,
    };
}

Here is the call graph for this function:

Here is the caller graph for this function:

fat_close()

void fat_close

(

void

)

                 {
    // Write FAT boot sector
    uint8_t *bounce = calloc (1, DISK_SECTOR_SIZE);
    if (bounce == NULL)
        PANIC ("FAT close failed");
    memcpy (bounce, &fat_fs->bs, sizeof (fat_fs->bs));
    disk_write (filesys_disk, FAT_BOOT_SECTOR, bounce);
    free (bounce);
 
    // Write FAT directly to the disk
    uint8_t *buffer = (uint8_t *) fat_fs->fat;
    off_t bytes_wrote = 0;
    off_t bytes_left = sizeof (fat_fs->fat);
    const off_t fat_size_in_bytes = fat_fs->fat_length * sizeof (cluster_t);
    for (unsigned i = 0; i < fat_fs->bs.fat_sectors; i++) {
        bytes_left = fat_size_in_bytes - bytes_wrote;
        if (bytes_left >= DISK_SECTOR_SIZE) {
            disk_write (filesys_disk, fat_fs->bs.fat_start + i,
                        buffer + bytes_wrote);
            bytes_wrote += DISK_SECTOR_SIZE;
        } else {
            bounce = calloc (1, DISK_SECTOR_SIZE);
            if (bounce == NULL)
                PANIC ("FAT close failed");
            memcpy (bounce, buffer + bytes_wrote, bytes_left);
            disk_write (filesys_disk, fat_fs->bs.fat_start + i, bounce);
            bytes_wrote += bytes_left;
            free (bounce);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

fat_create()

void fat_create

(

void

)

                  {
    // Create FAT boot
    fat_boot_create ();
    fat_fs_init ();
 
    // Create FAT table
    fat_fs->fat = calloc (fat_fs->fat_length, sizeof (cluster_t));
    if (fat_fs->fat == NULL)
        PANIC ("FAT creation failed");
 
    // Set up ROOT_DIR_CLST
    fat_put (ROOT_DIR_CLUSTER, EOChain);
 
    // Fill up ROOT_DIR_CLUSTER region with 0
    uint8_t *buf = calloc (1, DISK_SECTOR_SIZE);
    if (buf == NULL)
        PANIC ("FAT create failed due to OOM");
    disk_write (filesys_disk, cluster_to_sector (ROOT_DIR_CLUSTER), buf);
    free (buf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

fat_create_chain()

cluster_t fat_create_chain

(

cluster_t

clst

)

                                  {
    /* TODO: Your code goes here. */
}

fat_fs_init()

void fat_fs_init

(

void

)

                   {
    /* TODO: Your code goes here. */
}

Here is the caller graph for this function:

fat_get()

cluster_t fat_get

(

cluster_t

clst

)

                         {
    /* TODO: Your code goes here. */
}

fat_init()

void fat_init

(

void

)

                {
    fat_fs = calloc (1, sizeof (struct fat_fs));
    if (fat_fs == NULL)
        PANIC ("FAT init failed");
 
    // Read boot sector from the disk
    unsigned int *bounce = malloc (DISK_SECTOR_SIZE);
    if (bounce == NULL)
        PANIC ("FAT init failed");
    disk_read (filesys_disk, FAT_BOOT_SECTOR, bounce);
    memcpy (&fat_fs->bs, bounce, sizeof (fat_fs->bs));
    free (bounce);
 
    // Extract FAT info
    if (fat_fs->bs.magic != FAT_MAGIC)
        fat_boot_create ();
    fat_fs_init ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

fat_open()

void fat_open

(

void

)

                {
    fat_fs->fat = calloc (fat_fs->fat_length, sizeof (cluster_t));
    if (fat_fs->fat == NULL)
        PANIC ("FAT load failed");
 
    // Load FAT directly from the disk
    uint8_t *buffer = (uint8_t *) fat_fs->fat;
    off_t bytes_read = 0;
    off_t bytes_left = sizeof (fat_fs->fat);
    const off_t fat_size_in_bytes = fat_fs->fat_length * sizeof (cluster_t);
    for (unsigned i = 0; i < fat_fs->bs.fat_sectors; i++) {
        bytes_left = fat_size_in_bytes - bytes_read;
        if (bytes_left >= DISK_SECTOR_SIZE) {
            disk_read (filesys_disk, fat_fs->bs.fat_start + i,
                       buffer + bytes_read);
            bytes_read += DISK_SECTOR_SIZE;
        } else {
            uint8_t *bounce = malloc (DISK_SECTOR_SIZE);
            if (bounce == NULL)
                PANIC ("FAT load failed");
            disk_read (filesys_disk, fat_fs->bs.fat_start + i, bounce);
            memcpy (buffer + bytes_read, bounce, bytes_left);
            bytes_read += bytes_left;
            free (bounce);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

fat_put()

void fat_put	(	cluster_t	clst,
		cluster_t	val
	)

                                        {
    /* TODO: Your code goes here. */
}

Here is the caller graph for this function:

fat_remove_chain()

void fat_remove_chain	(	cluster_t	clst,
		cluster_t	pclst
	)

                                                   {
    /* TODO: Your code goes here. */
}

Variable Documentation

fat_fs

struct fat_fs* fat_fs

static