---

fat12.c

Go to the documentation of this file.

/*!     \file fs/fat12/fat12.c
 *      \brief FAT-12 fyle system.
 *      \author
 *              Matteo Chesi <dalamar@inwind.it>
 *              Rudy Manganelli <feller@libero.it>
 *              Andrea Righi <drizzt@inwind.it>
 *      \date Last update: 2003-11-09
 *      \note Copyright (&copy;) 2003
 *              Matteo Chesi <dalamar@inwind.it>
 *              Rudy Manganelli <feller@libero.it>
 *              Andrea Righi <drizzt@inwind.it>
 */

#include <const.h>
#include <string.h>

#include <arch/mem.h>

#include <kernel/console.h>
#include <kernel/floppy.h>
#include <kernel/keyboard.h>
#include <kernel/kmalloc.h>

#include <kernel/fat.h>

// FAT global variables //
bootsect_t bootsector;
FAT12_t fat;
logical_FAT12_t lfat;
word directory=0;
char path[256];

// ---------- File system procedures ---------- //
bool next_sector(word *next, word actual)
{
        *next = lfat.data[actual];
        if ( (*next == 0) || (*next >= 0x0FF0) )
                return(FALSE);
        else
                return(TRUE);
}

int how_many_cluster(word start)
{
        word c=1, cl;

        // The root directory (start=0) has a fixed size                        //
        if (!start)
                return( (bootsector.RootDirectoryEntries*sizeof(FileEntry_t))/bootsector.BytesPerSector );

        // Calculate the size of the directory (it's not the root!)             //
        cl=start;

        while (next_sector(&cl, cl)) c++;
        return(c);
}

void int_to_date(date_t *d, word date)
{
        d->year=date/512;
        d->month=(date-(d->year*512))/32;
        d->day=date-(d->year*512)-(d->month*32);
}

void int_to_time(fat_time_t *time, word t)
{
        time->hour=t/2048;
        time->minute=(t-(time->hour*2048))/32;
        time->second=(t-(time->hour*2048)-(time->minute*32))*2;
}

void read_attrib(attrib_t *FileAttr, byte attrib)
{
        FileAttr->RW=       (attrib & (byte)0x1) && 0x1;
        FileAttr->Hidden=   (attrib & (byte)0x2) && 0x2;
        FileAttr->System=   (attrib & (byte)0x4) && 0x4;
        FileAttr->Label=    (attrib & (byte)0x8) && 0x8;
        FileAttr->Directory=(attrib & (byte)0x10)&& 0x10;
        FileAttr->Archived= (attrib & (byte)0x20)&& 0x20;
        FileAttr->Reserved= attrib>>6;
}

char *show_attrib(attrib_t *FileAttr, char *stringa)
{
        if (FileAttr->Label)
        {
                stringa="LABEL   ";
                return stringa;
        }
        if (FileAttr->Directory)
        {
                stringa="DIR     ";
                return stringa;
        }
        stringa[0]='r';
        if (FileAttr->RW) stringa[1]='-'; //ReadOnly
        else stringa[1]='+';//Read and Write
        stringa[2]='h';
        if (FileAttr->Hidden) stringa[3]='+'; //Hidden
        else stringa[3]='-';//Visible
        stringa[4]='s';
        if (FileAttr->System) stringa[5]='+'; //System
        else stringa[5]='-';//NonSystem
        stringa[6]='a';
        if (FileAttr->Archived) stringa[7]='+'; //Archived
        else stringa[7]='-';//NotArchived
        stringa[8]='\0';

        return stringa;
}

char *file_name(FileEntry_t *temp, char *stringa)
{
        int k, a;

        a=0;
        for(k=0; k<8; k++)
        {
                if ((temp->Name[k]!=0)&&(temp->Name[k]!=' '))
                {
                        stringa[k]=temp->Name[k];
                        a=k;
                }
        }
        for(k=0;k<3;k++)
        {
                if (temp->Extension[k]!=' ')
                {
                        if (k==0) stringa[++a]='.';
                        stringa[++a]=temp->Extension[k];
                }
        }
        for(a++;a<12;a++) stringa[a]=' ';
        stringa[12]='\0';

        return stringa;
}

