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