large file support

Discussion in 'C++' started by Joseph, Dec 2, 2004.

  1. Joseph

    Joseph Guest

    Hi,

    I'm having bit of questions on recursive pointer. I have following
    code that supports upto 8K files but when i do a file like 12K i get a
    segment fault. I Know it is in this line of code. How do i make the
    last pointer in the indirect sector that has another level of indirect
    pointer, and be defined recursively to support infinite large files?

    -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 = freeMap->Find();

    if( (numSectors / NumDirect) > 0 ) {
    indirectHdrSector = freeMap->Find();
    FileHeader *hdr = new FileHeader;
    for( i = 0; i < (numSectors - directSectors); i++ )
    hdr->dataSectors = freeMap->Find();
    hdr->WriteBack(indirectHdrSector);
    delete hdr;
    }
    return TRUE;
    }
    Joseph, Dec 2, 2004
    #1
    1. Advertising

  2. Joseph

    Howard Guest

    "Joseph" <> wrote in message
    news:congm9$68i$...
    > Hi,
    >
    > I'm having bit of questions on recursive pointer.


    What's a "recursive pointer"?

    >... I have following code that supports upto 8K files but when i do a file
    >like 12K i get a segment fault. I Know it is in this line of code.


    What line of code?

    >... How do i make the last pointer in the indirect sector that has another
    >level of indirect pointer, and be defined recursively to support infinite
    >large files?
    >


    ??? I don't understand that sentence at all. What's the "last pointer"?
    What's the "indirect sector"?

    You do know there's no such thing as an "infinite" (infinitely) large file,
    right? (A 12k file is actually quite small.)

    > -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 = freeMap->Find();
    >
    > if( (numSectors / NumDirect) > 0 ) {
    > indirectHdrSector = freeMap->Find();


    Where is indirectHdrSector defined?

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


    Comments in the code would help a great deal. It's very difficult to try to
    figure out what all this code is *supposed* to be doing.

    Also, where does it crash? Can you debug it to see what is causing the
    crash?

    -Howard
    Howard, Dec 2, 2004
    #2
    1. Advertising

  3. Joseph

    Joseph Guest

    Oh my,
    you sure rip my post apart.

    what i mean by "recursive pointer" i mean by a pointer that is defined
    recursively. The code that i have posted below is the template in
    defining couple of things. When i say infiately large file i mean
    theoetically. indirectHdrSector is defined in the header file as
    private int.

    -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 = 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 = freeMap->Find();
    hdr->WriteBack(indirectHdrSector);
    delete hdr;
    }
    return TRUE;
    }



    Howard wrote:
    > "Joseph" <> wrote in message
    > news:congm9$68i$...
    >
    >>Hi,
    >>
    >> I'm having bit of questions on recursive pointer.

    >
    >
    > What's a "recursive pointer"?
    >
    >
    >>... I have following code that supports upto 8K files but when i do a file
    >>like 12K i get a segment fault. I Know it is in this line of code.

    >
    >
    > What line of code?
    >
    >
    >>... How do i make the last pointer in the indirect sector that has another
    >>level of indirect pointer, and be defined recursively to support infinite
    >>large files?
    >>

    >
    >
    > ??? I don't understand that sentence at all. What's the "last pointer"?
    > What's the "indirect sector"?
    >
    > You do know there's no such thing as an "infinite" (infinitely) large file,
    > right? (A 12k file is actually quite small.)
    >
    >
    >>-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 = freeMap->Find();
    >>
    >> if( (numSectors / NumDirect) > 0 ) {
    >> indirectHdrSector = freeMap->Find();

    >
    >
    > Where is indirectHdrSector defined?
    >
    >
    >> FileHeader *hdr = new FileHeader;
    >> for( i = 0; i < (numSectors - directSectors); i++ )
    >> hdr->dataSectors = freeMap->Find();
    >> hdr->WriteBack(indirectHdrSector);
    >> delete hdr;
    >> }
    >> return TRUE;
    >>}

    >
    >
    > Comments in the code would help a great deal. It's very difficult to try to
    > figure out what all this code is *supposed* to be doing.
    >
    > Also, where does it crash? Can you debug it to see what is causing the
    > crash?
    >
    > -Howard
    >
    >
    >
    >
    Joseph, Dec 2, 2004
    #3
  4. 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 = 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 = 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;
    > }
    >


    --
    Karl Heinz Buchegger
    Karl Heinz Buchegger, Dec 2, 2004
    #4
  5. Joseph

    Joseph Guest

    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 = 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 = 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 = freeMap->Find();

    if( (numSectors / NumDirect) > 0 ) {
    indirectHdrSector = freeMap->Find();
    FileHeader *hdr = new FileHeader;
    for( i = 0; i < (numSectors - directSectors); i++ )
    hdr->dataSectors = 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)); // ought to be marked!
    freeMap->Clear((int) dataSectors);
    }

    if( indirectHdrSector != 0 ) {
    FileHeader *hdr = new FileHeader;
    hdr->FetchFrom(indirectHdrSector);

    for( i = 0; i < (numSectors - directSectors); i++) {
    ASSERT(freeMap->Test((int) hdr->dataSectors));
    freeMap->Clear((int) hdr->dataSectors);
    }
    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);
    printf("\nFile contents:\n");
    for (i = k = 0; i < numSectors; i++) {
    synchDisk->ReadSector(dataSectors, 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
    Joseph, Dec 2, 2004
    #5
  6. Joseph

    Joseph Guest

    Modify the file system to allow the maximum size of a file to be as
    large as the disk (128Kbytes). In the basic file system, each file is
    limited to a file size of just under 4Kbytes. Each file has a header
    (class FileHeader) that is a table of direct pointers to the disk blocks
    for that file. Since the header is stored in one disk sector, the
    maximum size of a file is limited by the number of pointers that will
    fit in one disk sector. Increasing the limit to 128KBytes will probably
    but not necessarily require you to implement double indirect, or
    linked-list blocks.

    Joseph wrote:
    > 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 = 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 = 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 = freeMap->Find();
    >
    > if( (numSectors / NumDirect) > 0 ) {
    > indirectHdrSector = freeMap->Find();
    > FileHeader *hdr = new FileHeader;
    > for( i = 0; i < (numSectors - directSectors); i++ )
    > hdr->dataSectors = 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)); // ought to be marked!
    > freeMap->Clear((int) dataSectors);
    > }
    >
    > if( indirectHdrSector != 0 ) {
    > FileHeader *hdr = new FileHeader;
    > hdr->FetchFrom(indirectHdrSector);
    >
    > for( i = 0; i < (numSectors - directSectors); i++) {
    > ASSERT(freeMap->Test((int) hdr->dataSectors));
    > freeMap->Clear((int) hdr->dataSectors);
    > }
    > 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);
    > printf("\nFile contents:\n");
    > for (i = k = 0; i < numSectors; i++) {
    > synchDisk->ReadSector(dataSectors, 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
    Joseph, Dec 2, 2004
    #6
  7. Joseph wrote:
    > I'm sorry i not too familiar with newgroup etiquotte for programming.


    I just saw another "Welcome to comp.lang.c++" message posted. Read it.
    In addition, read http://www.parashift.com/c -faq-lite/how-to-post.html

    After that you should consider starting another thread by posting the way
    folks here expect you to. Just a thought...

    > [..]


    V
    Victor Bazarov, Dec 2, 2004
    #7
  8. Joseph wrote:
    >
    > I'm sorry i not too familiar with newgroup etiquotte for programming.


    OK. Now you know.
    In an ideal case you shorten the posted code such that:
    * it shows the problem you are having
    * enables us to cut&paste your code into our devlopment environment
    * compile your code
    * run it

    > I've attached the files its the total code. I get segmenet fault
    > anything that is begger than 8K.


    This is by design, as far as I can see.

    The thing works as follows:

    One FileHeader object contains an array of sector numbers
    (where the actual data is stored). That array is fixed size
    to 'NumDirect' entries.

    The code in Allocate() calculates the needed amount of sectors
    end then checks with
    if( (numSectors / NumDirect) > 0 ) {
    if an additional FileHeader sector is needed.
    This check gave me some headaches until I figured it out. Rewriting
    it (and thus making it clearer) the above is simply:

    if( numSectors > NumDirect ) {
    // allocate the indirectHdrSector and allocate sectors
    // for it
    }

    That's fine. But there is a pitfall: Assume that
    NumDirect equals 3 and numSectors equals 8. How many
    indirect FileHeaders will you need? Well you need 2 of them,
    not only 1! Your code correctly allocates the first 3 sectors
    in the FileHeader, but then tries to squeeze the remaing 5
    sectors in the indirectHdrSector, which will not work, since
    there is only room for 3 of them. In the end the loop

    for( i = 0; i < (numSectors - directSectors); i++ )
    hdr->dataSectors = freeMap->Find();

    will overflow the array. Didn't you do the test I told you
    I would do? It is as easy as:

    for( i = 0; i < (numSectors - directSectors); i++ ) {
    if( i >= NumDirect ) {
    printf( "Something is terribly wrong in Allocate()\n" );
    }
    hdr->dataSectors = freeMap->Find();
    }

    And the program would have told you why it crashed!


    --
    Karl Heinz Buchegger
    Karl Heinz Buchegger, Dec 3, 2004
    #8
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Chris Bentz

    Large File Support

    Chris Bentz, Sep 13, 2003, in forum: Java
    Replies:
    6
    Views:
    588
    Brad BARCLAY
    Sep 14, 2003
  2. Mathew
    Replies:
    0
    Views:
    261
    Mathew
    Nov 25, 2003
  3. Tim Peters
    Replies:
    2
    Views:
    302
    Mathew
    Nov 25, 2003
  4. Robin Friedrich

    Build with large file support on AIX

    Robin Friedrich, Jan 21, 2004, in forum: Python
    Replies:
    0
    Views:
    306
    Robin Friedrich
    Jan 21, 2004
  5. Replies:
    5
    Views:
    841
    Xho Jingleheimerschmidt
    Apr 2, 2009
Loading...

Share This Page