bool show_file_entry(FileEntry_t *TempFile)
{
        date_t FileDate;
        fat_time_t FileTime;
        attrib_t FileAttr;
        char Attributi[8];
        char Nome[13];

        read_attrib(&FileAttr, TempFile->Attribute);
        if (!FileAttr.Label)
        {
                if ( (TempFile->Name[0]) && (TempFile->Name[0]!=0xE5) )
                {
                        if (TempFile->Name[0]==0x05) TempFile->Name[0]=0xE5;
                        int_to_date(&FileDate, TempFile->Date);
                        int_to_time(&FileTime, TempFile->Time);

                        kprintf("%s", file_name(TempFile, Nome));
                        gotoxy(15, -1);
                        kprintf("%s", show_attrib(&FileAttr, Attributi));
                        gotoxy(25, -1);
                        kprintf("%d/%d/%u", FileDate.day, FileDate.month, (FileDate.year+1980));
                        gotoxy(36, -1);
                        kprintf("%d:%d:%d", FileTime.hour, FileTime.minute, FileTime.second);
                        gotoxy(46, -1);
                        kprintf("S:%#x", TempFile->StartCluster);
                        gotoxy(60, -1);
                        kprintf("D:%u", TempFile->FileLength);
                        kprintf("\n\r");

                        if (TempFile->Name[0]==0xE5) TempFile->Name[0]=0x05;

                        return TRUE;
                }
        }
        return FALSE;
}

void name_ext(char *filename, char *name, char *ext)
{
        int i;
        unsigned char *find;

        // Set the string to uppercase                                  //
        strtoupper(filename);

        // Get the file name                                            //
        for(i=0; i<8; i++)
        {
                if ( (filename[i]=='.') || (filename[i]=='\0') )
                        break;
                name[i] = filename[i];
        }
        for(; i<8; i++)
                name[i] = ' ';
        name[8] = '\0';

        // Get the file extension                                       //
        find = strstr(filename, ".");
        if (find++)
        {
                for(i=0; i<3; i++)
                {
                        if (find[i]=='\0')
                                break;
                        ext[i] = find[i];
                }
                for(; i<3; i++)
                        ext[i] = ' ';
        }
        else
        {
                for(i=0; i<3; i++)
                        ext[i] = ' ';
        }
        ext[3] = '\0';
}

bool compare_name_ext(unsigned char *name1, unsigned char *name2, char *ext1, char *ext2)
{
        bool different = TRUE;
        if ( (*name1 != 0) && (*name1 != 0xE5) )
        {
                if (*name1 == 0x05) *name1=0xE5;

                if ( (strncmp(name1, name2, 8) == 0) && (strncmp(ext1, ext2, 3) == 0) )
                        different = FALSE;

                if (*name1 == 0xE5) *name1=0x05;
        }
        return(!different);
}

// --- Read procedures -------------------------------------------------//
void read_file(sector_t *Buf, int start, int c)
{
        int i, j;
        word a;
        word dir_start = bootsector.Fats*bootsector.SectorsPerFat+1;
        word data_start = dir_start + bootsector.RootDirectoryEntries*32/bootsector.BytesPerSector-2;

        if(!start)
        {
                for(j=0; j<3; j++)
                        if (fdc_read(dir_start, (byte *)Buf, c)) break;
        }
        else
        {
                // Read the start sector //
                a=start;
                for(j=0; j<3; j++)
                        if (fdc_read(data_start+a, (byte *)Buf, 1)) break;

                // Read the other sectors //
                for(i=1; i<c; i++)
                {
                        if (next_sector(&a, a))
                        {
                                for(j=0; j<3; j++)
                                        if (fdc_read(data_start+a, (byte *)(Buf+i), 1)) break;
                        }
                        else
                                // End of file //
                                break;
                }
        }
}

bool load_file(char *stringa, byte *buffer)
{
        unsigned char Nome[9], Ext[4];
        SectorDir_t *Buf;
        int counter, count;
        int h, i;
        bool found=FALSE;

        // Get the file name and extension //
        name_ext(stringa, Nome, Ext);

        // Get the list of file into the current directory //
        counter = how_many_cluster(directory);

        Buf = kmalloc(FAT_SECTOR_SIZE*counter);
        memset(Buf, 0, FAT_SECTOR_SIZE*counter);

        // Read the directory //
        read_file((sector_t *)Buf, directory, counter);

        for(h=0; h<counter; h++)
        {
                for(i=0; i<FAT_SECTOR_SIZE/sizeof(FileEntry_t); i++)
                {
                        found = compare_name_ext(Buf[h].Entry[i].Name, Nome, Buf[h].Entry[i].Extension, Ext);
                        if (found)
                        {
                                // The file is empty //
                                if ( !(Buf[h].Entry[i].StartCluster) ) goto founded;

                                // Copy the file into the buffer //
                                count = how_many_cluster(Buf[h].Entry[i].StartCluster);
                                read_file((sector_t *)buffer, Buf[h].Entry[i].StartCluster, count);
                                goto founded;
                        }
                }
        }
founded:
        kfree(Buf);

        if (!found) return(FALSE);
        return(TRUE);
}

