Public Member Functions | Public Attributes

FATDrive Struct Reference

FAT drive root entry. More...

#include <fatfs.h>

Inheritance diagram for FATDrive:
Inheritance graph
[legend]
Collaboration diagram for FATDrive:
Collaboration graph
[legend]

List of all members.

Public Member Functions

 FATDrive (LPCTSTR path)
 ~FATDrive ()
bool read_sector (DWORD sec, Buffer *buf, int len)
DWORD read_FAT (DWORD Clus, bool &ok)
void small_cache ()
void reset_cache ()
bool read_cache (DWORD sec, Buffer **bufptr)
int get_cache_buffer ()

Public Attributes

HANDLE _hDrive
BootSector _boot_sector
int _bufl
int _bufents
int _SClus
Cache_FATCache
int _CacheCount
DWORD * _CacheSec
int * _CacheCnt
bool * _CacheDty
int _Caches
bool _cache_empty
int _read_ahead

Detailed Description

FAT drive root entry.

Definition at line 225 of file fatfs.h.


Constructor & Destructor Documentation

FATDrive::FATDrive ( LPCTSTR  path )

Definition at line 410 of file fatfs.cpp.

References _boot_sector, _bufents, _bufl, _CacheCnt, _CacheCount, _CacheDty, _Caches, _CacheSec, _FATCache, _hDrive, _SClus, BootSector::BytesPerSector, read_sector(), and small_cache().

 :  FATDirectory(*this, TEXT("\\"))
{
    _bufl = 0;
    _bufents = 0;
    _SClus = 0;
    _FATCache = NULL;
    _CacheCount = 0;
    _CacheSec = NULL;
    _CacheCnt = NULL;
    _CacheDty = NULL;
    _Caches = 0;

    _hDrive = CreateFile(path, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0);

    if (_hDrive != INVALID_HANDLE_VALUE) {
        _boot_sector.BytesPerSector = 512;

        if (read_sector(0, (Buffer*)&_boot_sector, 1)) {
            _bufl = _boot_sector.BytesPerSector;
            _SClus = _boot_sector.SectorsPerCluster;
            _bufents = _bufl / sizeof(union DEntry);
        }

        small_cache();
    }
}

Here is the call graph for this function:

FATDrive::~FATDrive (  )

Definition at line 438 of file fatfs.cpp.

References _hDrive, and Directory::_path.

{
    if (_hDrive != INVALID_HANDLE_VALUE)
        CloseHandle(_hDrive);

    free(_path);
    _path = NULL;
}

Member Function Documentation

int FATDrive::get_cache_buffer (  )

Todo:
enable write back if (CacheDty[j]) // Dirty-Flag gesetzt? if (writesec(_CacheSec[j], (Buffer*) &_FATCache[j], 1)) FPara = _CacheSec[j], Frag(SecWriteErr);

Definition at line 603 of file fatfs.cpp.

References _cache_empty, _CacheCnt, _Caches, and _CacheSec.

Referenced by read_cache().

{
 int i, j, minCnt;

 for(i=0; i<_Caches; i++)
  if (_CacheSec[i])
   break;

 _cache_empty = i==_Caches? true: false;

 for(i=0; _CacheSec[i] && i<_Caches; )
  ++i;

 if (i < _Caches)
  j = i;
 else
  {
   minCnt = 0;          // search for least used buffer

   for(j=i=0; i<_Caches; i++)
    if (minCnt < _CacheCnt[i]) {
     minCnt = _CacheCnt[i];
     j = i;
    }

/**@todo enable write back
   if (CacheDty[j])     // Dirty-Flag gesetzt?
    if (writesec(_CacheSec[j], (Buffer*) &_FATCache[j], 1))
     FPara = _CacheSec[j], Frag(SecWriteErr);
*/
  }

 return j;
}

Here is the caller graph for this function:

bool FATDrive::read_cache ( DWORD  sec,
Buffer **  bufptr 
)

Definition at line 555 of file fatfs.cpp.

References _boot_sector, _cache_empty, _CacheCnt, _CacheCount, _CacheDty, _Caches, _CacheSec, _FATCache, _read_ahead, BufLen, BootSector::BytesPerSector, get_cache_buffer(), BootSector::NumberFATs, read_sector(), and BootSector::SectorsPerFAT.

