Re: large file support

From: Joseph (crossgrid_at_gmail.com)
Date: 12/02/04 

Date: Thu, 02 Dec 2004 12:45:33 -0500

I'm sorry i not too familiar with newgroup etiquotte for programming.
I've attached the files its the total code. I get segmenet fault
anything that is begger than 8K. Again i'm sorry i just didnt want to
fill the whole post with codes.

Karl Heinz Buchegger wrote:
> Joseph wrote:
>
>>Oh my,
>>you sure rip my post apart.
>>
>
>
> Look man.
> Nobody here knows what you are working on.
> Nobody knows what your class FileHeader should do or
> how its internals are structured or what members it has.
> Nor do we see the rest of the code to guess what you
> don't tell us.
>
> With that background nobody really can help you.
> [Scroll down]
>
>
>>-code-
>>bool
>>FileHeader::Allocate(BitMap *freeMap, int fileSize)
>>{
>> int i;
>>
>> numBytes = fileSize;
>> numSectors = divRoundUp(fileSize, SectorSize);
>> if (freeMap->NumClear() < (numSectors+1))
>> return FALSE; // not enough space
>>
>> int directSectors = numSectors % NumDirect;
>>
>> for (i = 0; i < directSectors; i++)
>> dataSectors[i] = freeMap->Find();
>>
>> // this section of code supports file size bigger than 8KB but not
>> // bigger than 12KB need to support upto 128KB
>> if( (numSectors / NumDirect) > 0 ) {
>> indirectHdrSector = freeMap->Find();
>> FileHeader *hdr = new FileHeader; // here is the pointer i was
>> // speaking of that which is
>> // indirect sector meaning
>> // anything above 4KB is
>> //indirect sector
>> for( i = 0; i < (numSectors - directSectors); i++ )
>> hdr->dataSectors[i] = freeMap->Find();
>
>
> So, you get a segfault. dataSectors seems to be a fixed size array
> in that class. At least I can't see any allocation to a pointer
> in that code. The first thing I would check if I were you is if
> that array is overflowed.
>
>
>> hdr->WriteBack(indirectHdrSector);
>> delete hdr;
>> }
>> return TRUE;
>>}
>>
>
>

// modified
// filehdr.cc
// Routines for managing the disk file header (in UNIX, this
// would be called the i-node).
//
// The file header is used to locate where on disk the
// file's data is stored. We implement this as a fixed size
// table of pointers -- each entry in the table points to the
// disk sector containing that portion of the file data
// (in other words, there are no indirect or doubly indirect
// blocks). The table size is chosen so that the file header
// will be just big enough to fit in one disk sector,
//
// Unlike in a real system, we do not keep track of file permissions,
// ownership, last modification date, etc., in the file header.
//
// A file header can be initialized in two ways:
// for a new file, by modifying the in-memory data structure
// to point to the newly allocated data blocks
// for a file already on disk, by reading the file header from disk
//
// Copyright (c) 1992-1993 The Regents of the University of California.
// All rights reserved. See copyright.h for copyright notice and limitation
// of liability and disclaimer of warranty provisions.

#include "copyright.h"

#include "system.h"
#include "filehdr.h"

//----------------------------------------------------------------------
// FileHeader::Allocate
// Initialize a fresh file header for a newly created file.
// Allocate data blocks for the file out of the map of free disk blocks.
// Return FALSE if there are not enough free blocks to accomodate
// the new file.
//
// "freeMap" is the bit map of free disk sectors
// "fileSize" is the bit map of free disk sectors
//----------------------------------------------------------------------

bool
FileHeader::Allocate(BitMap *freeMap, int fileSize)
{
    int i;

    numBytes = fileSize;
    numSectors = divRoundUp(fileSize, SectorSize);
    if (freeMap->NumClear() < (numSectors+1))
        return FALSE; // not enough space
    
    int directSectors = numSectors % NumDirect;

    for (i = 0; i < directSectors; i++)
        dataSectors[i] = freeMap->Find();

    if( (numSectors / NumDirect) > 0 ) {
              indirectHdrSector = freeMap->Find();
        FileHeader *hdr = new FileHeader;
        for( i = 0; i < (numSectors - directSectors); i++ )
            hdr->dataSectors[i] = freeMap->Find();
        hdr->WriteBack(indirectHdrSector);
        delete hdr;
    }
    return TRUE;
}

//----------------------------------------------------------------------
// FileHeader::Deallocate
// De-allocate all the space allocated for data blocks for this file.
//
// "freeMap" is the bit map of free disk sectors
//----------------------------------------------------------------------

void
FileHeader::Deallocate(BitMap *freeMap)
{
    int i;

    int directSectors = numSectors % NumDirect;

    for (i = 0; i < directSectors; i++) {
        ASSERT(freeMap->Test((int) dataSectors[i])); // ought to be marked!
        freeMap->Clear((int) dataSectors[i]);
    }

    if( indirectHdrSector != 0 ) {
        FileHeader *hdr = new FileHeader;
        hdr->FetchFrom(indirectHdrSector);
        
        for( i = 0; i < (numSectors - directSectors); i++) {
            ASSERT(freeMap->Test((int) hdr->dataSectors[i]));
            freeMap->Clear((int) hdr->dataSectors[i]);
           }
        delete hdr;
    }
}