int get_file_size(char *file_name)
{
// Get the size of a file //
        unsigned char name[9], ext[4];
        SectorDir_t *Buf;
        int counter, count=0, h, i;
        bool found=FALSE;

        // Get the file name and extension //
        name_ext(file_name, name, ext);

        // Get the list of file into the current directory //
        counter = how_many_cluster(directory);
        Buf = kmalloc(FAT_SECTOR_SIZE*counter);
        memset(Buf, 0, FAT_SECTOR_SIZE*counter);
        // Read the directory //
        read_file((sector_t *)Buf, directory, counter);

        // Find the file //
        for(h=0; h<counter; h++)
        {
                for(i=0; i<FAT_SECTOR_SIZE/sizeof(FileEntry_t); i++)
                {
                        found = compare_name_ext(Buf[h].Entry[i].Name, name, Buf[h].Entry[i].Extension, ext);
                        if (found)
                        {
                                // The file is empty //
                                if ( !(Buf[h].Entry[i].StartCluster) ) goto founded;

                                // Get the size in clusters //
                                count = how_many_cluster(Buf[h].Entry[i].StartCluster);
                                goto founded;
                        }
                }
        }
founded:
        kfree(Buf);
        if (!found) return(-1);
        return(count*FAT_SECTOR_SIZE);
};

void ls()
{
        int counter=0;
        int h, i, scroll;
        SectorDir_t *Buf;

        counter = how_many_cluster(directory);
        Buf = kmalloc(FAT_SECTOR_SIZE*counter);
        memset(Buf, 0, FAT_SECTOR_SIZE*counter);

        read_file((sector_t *)Buf, directory, counter);

        kprintf("\nList of files into the directory:\n\r\n\r");
        for(h=0, scroll=0; h<counter; h++)
        {
                for(i=0; i<(bootsector.BytesPerSector/sizeof(FileEntry_t)); i++)
                {
                        if (scroll==20)
                        {
                                kprintf("\n\rPress a key to continue...\n\r");
                                scroll=0;
                                if (kgetchar() == CTRL_C)
                                {
                                        kprintf("\n\r");
                                        kfree(Buf);
                                        return;
                                }
                        }
                        if ( show_file_entry(&(Buf[h].Entry[i])) )
                                scroll++;
                }
        }
        kfree(Buf);
        kprintf("\n\r");
}

bool cat(char *stringa)
{
        unsigned char Nome[9], Ext[4];
        SectorDir_t *Buf, *Buf2;
        word sector;
        int counter;
        int h, i;
        bool a=FALSE;

        name_ext(stringa, Nome, Ext);

        counter = how_many_cluster(directory);
        Buf = kmalloc(FAT_SECTOR_SIZE*counter);
        memset(Buf, 0, FAT_SECTOR_SIZE*counter);
        read_file((sector_t *)Buf, directory, counter);

        for(h=0; h<counter; h++)
        {
                for(i=0; i<FAT_SECTOR_SIZE/sizeof(FileEntry_t); i++)
                {
                        a = compare_name_ext(Buf[h].Entry[i].Name, Nome, Buf[h].Entry[i].Extension, Ext);
                        if (a)
                        {
                                // The file is empty //
                                if ( !(Buf[h].Entry[i].StartCluster) ) goto founded;

                                // Print the file to the standard output //
                                sector = Buf[h].Entry[i].StartCluster;
                                Buf2 = kmalloc(sizeof(sector_t));
                                memset(Buf2, 0, sizeof(sector_t));
                                for (;;)
                                {
                                        read_file((sector_t *)Buf2, sector, 1);
                                        for (i=0; i<FAT_SECTOR_SIZE; i++)
                                        {
                                                kputchar( ((byte *)Buf2)[i] );
                                        }
                                        if (!(next_sector(&sector, sector))) break;
                                }
                                kfree(Buf2);
                                goto founded;
                        }
                }
        }
founded:
        kfree(Buf);
        if (!a) return(FALSE);
        return(TRUE);
}

void add_dir_path(char *new_path)
{
        strcat(path, new_path);
        strcat(path, "/");
}

void up_dir_path(void)
{
        int i, k;
        for(i=0; path[i]!='\0'; i++);
        for(k=(i-2); path[k]!='/'; k--);
        path[++k] = '\0';
}

char *pwd()
{
// Return the current path //
        return(path);
}

