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