Referenced by read_FAT().

{
 int i, C, anz;

 if (_boot_sector.BytesPerSector != BufLen)  // no standard sector size?
  return read_sector(sec, *bufptr=(Buffer*)&_FATCache[0], 1);

 _CacheCount++;

 for(i=0; _CacheSec[i]!=sec && i<_Caches; )
  ++i;

 if (i < _Caches)
  {
   *bufptr = (Buffer*) &_FATCache[i];    // FAT-Sektor schon gepuffert
   _CacheCnt[i]++;
   return true;
  }

 i = get_cache_buffer();

 if (_cache_empty)      // von get_cache_buffer() gesetzt
  {
   C = _CacheCount-1;
   anz = _boot_sector.SectorsPerFAT*_boot_sector.NumberFATs - sec;

   if (anz > _read_ahead)
    anz = _read_ahead;

   for(i=0; i<anz; i++) {
    _CacheSec[i] = sec++;
    _CacheCnt[i] = C;
    _CacheDty[i] = 0;
   }

   _CacheCnt[0] = _CacheCount;

   return read_sector(_CacheSec[0], *bufptr=(Buffer*) &_FATCache[0], anz);
  }
 else
  {
   _CacheDty[i] = 0;
   _CacheCnt[i] = _CacheCount;

   return read_sector(_CacheSec[i]=sec, *bufptr=(Buffer*) &_FATCache[i], 1);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

DWORD FATDrive::read_FAT ( DWORD  Clus,
bool &  ok 
)

Todo:
cache result

Definition at line 499 of file fatfs.cpp.

References _boot_sector, BootSector::BytesPerSector, Buffer::dat, dpeek, read_cache(), BootSector::ReservedSectors, BootSector::Sectors16, BootSector::Sectors32, BootSector::SectorsPerCluster, and wpeek.

Referenced by FATDirectory::read_dir().

{
    DWORD nClus;
    Buffer* FATBuf;

    DWORD nclus = (_boot_sector.Sectors32? _boot_sector.Sectors32: _boot_sector.Sectors16) / _boot_sector.SectorsPerCluster;    ///@todo cache result

    if (cluster > nclus) {
        ok = false;
        return (DWORD)-1;
    }

    if (nclus >= 65536) {       // FAT32
        DWORD FATsec = cluster / (_boot_sector.BytesPerSector/4);
        DWORD z = (cluster - _boot_sector.BytesPerSector/4 * FATsec)*4;
        FATsec += _boot_sector.ReservedSectors;
        if (!read_cache(FATsec, &FATBuf))
            ok = false;
        nClus = dpeek(&FATBuf->dat[z]);
    } else if (nclus >= 4096) { // 16 Bit-FAT
        DWORD FATsec = cluster / (_boot_sector.BytesPerSector/2);
        DWORD z = (cluster - _boot_sector.BytesPerSector/2 * FATsec)*2;
        FATsec += _boot_sector.ReservedSectors;
        if (!read_cache(FATsec, &FATBuf))
            ok = false;
        nClus = wpeek(&FATBuf->dat[z]);

        if (nClus >= 0xfff0)
            nClus |= 0x0fff0000;
    } else {                        // 12 Bit-FAT
        DWORD FATsec = cluster*3 / (_boot_sector.BytesPerSector*2);
        DWORD z = (cluster*3 - _boot_sector.BytesPerSector*2*FATsec)/2;
        FATsec += _boot_sector.ReservedSectors;
        if (!read_cache(FATsec,&FATBuf))
            ok = false;
        BYTE a = FATBuf->dat[z++];

        if (z >= _boot_sector.BytesPerSector)
            if (!read_cache(FATsec+1,&FATBuf))
                ok = false;
        z = 0;

        BYTE b = FATBuf->dat[z];

        if (cluster & 1)
            nClus = (a>>4) | (b<<4);
        else
            nClus = a | ((b & 0xf)<<8);

        if (nClus >= 0xff0)
            nClus |= 0x0ffff000;
    }

    return nClus;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool FATDrive::read_sector ( DWORD  sec,
Buffer buf,
int  len 
)

Definition at line 484 of file fatfs.cpp.

References _boot_sector, FATDirectory::_drive, _hDrive, and BootSector::BytesPerSector.

Referenced by FATDrive(), read_cache(), and FATDirectory::read_dir().

{
    sec += 63;  //@@ jump to first partition

    if (SetFilePointer(_hDrive, sec*_drive._boot_sector.BytesPerSector, 0, 0) == INVALID_SET_FILE_POINTER)
        return false;

    DWORD read;

    if (!ReadFile(_hDrive, buf, len*_drive._boot_sector.BytesPerSector, &read, 0))
        return false;

    return true;
}

Here is the caller graph for this function:

void FATDrive::reset_cache (  )

Definition at line 464 of file fatfs.cpp.

References _CacheCnt, _CacheDty, _Caches, _CacheSec, and _read_ahead.

Referenced by small_cache().

{
    int i;

    if (!_CacheSec) {
        _CacheSec = (DWORD*) malloc(_Caches * sizeof(DWORD));
        _CacheCnt = (int*) malloc(_Caches * sizeof(int));
        _CacheDty = (bool*) malloc(_Caches * sizeof(bool));
    } else {
        _CacheSec = (DWORD*) realloc(_CacheSec, _Caches * sizeof(DWORD));
        _CacheCnt = (int*) realloc(_CacheCnt, _Caches * sizeof(int));
        _CacheDty = (bool*) realloc(_CacheDty, _Caches * sizeof(bool));
    }

    for(i=0; i<_Caches; i++)
        _CacheSec[i] = 0;

    _read_ahead = (_Caches+1) / 2;
}

Here is the caller graph for this function:

void FATDrive::small_cache (  )

Definition at line 447 of file fatfs.cpp.

References _bufl, _CacheCnt, _CacheDty, _Caches, _CacheSec, FATDirectory::_drive, _FATCache, CACHE_SIZE_LOW, and reset_cache().

Referenced by FATDrive().

{
    if (_FATCache)
        free(_FATCache);

    if (_CacheSec) {
        free(_CacheSec), _CacheSec = NULL;
        free(_CacheCnt);
        free(_CacheDty);
    }

    _Caches = CACHE_SIZE_LOW;
    _FATCache = (struct Cache *) malloc((_Caches+1) * _drive._bufl);

    reset_cache();
}

Here is the call graph for this function:

Here is the caller graph for this function:


Member Data Documentation

Definition at line 238 of file fatfs.h.

Referenced by FATDrive(), read_cache(), FATDirectory::read_dir(), read_FAT(), and read_sector().

Definition at line 240 of file fatfs.h.

Referenced by FATDrive(), and FATDirectory::read_dir().

Definition at line 239 of file fatfs.h.

Referenced by FATDrive(), FATDirectory::read_dir(), and small_cache().

Definition at line 250 of file fatfs.h.

Referenced by get_cache_buffer(), and read_cache().

Definition at line 247 of file fatfs.h.

Referenced by FATDrive(), get_cache_buffer(), read_cache(), reset_cache(), and small_cache().

Definition at line 245 of file fatfs.h.

Referenced by FATDrive(), and read_cache().

Definition at line 248 of file fatfs.h.

Referenced by FATDrive(), read_cache(), reset_cache(), and small_cache().

Definition at line 249 of file fatfs.h.

Referenced by FATDrive(), get_cache_buffer(), read_cache(), reset_cache(), and small_cache().

Definition at line 246 of file fatfs.h.

Referenced by FATDrive(), get_cache_buffer(), read_cache(), reset_cache(), and small_cache().

Definition at line 244 of file fatfs.h.

Referenced by FATDrive(), read_cache(), and small_cache().

Definition at line 237 of file fatfs.h.

Referenced by FATDrive(), FileChildWindow::FileChildWindow(), read_sector(), and ~FATDrive().

Definition at line 251 of file fatfs.h.

Referenced by read_cache(), and reset_cache().

Definition at line 241 of file fatfs.h.

Referenced by FATDrive(), and FATDirectory::read_dir().


The documentation for this struct was generated from the following files:

ROS Explorer Source Code Documentation
generated on 02.01.2013 by doxygen

ROS Explorer Homepage