bool cd(char *new_path)
{
        int counter=0;
        int l, h, i;
        bool change=FALSE;
        word a=0;
        attrib_t FileAttr;
        char dir_name[8];
        SectorDir_t *Buf;

        // Goto the root //
        if (new_path[0]=='/')
                if (new_path[1]=='\0')
                {
                        path[0]='\0';
                        directory=0;
                        return(TRUE);
                }


        counter = how_many_cluster(directory);
        Buf = kmalloc(FAT_SECTOR_SIZE*counter);
        memset(Buf, 0, FAT_SECTOR_SIZE*counter);
        read_file((sector_t *)Buf, directory, counter);

        for(h=0; h<counter; h++)
        {
                for(i=0; i<FAT_SECTOR_SIZE/sizeof(FileEntry_t); i++)
                {
                        read_attrib(&FileAttr, Buf[h].Entry[i].Attribute);
                        if (FileAttr.Directory)
                        {
                                if ((Buf[h].Entry[i].Name[0]!=0)&&(Buf[h].Entry[i].Name[0]!=0xE5))
                                {
                                        if (Buf[h].Entry[i].Name[0]==5) Buf[h].Entry[i].Name[0]=0xE5;
                                        l=0;
                                        do
                                        {
                                                dir_name[l]=Buf[h].Entry[i].Name[l];
                                        } while(dir_name[l++]!=' ');

                                        dir_name[--l]='\0';

                                        if (strcmp(new_path, dir_name)==0)
                                        {
                                                a = Buf[h].Entry[i].StartCluster;
                                                change=TRUE;
                                                goto founded;
                                        }
                                        if (Buf[h].Entry[i].Name[0]==0xE5) Buf[h].Entry[i].Name[0]=0x05;
                                }
                        }
                }
        }
founded:
        kfree(Buf);
        if (change)
        {
                directory = a;
                if (!a)
                        path[0]='\0';
                else
                {
                        if(new_path[0] != '.') add_dir_path(new_path);
                        else
                        {
                                if (new_path[1] == '.') up_dir_path();
                        }
                }
                return TRUE;
        }
        else
                return FALSE;
}

// --- Write procedures ------------------------------------------------//
bool fat12_write()
{
// Write the logical FAT to the disk                                    //
        int i, j;

        // Converts the FAT from the logical structure into the         //
        // physical structure                                           //
        for(i=0, j=0; j<3072; j+=2)
        {
                fat.data[i++] = (byte)lfat.data[j];
                fat.data[i++] = (byte)((lfat.data[j]>>8)&(0x0F))|((lfat.data[j+1]<<4)&(0xF0));
                fat.data[i++] = (byte)(lfat.data[j+1]>>4);
        }

        // Copy the FAT to the disk                                     //
        for(j=0; j<bootsector.Fats; j++)
        {
                for(i=0; i<3; i++)
                        if ( fdc_write(1, (byte *)&fat, bootsector.SectorsPerFat) )
                                break;
                if (i == 3)
                        return(FALSE);
        }

        // Write successful!                                            //
        return(TRUE);
}

word find_sector(int n, word actual)
{
// Find the sector n from actual                                        //
        word c, temp;

        temp = actual;
        for(c=0; c<n; c++) next_sector(&temp, temp);
        return(temp);
}

void write_sector_dir(SectorDir_t *sector, int num)
{
        int i, j;
        word dir_start = bootsector.Fats*bootsector.SectorsPerFat+1;
        word data_start = dir_start + bootsector.RootDirectoryEntries*32/bootsector.BytesPerSector-2;

        if( !directory )
        {
                for(j=0; j<3; j++)
                        if ( fdc_write(dir_start+num, (byte *)sector, 1) )
                                break;
        }
        else
        {
                i = find_sector(num, directory);
                for(j=0; j<3; j++)
                        if ( fdc_write(data_start+i, (byte *)sector, 1) )
                                break;
        }
}

void delete_file(word cluster)
{
// Delete the file from the FAT structure                               //
        word next;

        while ( next_sector(&next, cluster) )
        {
                lfat.data[cluster] = 0;
                cluster = next;
        }
        lfat.data[cluster] = 0;
}