//----------------------------------------------------------------------
// FileHeader::FetchFrom
// Fetch contents of file header from disk.
//
// "sector" is the disk sector containing the file header
//----------------------------------------------------------------------

void
FileHeader::FetchFrom(int sector)
{
    DEBUG('z', "Reading the sector from FileHeader:%d:\n", sector);
    synchDisk->ReadSector(sector, (char *)this);
}

//----------------------------------------------------------------------
// FileHeader::WriteBack
// Write the modified contents of the file header back to disk.
//
// "sector" is the disk sector to contain the file header
//----------------------------------------------------------------------

void
FileHeader::WriteBack(int sector)
{
    synchDisk->WriteSector(sector, (char *)this);
}

//----------------------------------------------------------------------
// FileHeader::ByteToSector
// Return which disk sector is storing a particular byte within the file.
// This is essentially a translation from a virtual address (the
// offset in the file) to a physical address (the sector where the
// data at the offset is stored).
//
// "offset" is the location within the file of the byte in question
//----------------------------------------------------------------------

int
FileHeader::ByteToSector(int offset)
{
    int SectorNum = offset / SectorSize;

    if( SectorNum < NumDirect )
        return dataSectors[SectorNum];

    else {
          FileHeader *hdr = new FileHeader;
        hdr->FetchFrom(indirectHdrSector);
        int returnNum = hdr->dataSectors[ SectorNum - NumDirect ];
        delete hdr;
        return returnNum;

    }
    //return(dataSectors[offset / SectorSize]);
}

//----------------------------------------------------------------------
// FileHeader::FileLength
// Return the number of bytes in the file.
//----------------------------------------------------------------------

int
FileHeader::FileLength()
{
    return numBytes;
}

//----------------------------------------------------------------------
// FileHeader::Print
// Print the contents of the file header, and the contents of all
// the data blocks pointed to by the file header.
//----------------------------------------------------------------------

void
FileHeader::Print()
{
    int i, j, k;
    char *data = new char[SectorSize];

    printf("FileHeader contents. File size: %d. File blocks:\n", numBytes);
    for (i = 0; i < numSectors; i++)
        printf("%d ", dataSectors[i]);
    printf("\nFile contents:\n");
    for (i = k = 0; i < numSectors; i++) {
        synchDisk->ReadSector(dataSectors[i], data);
        for (j = 0; (j < SectorSize) && (k < numBytes); j++, k++) {
            if ('\040' <= data[j] && data[j] <= '\176') // isprint(data[j])
                printf("%c", data[j]);
            else
                printf("\\%x", (unsigned char)data[j]);
        }
        printf("\n");
    }
    delete [] data;
}

#ifdef CHANGED
void FileHeader::SetFileAttr(int TotBytes, int TotSectors) {
    numBytes = TotBytes;
    numSectors = TotSectors;
}
#endif

// modified
// filehdr.h
// Data structures for managing a disk file header.
//
// A file header describes where on disk to find the data in a file,
// along with other information about the file (for instance, its
// length, owner, etc.)
//
// Copyright (c) 1992-1993 The Regents of the University of California.
// All rights reserved. See copyright.h for copyright notice and limitation
// of liability and disclaimer of warranty provisions.

#include "copyright.h"

#ifndef FILEHDR_H
#define FILEHDR_H

#include "disk.h"
#include "bitmap.h"

#define NumDirect ((SectorSize - 3 * sizeof(int)) / sizeof(int))
#define MaxFileSize (NumDirect * SectorSize)

// The following class defines the Nachos "file header" (in UNIX terms,
// the "i-node"), describing where on disk to find all of the data in the file.
// The file header is organized as a simple table of pointers to
// data blocks.
//
// The file header data structure can be stored in memory or on disk.
// When it is on disk, it is stored in a single sector -- this means
// that we assume the size of this data structure to be the same
// as one disk sector. Without indirect addressing, this
// limits the maximum file length to just under 4K bytes.
//
// There is no constructor; rather the file header can be initialized
// by allocating blocks for the file (if it is a new file), or by
// reading it from disk.

class FileHeader {
  public:
    bool Allocate(BitMap *bitMap, int fileSize);// Initialize a file header,
                                                // including allocating space
                                                // on disk for the file data
    void Deallocate(BitMap *bitMap); // De-allocate this file's
                                                // data blocks

    void FetchFrom(int sectorNumber); // Initialize file header from disk
    void WriteBack(int sectorNumber); // Write modifications to file header
                                        // back to disk

    int ByteToSector(int offset); // Convert a byte offset into the file
                                        // to the disk sector containing
                                        // the byte

    int FileLength(); // Return the length of the file
                                        // in bytes

    void Print(); // Print the contents of the file.

#ifdef CHANGED
    void SetFileAttr(int TotBytes, int TotSectors);
#endif
    int dataSectors[NumDirect];
    int indirectHdrSector;

  private:
    int numBytes; // Number of bytes in the file
    int numSectors; // Number of data sectors in the file
  // int dataSectors[NumDirect]; // Disk sector numbers for each data
                                        // block in the file
};

#endif // FILEHDR_H

Relevant Pages