fat.h File Reference

#include "devices/disk.h"
#include "filesys/file.h"
#include <inttypes.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>

Include dependency graph for fat.h:

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

Go to the source code of this file.

Macros
#define	FAT_MAGIC   0xEB3C9000 /* MAGIC string to identify FAT disk */
#define	EOChain   0x0FFFFFFF /* End of cluster chain */
#define	SECTORS_PER_CLUSTER   1 /* Number of sectors per cluster */
#define	FAT_BOOT_SECTOR   0 /* FAT boot sector. */
#define	ROOT_DIR_CLUSTER   1 /* Cluster for the root directory */

Typedefs
typedef uint32_t	cluster_t

Functions
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)
cluster_t	fat_get (cluster_t clst)
void	fat_put (cluster_t clst, cluster_t val)
disk_sector_t	cluster_to_sector (cluster_t clst)

Macro Definition Documentation

EOChain

#define EOChain   0x0FFFFFFF /* End of cluster chain */

FAT_BOOT_SECTOR

#define FAT_BOOT_SECTOR   0 /* FAT boot sector. */

FAT_MAGIC

#define FAT_MAGIC   0xEB3C9000 /* MAGIC string to identify FAT disk */

ROOT_DIR_CLUSTER

#define ROOT_DIR_CLUSTER   1 /* Cluster for the root directory */

SECTORS_PER_CLUSTER

#define SECTORS_PER_CLUSTER   1 /* Number of sectors per cluster */

Typedef Documentation

cluster_t

typedef uint32_t cluster_t

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_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_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. */
}