bool rm(char *filename)
{
// Remove a file from the disk                                          //
        unsigned char name[9], ext[4];
        SectorDir_t *Buf;
        int counter, h, i;
        bool a=FALSE;

        if ( (strcmp(filename, ".")==0) || (strcmp(filename, "..")==0) )
                return(FALSE);

        name_ext(filename, name, ext);

        counter = how_many_cluster(directory);
        Buf = kmalloc(FAT_SECTOR_SIZE*counter);
        memset(Buf, 0, FAT_SECTOR_SIZE*counter);
        read_file((sector_t *)Buf, directory, counter);

        for(h=0; h<counter; h++)
        {
                for(i=0; i<FAT_SECTOR_SIZE/sizeof(FileEntry_t); i++)
                {
                        a = compare_name_ext(Buf[h].Entry[i].Name, name, Buf[h].Entry[i].Extension, ext);
                        if (a)
                        {
                                // Delete the file //
                                Buf[h].Entry[i].Name[0] = 0xE5;
                                write_sector_dir(&Buf[h], h);
                                delete_file(Buf[h].Entry[i].StartCluster);
                                fat12_write();
                                goto founded;
                }
                }
        }
founded:
        kfree(Buf);
        if (!a) return(FALSE);
        return(TRUE);
}

// --- Init procedures -------------------------------------------------//
bool init_FAT()
{
// Initialize the file system //
        int i;

        for(i=0; i<3; i++)
                if (fdc_read(FAT_BOOT_SECTOR, (byte *)&bootsector, 1))
                        break;
        if (i != 3)
                return(TRUE);
        else
                return(FALSE);
}

bool check_FAT(void)
{
        if ( (bootsector.BytesPerSector!=FAT_SECTOR_SIZE) || (bootsector.SectorsPerCluster!=1) ||
        (bootsector.Fats!=2) || (bootsector.RootDirectoryEntries!=224) ||
        (bootsector.LogicalSectors!=2880) || (bootsector.MediumDescriptorByte!=0xF0) )
           {
                   kprintf("\n\rNot a valid FAT12 filesystem on the disk.\n\r");
                   return FALSE;
           }
        return TRUE;
}

bool Read_FAT()
{
// Read the FAT from the floppy (mount) //
        int i, j;

        if (!( init_FAT() ))
        {
                kprintf("\n\rFloppy I/O error. Unable to read the block!!!\n\r");
                return(FALSE);
        }

        // FAT initializazion OK! //
        for (i=0; i<3; i++)
                if (fdc_read(1, (byte *)&fat, bootsector.SectorsPerFat))
                        break;
        if (i == 3)
        {
                kprintf("\n\rFloppy I/O error. Unable to read the block!!!\n\r");
                return(FALSE);
        }

        // Converts the FAT into the logical structures (array of word) //
        for(i=0, j=0; i<4608; i+=3)
        {
                lfat.data[j++] = (fat.data[i] + (fat.data[i+1] << 8)) & 0x0FFF;
                lfat.data[j++] = (fat.data[i+1] + (fat.data[i+2] << 8)) >> 4;
        }

        // Check if the FAT is correct //
        if (!( check_FAT() ))
        {
                kprintf("\n\rNot a valid FAT12 filesystem!!!\n\r");
                return(FALSE);
        }

        // Initialize the path //
        path[0]='\0';

        #ifdef FAT_DEBUG
        kprintf("\n\rInitializing FileSystem...\n\r");
        kprintf("\n\r");
        kprintf("Jump:\t\t\t%02x %02x %02x\n\r", bootsector.Jump[0], bootsector.Jump[1], bootsector.Jump[2]);
        kprintf("OS Name:\t\t\t%s\n\r", bootsector.Name);
        kprintf("BytesPerSector:\t\t\t%u\n\r", bootsector.BytesPerSector);
        kprintf("SectorsPerCluster:\t\t\t%u\n\r", bootsector.SectorsPerCluster);
        kprintf("ReservedSectors:\t\t\t%u\n\r", bootsector.ReservedSectors);
        kprintf("Fats:\t\t\t%u\n\r", bootsector.Fats);
        kprintf("RootDirectoryEntries:\t\t\t%u\n\r", bootsector.RootDirectoryEntries);
        kprintf("LogicalSectors:\t\t\t%u\n\r", bootsector.LogicalSectors);
        kprintf("MediumDescriptorByte:\t\t\t%X\n\r", bootsector.MediumDescriptorByte);
        kprintf("SectorsPerFat:\t\t\t%u\n\r", bootsector.SectorsPerFat);
        kprintf("SectorsPerTrack:\t\t\t%u\n\r", bootsector.SectorsPerTrack);
        kprintf("Heads:\t\t\t%u\n\r", bootsector.Heads);
        kprintf("HiddenSectors:\t\t\t%u\n\r", bootsector.HiddenSectors);
        kprintf("\n\r");
        #endif

        return(TRUE);
}

---