KernelLand/Modules/Filesystems/FAT/fat.c

   1 /*\r
   2  * Acess 2\r
   3  * FAT12/16/32 Driver Version (Incl LFN)\r
   4  * \r
   5  * NOTE: This driver will only support _reading_ long file names, not\r
   6  * writing. I don't even know why I'm adding write-support. FAT sucks.\r
   7  * \r
   8  * Known Bugs:\r
   9  * - LFN Is buggy in FAT_ReadDir\r
  10  * \r
  11  * Notes:\r
  12  * - There's hard-coded 512 byte sectors everywhere, that needs to be\r
  13  *   cleaned.\r
  14  * - Thread safety is out the window with the write and LFN code\r
  15  */\r
  16 /**\r
  17  * \todo Implement changing of the parent directory when a file is written to\r
  18  * \todo Implement file creation / deletion\r
  19  */\r
  20 #define DEBUG   0\r
  21 #define VERBOSE 1\r
  22 \r
  23 #include <acess.h>\r
  24 #include <modules.h>\r
  25 #include "common.h"\r
  26 \r
  27 // === PROTOTYPES ===\r
  28 // --- Driver Core\r
  29  int    FAT_Install(char **Arguments);\r
  30 tVFS_Node       *FAT_InitDevice(const char *device, const char **options);\r
  31 void    FAT_Unmount(tVFS_Node *Node);\r
  32 // --- Helpers\r
  33  int    FAT_int_GetAddress(tVFS_Node *Node, Uint64 Offset, Uint64 *Addr, Uint32 *Cluster);\r
  34 // --- File IO\r
  35 size_t  FAT_Read(tVFS_Node *Node, off_t Offset, size_t Length, void *Buffer);\r
  36 #if SUPPORT_WRITE\r
  37 size_t  FAT_Write(tVFS_Node *Node, off_t Offset, size_t Length, const void *Buffer);\r
  38 #endif\r
  39 void    FAT_CloseFile(tVFS_Node *node);\r
  40 \r
  41 \r
  42 // === Options ===\r
  43  int    giFAT_MaxCachedClusters = 1024*512/4;\r
  44 \r
  45 // === SEMI-GLOBALS ===\r
  46 MODULE_DEFINE(0, VER2(0,80) /*v0.80*/, VFAT, FAT_Install, NULL, NULL);\r
  47 tFAT_VolInfo    gFAT_Disks[8];\r
  48  int    giFAT_PartCount = 0;\r
  49 tVFS_Driver     gFAT_FSInfo = {"fat", 0, FAT_InitDevice, FAT_Unmount, FAT_GetNodeFromINode, NULL};\r
  50 tVFS_NodeType   gFAT_DirType = {\r
  51         .TypeName = "FAT-Dir",\r
  52         .ReadDir = FAT_ReadDir,\r
  53         .FindDir = FAT_FindDir,\r
  54         #if SUPPORT_WRITE\r
  55         .MkNod = FAT_Mknod,\r
  56         .Link = FAT_Link,\r
  57         .Unlink = FAT_Unlink,\r
  58         #endif\r
  59         .Close = FAT_CloseFile\r
  60         };\r
  61 tVFS_NodeType   gFAT_FileType = {\r
  62         .TypeName = "FAT-File",\r
  63         .Read = FAT_Read,\r
  64         #if SUPPORT_WRITE\r
  65         .Write = FAT_Write,\r
  66         #endif\r
  67         .Close = FAT_CloseFile\r
  68         };\r
  69 \r
  70 // === CODE ===\r
  71 /**\r
  72  * \fn int FAT_Install(char **Arguments)\r
  73  * \brief Install the FAT Driver\r
  74  */\r
  75 int FAT_Install(char **Arguments)\r
  76 {\r
  77         VFS_AddDriver( &gFAT_FSInfo );\r
  78         return MODULE_ERR_OK;\r
  79 }\r
  80 \r
  81 /**\r
  82  * \brief Reads the boot sector of a disk and prepares the structures for it\r
  83  */\r
  84 tVFS_Node *FAT_InitDevice(const char *Device, const char **Options)\r
  85 {\r
  86         fat_bootsect *bs;\r
  87          int    i;\r
  88         Uint32  FATSz, RootDirSectors, TotSec;\r
  89         tVFS_Node       *node = NULL;\r
  90         tFAT_VolInfo    *diskInfo = &gFAT_Disks[giFAT_PartCount];\r
  91 \r
  92         memset(diskInfo, 0, sizeof(*diskInfo));\r
  93         \r
  94         // Temporary Pointer\r
  95         bs = &diskInfo->bootsect;\r
  96         \r
  97         // Open device and read boot sector\r
  98         diskInfo->fileHandle = VFS_Open(Device, VFS_OPENFLAG_READ|VFS_OPENFLAG_WRITE);\r
  99         if(diskInfo->fileHandle == -1) {\r
 100                 Log_Notice("FAT", "Unable to open device '%s'", Device);\r
 101                 return NULL;\r
 102         }\r
 103         \r
 104         VFS_ReadAt(diskInfo->fileHandle, 0, 512, bs);\r
 105         \r
 106         if(bs->bps == 0 || bs->spc == 0) {\r
 107                 Log_Notice("FAT", "Error in FAT Boot Sector (zero BPS/SPC)");\r
 108                 VFS_Close(diskInfo->fileHandle);\r
 109                 return NULL;\r
 110         }\r
 111         \r
 112         // FAT Type Determining\r
 113         // - From Microsoft FAT Specifcation\r
 114         RootDirSectors = ((bs->files_in_root*32) + (bs->bps - 1)) / bs->bps;\r
 115         \r
 116         if(bs->fatSz16 != 0)\r
 117                 FATSz = bs->fatSz16;\r
 118         else\r
 119                 FATSz = bs->spec.fat32.fatSz32;\r
 120         \r
 121         if(bs->totalSect16 != 0)\r
 122                 TotSec = bs->totalSect16;\r
 123         else\r
 124                 TotSec = bs->totalSect32;\r
 125         \r
 126         diskInfo->ClusterCount = (TotSec - (bs->resvSectCount + (bs->fatCount * FATSz) + RootDirSectors)) / bs->spc;\r
 127         \r
 128         if(diskInfo->ClusterCount < FAT16_MIN_SECTORS)\r
 129                 diskInfo->type = FAT12;\r
 130         else if(diskInfo->ClusterCount < FAT32_MIN_CLUSTERS)\r
 131                 diskInfo->type = FAT16;\r
 132         else\r
 133                 diskInfo->type = FAT32;\r
 134         \r
 135         #if VERBOSE\r
 136         {\r
 137                 char    *sFatType, *sSize;\r
 138                 Uint    iSize = diskInfo->ClusterCount * bs->spc * bs->bps / 1024;\r
 139                 \r
 140                 switch(diskInfo->type)\r
 141                 {\r
 142                 case FAT12:     sFatType = "FAT12";     break;\r
 143                 case FAT16:     sFatType = "FAT16";     break;\r
 144                 case FAT32:     sFatType = "FAT32";     break;\r
 145                 default:        sFatType = "UNKNOWN";   break;\r
 146                 }\r
 147                 if(iSize <= 2*1024) {\r
 148                         sSize = "KiB";\r
 149                 }\r
 150                 else if(iSize <= 2*1024*1024) {\r
 151                         sSize = "MiB";\r
 152                         iSize >>= 10;\r
 153                 }\r
 154                 else {\r
 155                         sSize = "GiB";\r
 156                         iSize >>= 20;\r
 157                 }\r
 158                 Log_Notice("FAT", "'%s' %s, %i %s", Device, sFatType, iSize, sSize);\r
 159         }\r
 160         #endif\r
 161         \r
 162         // Get Name\r
 163         if(diskInfo->type == FAT32) {\r
 164                 for(i=0;i<11;i++)\r
 165                         diskInfo->name[i] = (bs->spec.fat32.label[i] == ' ' ? '\0' : bs->spec.fat32.label[i]);\r
 166         }\r
 167         else {\r
 168                 for(i=0;i<11;i++)\r
 169                         diskInfo->name[i] = (bs->spec.fat16.label[i] == ' ' ? '\0' : bs->spec.fat16.label[i]);\r
 170         }\r
 171         diskInfo->name[11] = '\0';\r
 172         \r
 173         // Compute Root directory offset\r
 174         if(diskInfo->type == FAT32)\r
 175                 diskInfo->rootOffset = bs->spec.fat32.rootClust;\r
 176         else\r
 177                 diskInfo->rootOffset = (FATSz * bs->fatCount) / bs->spc;\r
 178         \r
 179         diskInfo->firstDataSect = bs->resvSectCount + (bs->fatCount * FATSz) + RootDirSectors;\r
 180         \r
 181         //Allow for Caching the FAT\r
 182         #if CACHE_FAT\r
 183         if( diskInfo->ClusterCount <= giFAT_MaxCachedClusters )\r
 184         {\r
 185                 Uint32  Ofs;\r
 186                 diskInfo->FATCache = (Uint32*)malloc(sizeof(Uint32)*diskInfo->ClusterCount);\r
 187                 if(diskInfo->FATCache == NULL) {\r
 188                         Log_Warning("FAT", "Heap Exhausted");\r
 189                         VFS_Cose(diskInfo->fileHandle);\r
 190                         return NULL;\r
 191                 }\r
 192                 Ofs = bs->resvSectCount*512;\r
 193                 if(diskInfo->type == FAT12)\r
 194                 {\r
 195                         Uint32  val;\r
 196                          int    j;\r
 197                         char    buf[1536];\r
 198                         for(i = 0; i < diskInfo->ClusterCount/2; i++) {\r
 199                                 j = i & 511;    //%512\r
 200                                 if( j == 0 ) {\r
 201                                         VFS_ReadAt(diskInfo->fileHandle, Ofs, 3*512, buf);\r
 202                                         Ofs += 3*512;\r
 203                                 }\r
 204                                 val = *((int*)(buf+j*3));\r
 205                                 diskInfo->FATCache[i*2] = val & 0xFFF;\r
 206                                 diskInfo->FATCache[i*2+1] = (val>>12) & 0xFFF;\r
 207                         }\r
 208                 }\r
 209                 else if(diskInfo->type == FAT16)\r
 210                 {\r
 211                         Uint16  buf[256];\r
 212                         for(i=0;i<diskInfo->ClusterCount;i++) {\r
 213                                 if( (i & 255) == 0 ) {\r
 214                                         VFS_ReadAt(diskInfo->fileHandle, Ofs, 512, buf);\r
 215                                         Ofs += 512;\r
 216                                 }\r
 217                                 diskInfo->FATCache[i] = buf[i&255];\r
 218                         }\r
 219                 }\r
 220                 else if(diskInfo->type == FAT32)\r
 221                 {\r
 222                         Uint32  buf[128];\r
 223                         for(i=0;i<diskInfo->ClusterCount;i++) {\r
 224                                 if( (i & 127) == 0 ) {\r
 225                                         VFS_ReadAt(diskInfo->fileHandle, Ofs, 512, buf);\r
 226                                         Ofs += 512;\r
 227                                 }\r
 228                                 diskInfo->FATCache[i] = buf[i&127];\r
 229                         }\r
 230                 }\r
 231                 LOG("FAT Fully Cached");\r
 232         }\r
 233         #endif /*CACHE_FAT*/\r
 234         \r
 235         diskInfo->BytesPerCluster = bs->spc * bs->bps;\r
 236         \r
 237         // == VFS Interface\r
 238         node = &diskInfo->rootNode;\r
 239         //node->Size = bs->files_in_root;\r
 240         node->Size = -1;\r
 241         node->Inode = diskInfo->rootOffset;     // 0:31 - Cluster, 32:63 - Parent Directory Cluster\r
 242         node->ImplPtr = diskInfo;       // Disk info pointer\r
 243         node->ImplInt = 0;      // 0:15 - Directory Index, 16: Dirty Flag, 17: Deletion Flag\r
 244         \r
 245         node->ReferenceCount = 1;\r
 246         \r
 247         node->UID = 0;  node->GID = 0;\r
 248         node->NumACLs = 1;\r
 249         node->ACLs = &gVFS_ACL_EveryoneRWX;\r
 250         node->Flags = VFS_FFLAG_DIRECTORY;\r
 251         node->CTime = node->MTime = node->ATime = now();\r
 252 \r
 253         node->Type = &gFAT_DirType;     \r
 254         \r
 255         giFAT_PartCount ++;\r
 256         return node;\r
 257 }\r
 258 \r
 259 /**\r
 260  * \brief Closes a mount and marks it as free\r
 261  * \param Node  Mount Root\r
 262  * \r
 263  * \todo Remove FAT Cache\r
 264  * \todo Clear LFN Cache\r
 265  * \todo Check that all files are closed and flushed\r
 266  */\r
 267 void FAT_Unmount(tVFS_Node *Node)\r
 268 {\r
 269         tFAT_VolInfo    *disk = Node->ImplPtr;\r
 270         \r
 271         // Close Disk Handle\r
 272         VFS_Close( disk->fileHandle );\r
 273         // Clear Node Cache\r
 274         FAT_int_ClearNodeCache(disk);\r
 275         // Mark as unused\r
 276         disk->fileHandle = -2;\r
 277         return;\r
 278 }\r
 279 \r
 280 /**\r
 281  * \brief Converts an offset in a file into a disk address\r
 282  * \param Node  File (or directory) node\r
 283  * \param Offset        Offset in the file\r
 284  * \param Addr  Return Address\r
 285  * \param Cluster       Set to the current cluster (or the last one if \a Offset\r
 286  *                  is past EOC) - Not touched if the node is the root\r
 287  *                  directory.\r
 288  * \return Zero on success, non-zero on error\r
 289  */\r
 290 int FAT_int_GetAddress(tVFS_Node *Node, Uint64 Offset, Uint64 *Addr, Uint32 *Cluster)\r
 291 {\r
 292         Uint32  cluster, base_cluster;\r
 293         Uint64  addr;\r
 294          int    skip;\r
 295         tFAT_VolInfo    *disk = Node->ImplPtr;\r
 296         \r
 297         ENTER("pNode XOffset", Node, Offset);\r
 298         \r
 299         cluster = base_cluster = Node->Inode & 0xFFFFFFF;       // Cluster ID\r
 300 //      LOG("base cluster = 0x%07x", cluster);\r
 301         \r
 302         // Do Cluster Skip\r
 303         // - Pre FAT32 had a reserved area for the root.\r
 304         if( disk->type == FAT32 || cluster != disk->rootOffset )\r
 305         {\r
 306                 skip = Offset / disk->BytesPerCluster;\r
 307                 LOG("skip = %i", skip);\r
 308                 // Skip previous clusters\r
 309                 for(; skip-- ; )\r
 310                 {\r
 311                         if(Cluster)     *Cluster = cluster;\r
 312                         cluster = FAT_int_GetFatValue(disk, cluster);\r
 313                         // Check for end of cluster chain\r
 314                         if(cluster == 0xFFFFFFFF) {     LEAVE('i', 1);  return 1;}\r
 315                 }\r
 316                 if(Cluster)     *Cluster = cluster;\r
 317         }\r
 318         else {\r
 319                 // TODO: Bounds checking on root\r
 320 //              LOG("Root cluster count %i", disk->bootsect.files_in_root*32/disk->BytesPerCluster);\r
 321                 // Increment by clusters in offset\r
 322                 cluster += Offset / disk->BytesPerCluster;\r
 323         }\r
 324         \r
 325 //      LOG("cluster = 0x%07x", cluster);\r
 326         \r
 327         // Bounds Checking (Used to spot corruption)\r
 328         if(cluster > disk->ClusterCount + 2)\r
 329         {\r
 330                 Log_Warning("FAT", "Cluster ID is over cluster count (0x%x>0x%x)",\r
 331                         cluster, disk->ClusterCount+2);\r
 332                 LEAVE('i', 1);\r
 333                 return 1;\r
 334         }\r
 335         \r
 336         // Compute Offsets\r
 337         // - Pre FAT32 cluster base (in sectors)\r
 338         if( base_cluster == disk->rootOffset && disk->type != FAT32 ) {\r
 339                 addr = disk->bootsect.resvSectCount * disk->bootsect.bps;\r
 340                 addr += cluster * disk->BytesPerCluster;\r
 341         }\r
 342         else {\r
 343                 addr = disk->firstDataSect * disk->bootsect.bps;\r
 344                 addr += (cluster - 2) * disk->BytesPerCluster;\r
 345         }\r
 346         // In-cluster offset\r
 347         addr += Offset % disk->BytesPerCluster;\r
 348         \r
 349         LOG("addr = 0x%08x", addr);\r
 350         *Addr = addr;\r
 351         LEAVE('i', 0);\r
 352         return 0;\r
 353 }\r
 354 \r
 355 /* ====================\r
 356  *       File IO\r
 357  * ====================\r
 358  */\r
 359 /**\r
 360  * \brief Reads data from a specified file\r
 361  */\r
 362 size_t FAT_Read(tVFS_Node *Node, off_t Offset, size_t Length, void *Buffer)\r
 363 {\r
 364          int    preSkip, count;\r
 365         Uint64  final_bytes;\r
 366          int    i, cluster, pos;\r
 367         tFAT_VolInfo    *disk = Node->ImplPtr;\r
 368         char    tmpBuf[disk->BytesPerCluster];\r
 369          int    bpc = disk->BytesPerCluster;\r
 370         \r
 371         ENTER("pNode Xoffset xlength pbuffer", Node, Offset, Length, Buffer);\r
 372         \r
 373         // Sanity Check offset\r
 374         if(Offset > Node->Size) {\r
 375                 LOG("Seek past EOF (%i > %i)", Offset, Node->Size);\r
 376                 LEAVE('i', 0);\r
 377                 return 0;\r
 378         }\r
 379         \r
 380         // Cluster is stored in the low 32-bits of the Inode field\r
 381         cluster = Node->Inode & 0xFFFFFFFF;\r
 382         \r
 383         // Clamp Size\r
 384         if(Offset + Length > Node->Size) {\r
 385                 LOG("Reading past EOF (%lli + %lli > %lli), clamped to %lli",\r
 386                         Offset, Length, Node->Size, Node->Size - Offset);\r
 387                 Length = Node->Size - Offset;\r
 388         }\r
 389         \r
 390         // Skip previous clusters\r
 391         preSkip = Offset / bpc;\r
 392         Offset %= bpc;\r
 393         LOG("preSkip = %i, Offset = %i", preSkip, (int)Offset);\r
 394         for(i = preSkip; i--; )\r
 395         {\r
 396                 cluster = FAT_int_GetFatValue(disk, cluster);\r
 397                 if(cluster == -1) {\r
 398                         Log_Warning("FAT", "Offset is past end of cluster chain mark");\r
 399                         LEAVE('i', 0);\r
 400                         return 0;\r
 401                 }\r
 402         }\r
 403 \r
 404         // Reading from within one cluster\r
 405         if((int)Offset + (int)Length <= bpc)\r
 406         {\r
 407                 LOG("single cluster only");\r
 408                 FAT_int_ReadCluster(disk, cluster, bpc, tmpBuf);\r
 409                 memcpy( Buffer, (void*)( tmpBuf + Offset%bpc ), Length );\r
 410                 LEAVE('X', Length);\r
 411                 return Length;\r
 412         }\r
 413         \r
 414         // Align read to a cluster\r
 415         if( Offset > 0 )\r
 416         {\r
 417                 pos = bpc - Offset;\r
 418                 FAT_int_ReadCluster(disk, cluster, bpc, tmpBuf);\r
 419                 memcpy( Buffer, (void*)( tmpBuf + Offset ), pos );\r
 420                 LOG("pos = %i, Reading the rest of the clusters");\r
 421                 // Get next cluster in the chain\r
 422                 cluster = FAT_int_GetFatValue(disk, cluster);\r
 423                 if(cluster == -1) {\r
 424                         Log_Warning("FAT", "Read past End of Cluster Chain (Align)");\r
 425                         LEAVE('X', pos);\r
 426                         return pos;\r
 427                 }\r
 428         }\r
 429         else\r
 430                 pos = 0;\r
 431 \r
 432         // Get Count of Clusters to read\r
 433 //      count = DivMod64U(Length - pos, bpc, &final_bytes);\r
 434         count = (Length - pos) / bpc;\r
 435         final_bytes = (Length - pos) % bpc;\r
 436         LOG("Offset = %i, Length = %i, count = %i, final_bytes = %i", (int)Offset, (int)Length, count, final_bytes);\r
 437         \r
 438         // Read the rest of the cluster data\r
 439         for( ; count; count -- )\r
 440         {\r
 441                 if(cluster == -1) {\r
 442                         Log_Warning("FAT", "Read past End of Cluster Chain (Bulk)");\r
 443                         LEAVE('X', pos);\r
 444                         return pos;\r
 445                 }\r
 446                 // Read cluster\r
 447                 FAT_int_ReadCluster(disk, cluster, bpc, (void*)(Buffer+pos));\r
 448                 pos += bpc;\r
 449                 // Get next cluster in the chain\r
 450                 cluster = FAT_int_GetFatValue(disk, cluster);\r
 451         }\r
 452 \r
 453         if( final_bytes > 0 )\r
 454         {\r
 455                 if(cluster == -1) {\r
 456                         Log_Warning("FAT", "Read past End of Cluster Chain (Final)");\r
 457                         LEAVE('X', pos);\r
 458                         return pos;\r
 459                 }\r
 460                 // Read final cluster\r
 461                 FAT_int_ReadCluster( disk, cluster, bpc, tmpBuf );\r
 462                 memcpy( (void*)(Buffer+pos), tmpBuf, Length-pos );\r
 463         }\r
 464                 \r
 465         #if DEBUG\r
 466         //Debug_HexDump("FAT_Read", Buffer, Length);\r
 467         #endif\r
 468         \r
 469         LEAVE('X', Length);\r
 470         return Length;\r
 471 }\r
 472 \r
 473 #if SUPPORT_WRITE\r
 474 /**\r
 475  * \brief Write to a file\r
 476  * \param Node  File Node\r
 477  * \param Offset        Offset within file\r
 478  * \param Length        Size of data to write\r
 479  * \param Buffer        Data source\r
 480  */\r
 481 size_t FAT_Write(tVFS_Node *Node, off_t Offset, size_t Length, const void *Buffer)\r
 482 {\r
 483         tFAT_VolInfo    *disk = Node->ImplPtr;\r
 484         char    tmpBuf[disk->BytesPerCluster];\r
 485          int    remLength = Length;\r
 486         Uint32  cluster, tmpCluster;\r
 487          int    bNewCluster = 0;\r
 488         off_t   original_offset = Offset;\r
 489         \r
 490         if(Offset > Node->Size) return 0;\r
 491         \r
 492         ENTER("pNode Xoffset xlength pbuffer", Node, Offset, Length, Buffer);\r
 493         \r
 494         // Seek Clusters\r
 495         cluster = Node->Inode & 0xFFFFFFFF;\r
 496         while( Offset > disk->BytesPerCluster )\r
 497         {\r
 498                 cluster = FAT_int_GetFatValue( disk, cluster );\r
 499                 if(cluster == -1) {\r
 500                         Log_Warning("FAT", "EOC Unexpectedly Reached");\r
 501                         LEAVE('i', 0);\r
 502                         return 0;\r
 503                 }\r
 504                 Offset -= disk->BytesPerCluster;\r
 505         }\r
 506         if( Offset == disk->BytesPerCluster )\r
 507         {\r
 508                 Uint32  tmp = FAT_int_AllocateCluster(disk, cluster);\r
 509                 if(!tmp) {\r
 510                         LEAVE('i', 0);\r
 511                         return 0;\r
 512                 }\r
 513                 cluster = tmp;\r
 514                 Offset -= disk->BytesPerCluster;\r
 515         }\r
 516         \r
 517         if( Offset + Length < disk->BytesPerCluster )\r
 518         {\r
 519                 char    tmpBuf[disk->BytesPerCluster];\r
 520                 \r
 521                 LOG("Read-Modify-Write single");\r
 522                 \r
 523                 // Read-Modify-Write\r
 524                 FAT_int_ReadCluster( disk, cluster, disk->BytesPerCluster, tmpBuf );\r
 525                 memcpy( tmpBuf + Offset, Buffer, Length );\r
 526                 FAT_int_WriteCluster( disk, cluster, tmpBuf );\r
 527                 goto return_full;\r
 528         }\r
 529         \r
 530         // Clean up changes within a cluster\r
 531         if( Offset )\r
 532         {       \r
 533                 LOG("Read-Modify-Write first");\r
 534 \r
 535                 // Read-Modify-Write\r
 536                 FAT_int_ReadCluster( disk, cluster, disk->BytesPerCluster, tmpBuf );\r
 537                 memcpy( tmpBuf + Offset, Buffer, disk->BytesPerCluster - Offset );\r
 538                 FAT_int_WriteCluster( disk, cluster, tmpBuf );\r
 539                 \r
 540                 remLength -= disk->BytesPerCluster - Offset;\r
 541                 Buffer += disk->BytesPerCluster - Offset;\r
 542                 \r
 543                 // Get next cluster (allocating if needed)\r
 544                 tmpCluster = FAT_int_GetFatValue(disk, cluster);\r
 545                 if(tmpCluster == -1) {\r
 546                         tmpCluster = FAT_int_AllocateCluster(disk, cluster);\r
 547                         if( tmpCluster == 0 )\r
 548                                 goto ret_incomplete;\r
 549                 }\r
 550                 cluster = tmpCluster;\r
 551         }\r
 552         \r
 553         while( remLength > disk->BytesPerCluster )\r
 554         {\r
 555                 FAT_int_WriteCluster( disk, cluster, Buffer );\r
 556                 Buffer += disk->BytesPerCluster;\r
 557                 remLength -= disk->BytesPerCluster;\r
 558                 \r
 559                 // Get next cluster (allocating if needed)\r
 560                 tmpCluster = FAT_int_GetFatValue(disk, cluster);\r
 561                 if(tmpCluster == -1) {\r
 562                         bNewCluster = 1;\r
 563                         tmpCluster = FAT_int_AllocateCluster(disk, cluster);\r
 564                         if( tmpCluster == 0 )\r
 565                                 goto ret_incomplete;\r
 566                 }\r
 567                 cluster = tmpCluster;\r
 568         }\r
 569         \r
 570         // Finish off\r
 571         if( remLength )\r
 572         {\r
 573                 if( bNewCluster )\r
 574                         memset(tmpBuf, 0, disk->BytesPerCluster);\r
 575                 else\r
 576                         FAT_int_ReadCluster( disk, cluster, disk->BytesPerCluster, tmpBuf );\r
 577                 memcpy( tmpBuf, Buffer, remLength );\r
 578                 FAT_int_WriteCluster( disk, cluster, tmpBuf );\r
 579         }\r
 580 \r
 581 return_full:\r
 582         if( original_offset + Length > Node->Size ) {\r
 583                 Node->Size = original_offset + Length;\r
 584                 LOG("Updated size to %x", Node->Size);\r
 585                 Node->ImplInt |= FAT_FLAG_DIRTY;\r
 586         }\r
 587 \r
 588         LEAVE('i', Length);\r
 589         return Length;\r
 590 ret_incomplete:\r
 591         LOG("Write incomplete");\r
 592         Length -= remLength;\r
 593         if( original_offset + Length > Node->Size ) {\r
 594                 Node->Size = original_offset + Length;  \r
 595                 Node->ImplInt |= FAT_FLAG_DIRTY;\r
 596         }\r
 597         LEAVE('i', Length);\r
 598         return Length;\r
 599 }\r
 600 #endif\r
 601 \r
 602 /**\r
 603  * \fn void FAT_CloseFile(tVFS_Node *Node)\r
 604  * \brief Close an open file\r
 605  */\r
 606 void FAT_CloseFile(tVFS_Node *Node)\r
 607 {\r
 608         tFAT_VolInfo    *disk = Node->ImplPtr;\r
 609         if(Node == NULL)        return ;\r
 610 \r
 611         ENTER("pNode", Node);   \r
 612 \r
 613         #if SUPPORT_WRITE\r
 614         // Update the node if it's dirty (don't bother if it's marked for\r
 615         // deletion)\r
 616         if( (Node->ImplInt & FAT_FLAG_DIRTY) && !(Node->ImplInt & FAT_FLAG_DELETE) )\r
 617         {\r
 618                 fat_filetable   ft;\r
 619                 tVFS_Node       *dirnode;\r
 620 \r
 621                 dirnode = FAT_int_CreateIncompleteDirNode(disk, Node->Inode >> 32);\r
 622                 if( !dirnode ) {\r
 623                         Log_Error("FAT", "Can't get node for directory cluster #0x%x", Node->Inode>>32);\r
 624                         LEAVE('-');\r
 625                         return ;\r
 626                 }\r
 627 \r
 628                 int id = FAT_int_GetEntryByCluster(dirnode, Node->Inode & 0xFFFFFFFF, &ft);\r
 629                 ft.size = Node->Size;\r
 630                 // TODO: update adate, mtime, mdate\r
 631                 FAT_int_WriteDirEntry(dirnode, id, &ft);\r
 632                 \r
 633                 dirnode->Type->Close(dirnode);\r
 634                 \r
 635                 Node->ImplInt &= ~FAT_FLAG_DIRTY;\r
 636         }\r
 637         #endif\r
 638 \r
 639         Uint32  cluster = Node->Inode;\r
 640         Uint32  implint = Node->ImplInt;\r
 641         \r
 642         #if SUPPORT_WRITE\r
 643         if( FAT_int_DerefNode(Node) == 1 )\r
 644         {\r
 645                 LOG("implint = %x", implint);\r
 646                 // Delete File\r
 647                 if( implint & FAT_FLAG_DELETE ) {\r
 648                         Log_Debug("FAT", "Deallocating chain stating at 0x%07x", cluster);\r
 649                         // Since the node is marked, we only need to remove it's data\r
 650                         while( cluster != -1 )\r
 651                                 cluster = FAT_int_FreeCluster(disk, cluster);\r
 652                 }\r
 653         }\r
 654         #endif\r
 655         LEAVE('-');\r
 656 }\r