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 #define CACHE_FAT       0       //!< Caches the FAT in memory\r
  24 #define USE_LFN         1       //!< Enables the use of Long File Names\r
  25 #define SUPPORT_WRITE   0       //!< Enables write support\r
  26 \r
  27 #include <acess.h>\r
  28 #include <modules.h>\r
  29 #include <vfs.h>\r
  30 #include "fs_fat.h"\r
  31 \r
  32 #define FAT_FLAG_DIRTY  0x10000\r
  33 #define FAT_FLAG_DELETE 0x20000\r
  34 \r
  35 // === TYPES ===\r
  36 #if USE_LFN\r
  37 /**\r
  38  * \brief Long-Filename cache entry\r
  39  */\r
  40 typedef struct sFAT_LFNCacheEnt\r
  41 {\r
  42          int    ID;\r
  43         char    Data[256];\r
  44 }       tFAT_LFNCacheEnt;\r
  45 /**\r
  46  * \brief Long-Filename cache\r
  47  */\r
  48 typedef struct sFAT_LFNCache\r
  49 {\r
  50          int    NumEntries;\r
  51         tFAT_LFNCacheEnt        Entries[];\r
  52 }       tFAT_LFNCache;\r
  53 #endif\r
  54 \r
  55 // === PROTOTYPES ===\r
  56 // --- Driver Core\r
  57  int    FAT_Install(char **Arguments);\r
  58 tVFS_Node       *FAT_InitDevice(char *device, char **options);\r
  59 void    FAT_Unmount(tVFS_Node *Node);\r
  60 // --- Helpers\r
  61  int    FAT_int_GetAddress(tVFS_Node *Node, Uint64 Offset, Uint64 *Addr, Uint32 *Cluster);\r
  62 Uint32  FAT_int_GetFatValue(tFAT_VolInfo *Disk, Uint32 Cluster);\r
  63 #if SUPPORT_WRITE\r
  64 Uint32  FAT_int_AllocateCluster(tFAT_VolInfo *Disk, Uint32 Previous);\r
  65 Uint32  FAT_int_FreeCluster(tFAT_VolInfo *Disk, Uint32 Cluster);\r
  66 #endif\r
  67 void    FAT_int_ReadCluster(tFAT_VolInfo *Disk, Uint32 Cluster, int Length, void *Buffer);\r
  68 // --- File IO\r
  69 Uint64  FAT_Read(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer);\r
  70 #if SUPPORT_WRITE\r
  71 void    FAT_int_WriteCluster(tFAT_VolInfo *Disk, Uint32 Cluster, void *Buffer);\r
  72 Uint64  FAT_Write(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer);\r
  73 #endif\r
  74 // --- Directory IO\r
  75 char    *FAT_ReadDir(tVFS_Node *Node, int ID);\r
  76 tVFS_Node       *FAT_FindDir(tVFS_Node *Node, const char *Name);\r
  77 #if SUPPORT_WRITE\r
  78  int    FAT_Mknod(tVFS_Node *Node, const char *Name, Uint Flags);\r
  79  int    FAT_Relink(tVFS_Node *node, const char *OldName, const char *NewName);\r
  80 #endif\r
  81 void    FAT_CloseFile(tVFS_Node *node);\r
  82 \r
  83 // === Options ===\r
  84  int    giFAT_MaxCachedClusters = 1024*512/4;\r
  85 \r
  86 // === SEMI-GLOBALS ===\r
  87 MODULE_DEFINE(0, (0<<8)|50 /*v0.50*/, VFAT, FAT_Install, NULL, NULL);\r
  88 tFAT_VolInfo    gFAT_Disks[8];\r
  89  int    giFAT_PartCount = 0;\r
  90 tVFS_Driver     gFAT_FSInfo = {"fat", 0, FAT_InitDevice, FAT_Unmount, NULL};\r
  91 \r
  92 // === CODE ===\r
  93 /**\r
  94  * \fn int FAT_Install(char **Arguments)\r
  95  * \brief Install the FAT Driver\r
  96  */\r
  97 int FAT_Install(char **Arguments)\r
  98 {\r
  99         VFS_AddDriver( &gFAT_FSInfo );\r
 100         return MODULE_ERR_OK;\r
 101 }\r
 102 \r
 103 /**\r
 104  * \fn tVFS_Node *FAT_InitDevice(char *Device, char **Options)\r
 105  * \brief Reads the boot sector of a disk and prepares the structures for it\r
 106  */\r
 107 tVFS_Node *FAT_InitDevice(char *Device, char **Options)\r
 108 {\r
 109         fat_bootsect *bs;\r
 110          int    i;\r
 111         Uint32  FATSz, RootDirSectors, TotSec;\r
 112         tVFS_Node       *node = NULL;\r
 113         tFAT_VolInfo    *diskInfo = &gFAT_Disks[giFAT_PartCount];\r
 114         \r
 115         // Temporary Pointer\r
 116         bs = &diskInfo->bootsect;\r
 117         \r
 118         // Open device and read boot sector\r
 119         diskInfo->fileHandle = VFS_Open(Device, VFS_OPENFLAG_READ|VFS_OPENFLAG_WRITE);\r
 120         if(diskInfo->fileHandle == -1) {\r
 121                 Log_Notice("FAT", "Unable to open device '%s'", Device);\r
 122                 return NULL;\r
 123         }\r
 124         \r
 125         VFS_ReadAt(diskInfo->fileHandle, 0, 512, bs);\r
 126         \r
 127         if(bs->bps == 0 || bs->spc == 0) {\r
 128                 Log_Notice("FAT", "Error in FAT Boot Sector");\r
 129                 return NULL;\r
 130         }\r
 131         \r
 132         // FAT Type Determining\r
 133         // - From Microsoft FAT Specifcation\r
 134         RootDirSectors = ((bs->files_in_root*32) + (bs->bps - 1)) / bs->bps;\r
 135         \r
 136         if(bs->fatSz16 != 0)            FATSz = bs->fatSz16;\r
 137         else                                    FATSz = bs->spec.fat32.fatSz32;\r
 138         \r
 139         if(bs->totalSect16 != 0)                TotSec = bs->totalSect16;\r
 140         else                                            TotSec = bs->totalSect32;\r
 141         \r
 142         diskInfo->ClusterCount = (TotSec - (bs->resvSectCount + (bs->fatCount * FATSz) + RootDirSectors)) / bs->spc;\r
 143         \r
 144         if(diskInfo->ClusterCount < 4085)\r
 145                 diskInfo->type = FAT12;\r
 146         else if(diskInfo->ClusterCount < 65525)\r
 147                 diskInfo->type = FAT16;\r
 148         else\r
 149                 diskInfo->type = FAT32;\r
 150         \r
 151         #if VERBOSE\r
 152         {\r
 153                 char    *sFatType, *sSize;\r
 154                 Uint    iSize = diskInfo->ClusterCount * bs->spc * bs->bps / 1024;\r
 155                 \r
 156                 switch(diskInfo->type)\r
 157                 {\r
 158                 case FAT12:     sFatType = "FAT12";     break;\r
 159                 case FAT16:     sFatType = "FAT16";     break;\r
 160                 case FAT32:     sFatType = "FAT32";     break;\r
 161                 default:        sFatType = "UNKNOWN";   break;\r
 162                 }\r
 163                 if(iSize <= 2*1024) {\r
 164                         sSize = "KiB";\r
 165                 }\r
 166                 else if(iSize <= 2*1024*1024) {\r
 167                         sSize = "MiB";\r
 168                         iSize >>= 10;\r
 169                 }\r
 170                 else {\r
 171                         sSize = "GiB";\r
 172                         iSize >>= 20;\r
 173                 }\r
 174                 Log_Notice("FAT", "'%s' %s, %i %s", Device, sFatType, iSize, sSize);\r
 175         }\r
 176         #endif\r
 177         \r
 178         // Get Name\r
 179         if(diskInfo->type == FAT32) {\r
 180                 for(i=0;i<11;i++)\r
 181                         diskInfo->name[i] = (bs->spec.fat32.label[i] == ' ' ? '\0' : bs->spec.fat32.label[i]);\r
 182         }\r
 183         else {\r
 184                 for(i=0;i<11;i++)\r
 185                         diskInfo->name[i] = (bs->spec.fat16.label[i] == ' ' ? '\0' : bs->spec.fat16.label[i]);\r
 186         }\r
 187         diskInfo->name[11] = '\0';\r
 188         \r
 189         // Compute Root directory offset\r
 190         if(diskInfo->type == FAT32)\r
 191                 diskInfo->rootOffset = bs->spec.fat32.rootClust;\r
 192         else\r
 193                 diskInfo->rootOffset = (FATSz * bs->fatCount) / bs->spc;\r
 194         \r
 195         diskInfo->firstDataSect = bs->resvSectCount + (bs->fatCount * FATSz) + RootDirSectors;\r
 196         \r
 197         //Allow for Caching the FAT\r
 198         #if CACHE_FAT\r
 199         if( diskInfo->ClusterCount <= giFAT_MaxCachedClusters )\r
 200         {\r
 201                 Uint32  Ofs;\r
 202                 diskInfo->FATCache = (Uint32*)malloc(sizeof(Uint32)*diskInfo->ClusterCount);\r
 203                 if(diskInfo->FATCache == NULL) {\r
 204                         Log_Warning("FAT", "Heap Exhausted");\r
 205                         return NULL;\r
 206                 }\r
 207                 Ofs = bs->resvSectCount*512;\r
 208                 if(diskInfo->type == FAT12)\r
 209                 {\r
 210                         Uint32  val;\r
 211                          int    j;\r
 212                         char    buf[1536];\r
 213                         for(i = 0; i < diskInfo->ClusterCount/2; i++) {\r
 214                                 j = i & 511;    //%512\r
 215                                 if( j == 0 ) {\r
 216                                         VFS_ReadAt(diskInfo->fileHandle, Ofs, 3*512, buf);\r
 217                                         Ofs += 3*512;\r
 218                                 }\r
 219                                 val = *((int*)(buf+j*3));\r
 220                                 diskInfo->FATCache[i*2] = val & 0xFFF;\r
 221                                 diskInfo->FATCache[i*2+1] = (val>>12) & 0xFFF;\r
 222                         }\r
 223                 }\r
 224                 else if(diskInfo->type == FAT16)\r
 225                 {\r
 226                         Uint16  buf[256];\r
 227                         for(i=0;i<diskInfo->ClusterCount;i++) {\r
 228                                 if( (i & 255) == 0 ) {\r
 229                                         VFS_ReadAt(diskInfo->fileHandle, Ofs, 512, buf);\r
 230                                         Ofs += 512;\r
 231                                 }\r
 232                                 diskInfo->FATCache[i] = buf[i&255];\r
 233                         }\r
 234                 }\r
 235                 else if(diskInfo->type == FAT32)\r
 236                 {\r
 237                         Uint32  buf[128];\r
 238                         for(i=0;i<diskInfo->ClusterCount;i++) {\r
 239                                 if( (i & 127) == 0 ) {\r
 240                                         VFS_ReadAt(diskInfo->fileHandle, Ofs, 512, buf);\r
 241                                         Ofs += 512;\r
 242                                 }\r
 243                                 diskInfo->FATCache[i] = buf[i&127];\r
 244                         }\r
 245                 }\r
 246                 LOG("FAT Fully Cached");\r
 247         }\r
 248         #endif /*CACHE_FAT*/\r
 249         \r
 250         diskInfo->BytesPerCluster = bs->spc * bs->bps;\r
 251         \r
 252         // Initalise inode cache for filesystem\r
 253         diskInfo->inodeHandle = Inode_GetHandle();\r
 254         LOG("Inode Cache handle is %i", diskInfo->inodeHandle);\r
 255         \r
 256         // == VFS Interface\r
 257         node = &diskInfo->rootNode;\r
 258         //node->Size = bs->files_in_root;\r
 259         node->Size = -1;\r
 260         node->Inode = diskInfo->rootOffset;     // 0:31 - Cluster, 32:63 - Parent Directory Cluster\r
 261         node->ImplPtr = diskInfo;       // Disk info pointer\r
 262         node->ImplInt = 0;      // 0:15 - Directory Index, 16: Dirty Flag, 17: Deletion Flag\r
 263         \r
 264         node->ReferenceCount = 1;\r
 265         \r
 266         node->UID = 0;  node->GID = 0;\r
 267         node->NumACLs = 1;\r
 268         node->ACLs = &gVFS_ACL_EveryoneRWX;\r
 269         node->Flags = VFS_FFLAG_DIRECTORY;\r
 270         node->CTime = node->MTime = node->ATime = now();\r
 271         \r
 272         node->Read = node->Write = NULL;\r
 273         node->ReadDir = FAT_ReadDir;\r
 274         node->FindDir = FAT_FindDir;\r
 275         #if SUPPORT_WRITE\r
 276         node->Relink = FAT_Relink;\r
 277         node->MkNod = FAT_Mknod;\r
 278         #else\r
 279         node->Relink = NULL;\r
 280         node->MkNod = NULL;\r
 281         #endif\r
 282         //node->Close = FAT_Unmount;\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         Inode_ClearCache(disk->inodeHandle);\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;\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 = Node->Inode & 0xFFFFFFFF;     // Cluster ID\r
 329         LOG("cluster = %08x", cluster);\r
 330         \r
 331         // Do Cluster Skip\r
 332         // - Pre FAT32 had a reserved area for the root.\r
 333         if( disk->type == FAT32 || cluster != disk->rootOffset )\r
 334         {\r
 335                 skip = Offset / disk->BytesPerCluster;\r
 336                 LOG("skip = %i", skip);\r
 337                 // Skip previous clusters\r
 338                 for(; skip-- ; )\r
 339                 {\r
 340                         if(Cluster)     *Cluster = cluster;\r
 341                         cluster = FAT_int_GetFatValue(disk, cluster);\r
 342                         // Check for end of cluster chain\r
 343                         if(cluster == 0xFFFFFFFF) {     LEAVE('i', 1);  return 1;}\r
 344                 }\r
 345                 if(Cluster)     *Cluster = cluster;\r
 346         }\r
 347         else {\r
 348                 // Increment by clusters in offset\r
 349                 cluster += Offset / disk->BytesPerCluster;\r
 350         }\r
 351         \r
 352         LOG("cluster = %08x", cluster);\r
 353         \r
 354         // Bounds Checking (Used to spot corruption)\r
 355         if(cluster > disk->ClusterCount + 2)\r
 356         {\r
 357                 Log_Warning("FAT", "Cluster ID is over cluster count (0x%x>0x%x)",\r
 358                         cluster, disk->ClusterCount+2);\r
 359                 LEAVE('i', 1);\r
 360                 return 1;\r
 361         }\r
 362         \r
 363         // Compute Offsets\r
 364         // - Pre FAT32 cluster base (in sectors)\r
 365         if( cluster == disk->rootOffset && disk->type != FAT32 ) {\r
 366                 addr = disk->bootsect.resvSectCount * disk->bootsect.bps;\r
 367                 addr += cluster * disk->BytesPerCluster;\r
 368         }\r
 369         else {\r
 370                 addr = disk->firstDataSect * disk->bootsect.bps;\r
 371                 addr += (cluster - 2) * disk->BytesPerCluster;\r
 372         }\r
 373         // In-cluster offset\r
 374         addr += Offset % disk->BytesPerCluster;\r
 375         \r
 376         LOG("addr = 0x%08x", addr);\r
 377         *Addr = addr;\r
 378         LEAVE('i', 0);\r
 379         return 0;\r
 380 }\r
 381 \r
 382 /*\r
 383  * ====================\r
 384  *   FAT Manipulation\r
 385  * ====================\r
 386  */\r
 387 /**\r
 388  * \fn Uint32 FAT_int_GetFatValue(tFAT_VolInfo *Disk, Uint32 cluster)\r
 389  * \brief Fetches a value from the FAT\r
 390  */\r
 391 Uint32 FAT_int_GetFatValue(tFAT_VolInfo *Disk, Uint32 cluster)\r
 392 {\r
 393         Uint32  val = 0;\r
 394         Uint32  ofs;\r
 395         ENTER("pDisk xCluster", Disk, cluster);\r
 396         Mutex_Acquire( &Disk->lFAT );\r
 397         #if CACHE_FAT\r
 398         if( Disk->ClusterCount <= giFAT_MaxCachedClusters )\r
 399         {\r
 400                 val = Disk->FATCache[cluster];\r
 401                 if(Disk->type == FAT12 && val == EOC_FAT12)     val = -1;\r
 402                 if(Disk->type == FAT16 && val == EOC_FAT16)     val = -1;\r
 403                 if(Disk->type == FAT32 && val == EOC_FAT32)     val = -1;\r
 404         }\r
 405         else\r
 406         {\r
 407         #endif\r
 408                 ofs = Disk->bootsect.resvSectCount*512;\r
 409                 if(Disk->type == FAT12) {\r
 410                         VFS_ReadAt(Disk->fileHandle, ofs+(cluster/2)*3, 3, &val);\r
 411                         val = (cluster & 1 ? val>>12 : val & 0xFFF);\r
 412                         if(val == EOC_FAT12)    val = -1;\r
 413                 } else if(Disk->type == FAT16) {\r
 414                         VFS_ReadAt(Disk->fileHandle, ofs+cluster*2, 2, &val);\r
 415                         if(val == EOC_FAT16)    val = -1;\r
 416                 } else {\r
 417                         VFS_ReadAt(Disk->fileHandle, ofs+cluster*4, 4, &val);\r
 418                         if(val == EOC_FAT32)    val = -1;\r
 419                 }\r
 420         #if CACHE_FAT\r
 421         }\r
 422         #endif /*CACHE_FAT*/\r
 423         Mutex_Release( &Disk->lFAT );\r
 424         LEAVE('x', val);\r
 425         return val;\r
 426 }\r
 427 \r
 428 #if SUPPORT_WRITE\r
 429 /**\r
 430  * \brief Allocate a new cluster\r
 431  */\r
 432 Uint32 FAT_int_AllocateCluster(tFAT_VolInfo *Disk, Uint32 Previous)\r
 433 {\r
 434         Uint32  ret = Previous;\r
 435         #if CACHE_FAT\r
 436         if( Disk->ClusterCount <= giFAT_MaxCachedClusters )\r
 437         {\r
 438                 Uint32  eoc;\r
 439                 \r
 440                 LOCK(Disk->lFAT);\r
 441                 for(ret = Previous; ret < Disk->ClusterCount; ret++)\r
 442                 {\r
 443                         if(Disk->FATCache[ret] == 0)\r
 444                                 goto append;\r
 445                 }\r
 446                 for(ret = 0; ret < Previous; ret++)\r
 447                 {\r
 448                         if(Disk->FATCache[ret] == 0)\r
 449                                 goto append;\r
 450                 }\r
 451                 \r
 452                 RELEASE(Disk->lFAT);\r
 453                 return 0;\r
 454         \r
 455         append:\r
 456                 switch(Disk->type)\r
 457                 {\r
 458                 case FAT12:     eoc = EOC_FAT12;        break;\r
 459                 case FAT16:     eoc = EOC_FAT16;        break;\r
 460                 case FAT32:     eoc = EOC_FAT32;        break;\r
 461                 default:        return 0;\r
 462                 }\r
 463                 \r
 464                 Disk->FATCache[ret] = eoc;\r
 465                 Disk->FATCache[Previous] = ret;\r
 466                 \r
 467                 RELEASE(Disk->lFAT);\r
 468                 return ret;\r
 469         }\r
 470         else\r
 471         {\r
 472         #endif\r
 473                 Uint32  val;\r
 474                 Uint32  ofs = Disk->bootsect.resvSectCount*512;\r
 475                 Log_Warning("FAT", "TODO: Implement cluster allocation with non cached FAT");\r
 476                 return 0;\r
 477                 \r
 478                 switch(Disk->type)\r
 479                 {\r
 480                 case FAT12:\r
 481                         VFS_ReadAt(Disk->fileHandle, ofs+(Previous>>1)*3, 3, &val);\r
 482                         if( Previous & 1 ) {\r
 483                                 val &= 0xFFF000;\r
 484                                 val |= ret;\r
 485                         }\r
 486                         else {\r
 487                                 val &= 0xFFF;\r
 488                                 val |= ret<<12;\r
 489                         }\r
 490                         VFS_WriteAt(Disk->fileHandle, ofs+(Previous>>1)*3, 3, &val);\r
 491                         \r
 492                         VFS_ReadAt(Disk->fileHandle, ofs+(ret>>1)*3, 3, &val);\r
 493                         if( Cluster & 1 ) {\r
 494                                 val &= 0xFFF000;\r
 495                                 val |= eoc;\r
 496                         }\r
 497                         else {\r
 498                                 val &= 0x000FFF;\r
 499                                 val |= eoc<<12;\r
 500                         }\r
 501                         VFS_WriteAt(Disk->fileHandle, ofs+(ret>>1)*3, 3, &val);\r
 502                         break;\r
 503                 case FAT16:\r
 504                         VFS_ReadAt(Disk->fileHandle, ofs+Previous*2, 2, &ret);\r
 505                         VFS_WriteAt(Disk->fileHandle, ofs+ret*2, 2, &eoc);\r
 506                         break;\r
 507                 case FAT32:\r
 508                         VFS_ReadAt(Disk->fileHandle, ofs+Previous*4, 4, &ret);\r
 509                         VFS_WriteAt(Disk->fileHandle, ofs+ret*4, 4, &eoc);\r
 510                         break;\r
 511                 }\r
 512                 return ret;\r
 513         #if CACHE_FAT\r
 514         }\r
 515         #endif\r
 516 }\r
 517 \r
 518 /**\r
 519  * \brief Free's a cluster\r
 520  * \return The original contents of the cluster\r
 521  */\r
 522 Uint32 FAT_int_FreeCluster(tFAT_VolInfo *Disk, Uint32 Cluster)\r
 523 {\r
 524         Uint32  ret;\r
 525         #if CACHE_FAT\r
 526         if( Disk->ClusterCount <= giFAT_MaxCachedClusters )\r
 527         {\r
 528                 LOCK(Disk->lFAT);\r
 529                 \r
 530                 ret = Disk->FATCache[Cluster];\r
 531                 Disk->FATCache[Cluster] = 0;\r
 532                 \r
 533                 RELEASE(Disk->lFAT);\r
 534         }\r
 535         else\r
 536         {\r
 537         #endif\r
 538                 Uint32  val;\r
 539                 Uint32  ofs = Disk->bootsect.resvSectCount*512;\r
 540                 LOCK(Disk->lFAT);\r
 541                 switch(Disk->type)\r
 542                 {\r
 543                 case FAT12:\r
 544                         VFS_ReadAt(Disk->fileHandle, ofs+(Cluster>>1)*3, 3, &val);\r
 545                         if( Cluster & 1 ) {\r
 546                                 ret = val & 0xFFF0000;\r
 547                                 val &= 0xFFF;\r
 548                         }\r
 549                         else {\r
 550                                 ret = val & 0xFFF;\r
 551                                 val &= 0xFFF000;\r
 552                         }\r
 553                         VFS_WriteAt(Disk->fileHandle, ofs+(Previous>>1)*3, 3, &val);\r
 554                         break;\r
 555                 case FAT16:\r
 556                         VFS_ReadAt(Disk->fileHandle, ofs+Previous*2, 2, &ret);\r
 557                         val = 0;\r
 558                         VFS_WriteAt(Disk->fileHandle, ofs+Cluster*2, 2, &val);\r
 559                         break;\r
 560                 case FAT32:\r
 561                         VFS_ReadAt(Disk->fileHandle, ofs+Previous*4, 4, &ret);\r
 562                         val = 0;\r
 563                         VFS_WriteAt(Disk->fileHandle, ofs+Cluster*2, 2, &val);\r
 564                         break;\r
 565                 }\r
 566                 RELEASE(Disk->lFAT);\r
 567         #if CACHE_FAT\r
 568         }\r
 569         #endif\r
 570         if(Disk->type == FAT12 && ret == EOC_FAT12)     ret = -1;\r
 571         if(Disk->type == FAT16 && ret == EOC_FAT16)     ret = -1;\r
 572         if(Disk->type == FAT32 && ret == EOC_FAT32)     ret = -1;\r
 573         return ret;\r
 574 }\r
 575 #endif\r
 576 \r
 577 /*\r
 578  * ====================\r
 579  *      Cluster IO\r
 580  * ====================\r
 581  */\r
 582 /**\r
 583  * \brief Read a cluster\r
 584  * \param Disk  Disk (Volume) to read from\r
 585  * \param Length        Length to read\r
 586  * \param Buffer        Destination for read data\r
 587  */\r
 588 void FAT_int_ReadCluster(tFAT_VolInfo *Disk, Uint32 Cluster, int Length, void *Buffer)\r
 589 {\r
 590         ENTER("pDisk xCluster iLength pBuffer", Disk, Cluster, Length, Buffer);\r
 591         VFS_ReadAt(\r
 592                 Disk->fileHandle,\r
 593                 (Disk->firstDataSect + (Cluster-2)*Disk->bootsect.spc )\r
 594                         * Disk->bootsect.bps,\r
 595                 Length,\r
 596                 Buffer\r
 597                 );\r
 598         LEAVE('-');\r
 599 }\r
 600 \r
 601 /* ====================\r
 602  *       File IO\r
 603  * ====================\r
 604  */\r
 605 /**\r
 606  * \fn Uint64 FAT_Read(tVFS_Node *node, Uint64 offset, Uint64 length, void *buffer)\r
 607  * \brief Reads data from a specified file\r
 608  */\r
 609 Uint64 FAT_Read(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)\r
 610 {\r
 611          int    preSkip, count;\r
 612          int    i, cluster, pos;\r
 613          int    bpc;\r
 614         void    *tmpBuf;\r
 615         tFAT_VolInfo    *disk = Node->ImplPtr;\r
 616         \r
 617         ENTER("pNode Xoffset Xlength pbuffer", Node, Offset, Length, Buffer);\r
 618         \r
 619         // Sanity Check offset\r
 620         if(Offset > Node->Size) {\r
 621                 LOG("Reading past EOF (%i > %i)", Offset, Node->Size);\r
 622                 LEAVE('i', 0);\r
 623                 return 0;\r
 624         }\r
 625         \r
 626         // Calculate and Allocate Bytes Per Cluster\r
 627         bpc = disk->BytesPerCluster;\r
 628         tmpBuf = (void*) malloc(bpc);\r
 629         if( !tmpBuf )   return 0;\r
 630         \r
 631         // Cluster is stored in the low 32-bits of the Inode field\r
 632         cluster = Node->Inode & 0xFFFFFFFF;\r
 633         \r
 634         // Clamp Size\r
 635         if(Offset >= Node->Size || Offset + Length > Node->Size) {\r
 636                 LOG("Reading past EOF (%lli + %lli > %lli), clamped to %lli",\r
 637                         Offset, Length, Node->Size, Node->Size - Offset);\r
 638                 Length = Node->Size - Offset;\r
 639         }\r
 640         \r
 641         // Reading from within the first cluster only?\r
 642         if((int)Offset + (int)Length < bpc)\r
 643         {\r
 644                 LOG("First cluster only");\r
 645                 FAT_int_ReadCluster(disk, cluster, bpc, tmpBuf);\r
 646                 memcpy( Buffer, (void*)( tmpBuf + Offset%bpc ), Length );\r
 647                 free(tmpBuf);\r
 648                 #if DEBUG\r
 649                 //Debug_HexDump("FAT_Read", Buffer, Length);\r
 650                 #endif\r
 651                 LEAVE('i', 1);\r
 652                 return Length;\r
 653         }\r
 654         \r
 655         // Skip previous clusters\r
 656         preSkip = Offset / bpc;\r
 657         for(i = preSkip; i--; ) {\r
 658                 cluster = FAT_int_GetFatValue(disk, cluster);\r
 659                 if(cluster == -1) {\r
 660                         Log_Warning("FAT", "Offset is past end of cluster chain mark");\r
 661                         free(tmpBuf);\r
 662                         LEAVE('i', 0);\r
 663                         return 0;\r
 664                 }\r
 665         }\r
 666         \r
 667         // Get Count of Clusters to read\r
 668         count = ((Offset%bpc + Length) / bpc) + 1;\r
 669         \r
 670         // Get buffer Position after 1st cluster\r
 671         pos = bpc - Offset%bpc;\r
 672         \r
 673         // Read 1st Cluster (performs alignment for us)\r
 674         if( pos == bpc && (int)Length >= bpc ) {\r
 675                 FAT_int_ReadCluster(disk, cluster, bpc, Buffer);\r
 676         }\r
 677         else {\r
 678                 FAT_int_ReadCluster(disk, cluster, bpc, tmpBuf);\r
 679                 memcpy(\r
 680                         Buffer,\r
 681                         (void*)( tmpBuf + (bpc-pos) ),\r
 682                         (pos < (int)Length ? (Uint)pos : Length)\r
 683                         );\r
 684         }\r
 685         \r
 686         // Simple return\r
 687         if( count == 1 ) {\r
 688                 #if DEBUG\r
 689                 //Debug_HexDump("FAT_Read", Buffer, Length);\r
 690                 #endif\r
 691                 free(tmpBuf);\r
 692                 LEAVE('i', 1);\r
 693                 return Length;\r
 694         }\r
 695         \r
 696         #if DEBUG\r
 697         LOG("pos = %i", pos);\r
 698         LOG("Reading the rest of the clusters");\r
 699         #endif\r
 700         \r
 701         // Read the rest of the cluster data\r
 702         for( i = 1; i < count-1; i++ )\r
 703         {\r
 704                 // Get next cluster in the chain\r
 705                 cluster = FAT_int_GetFatValue(disk, cluster);\r
 706                 if(cluster == -1) {\r
 707                         Warning("FAT_Read - Read past End of Cluster Chain");\r
 708                         free(tmpBuf);\r
 709                         LEAVE('i', 0);\r
 710                         return 0;\r
 711                 }\r
 712                 // Read cluster\r
 713                 FAT_int_ReadCluster(disk, cluster, bpc, (void*)(Buffer+pos));\r
 714                 pos += bpc;\r
 715         }\r
 716         \r
 717         // Get next cluster in the chain\r
 718         cluster = FAT_int_GetFatValue(disk, cluster);\r
 719         if(cluster == -1) {\r
 720                 Warning("FAT_Read - Read past End of Cluster Chain");\r
 721                 free(tmpBuf);\r
 722                 LEAVE('i', 0);\r
 723                 return 0;\r
 724         }\r
 725         \r
 726         // Read final cluster\r
 727         if( (int)Length - pos == bpc )\r
 728         {\r
 729                 FAT_int_ReadCluster( disk, cluster, bpc, (void*)(Buffer+pos) );\r
 730         }\r
 731         else {\r
 732                 FAT_int_ReadCluster( disk, cluster, bpc, tmpBuf );\r
 733                 memcpy( (void*)(Buffer+pos), tmpBuf, Length-pos );\r
 734         }\r
 735         \r
 736         #if DEBUG\r
 737         LOG("Free tmpBuf(0x%x) and Return", tmpBuf);\r
 738         //Debug_HexDump("FAT_Read", Buffer, Length);\r
 739         #endif\r
 740         \r
 741         free(tmpBuf);\r
 742         LEAVE('X', Length);\r
 743         return Length;\r
 744 }\r
 745 \r
 746 #if SUPPORT_WRITE\r
 747 /**\r
 748  * \brief Write a cluster to disk\r
 749  */\r
 750 void FAT_int_WriteCluster(tFAT_VolInfo *Disk, Uint32 Cluster, void *Buffer)\r
 751 {\r
 752         ENTER("pDisk xCluster pBuffer", Disk, Cluster, Buffer);\r
 753         VFS_ReadAt(\r
 754                 Disk->fileHandle,\r
 755                 (Disk->firstDataSect + (Cluster-2)*Disk->bootsect.spc )\r
 756                         * Disk->bootsect.bps,\r
 757                 Disk->BytesPerCluster,\r
 758                 Buffer\r
 759                 );\r
 760         LEAVE('-');\r
 761 }\r
 762 \r
 763 /**\r
 764  * \brief Write to a file\r
 765  * \param Node  File Node\r
 766  * \param Offset        Offset within file\r
 767  * \param Length        Size of data to write\r
 768  * \param Buffer        Data source\r
 769  */\r
 770 Uint64 FAT_Write(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)\r
 771 {\r
 772         tFAT_VolInfo    *disk = Node->ImplPtr;\r
 773         void    *tmpBuf;\r
 774          int    remLength = Length;\r
 775         Uint32  cluster, tmpCluster;\r
 776          int    bNewCluster = 0;\r
 777         \r
 778         if(Offset > Node->Size) return 0;\r
 779         \r
 780         // Seek Clusters\r
 781         cluster = Node->Inode & 0xFFFFFFFF;\r
 782         while( Offset > disk->BytesPerCluster )\r
 783         {\r
 784                 cluster = FAT_int_GetFatValue( disk, cluster );\r
 785                 if(cluster == -1) {\r
 786                         Log_Warning("FAT", "EOC Unexpectedly Reached");\r
 787                         return 0;\r
 788                 }\r
 789                 Offset -= disk->BytesPerCluster;\r
 790         }\r
 791         if( Offset == disk->BytesPerCluster )\r
 792         {\r
 793                 Uint32  tmp = FAT_int_AllocateCluster(disk, cluster);\r
 794                 if(!tmp)        return 0;\r
 795                 cluster = tmp;\r
 796                 Offset -= disk->BytesPerCluster;\r
 797         }\r
 798         \r
 799         if( Offset + Length < disk->BytesPerCluster )\r
 800         {\r
 801                 tmpBuf = malloc( disk->BytesPerCluster );\r
 802                 \r
 803                 // Read-Modify-Write\r
 804                 FAT_int_ReadCluster( disk, cluster, disk->BytesPerCluster, tmpBuf );\r
 805                 memcpy( tmpBuf + Offset, Buffer, Length );\r
 806                 FAT_int_WriteCluster( disk, cluster, tmpBuf );\r
 807                 \r
 808                 free(tmpBuf);\r
 809                 return Length;\r
 810         }\r
 811         \r
 812         // Clean up changes within a cluster\r
 813         if( Offset )\r
 814         {\r
 815                 tmpBuf = malloc( disk->BytesPerCluster );\r
 816                 \r
 817                 // Read-Modify-Write\r
 818                 FAT_int_ReadCluster( disk, cluster, disk->BytesPerCluster, tmpBuf );\r
 819                 memcpy( tmpBuf + Offset, Buffer, disk->BytesPerCluster - Offset );\r
 820                 FAT_int_WriteCluster( disk, cluster, tmpBuf );\r
 821                 \r
 822                 free(tmpBuf);\r
 823                 \r
 824                 remLength -= disk->BytesPerCluster - Offset;\r
 825                 Buffer += disk->BytesPerCluster - Offset;\r
 826                 \r
 827                 // Get next cluster (allocating if needed)\r
 828                 tmpCluster = FAT_int_GetFatValue(disk, cluster);\r
 829                 if(tmpCluster == -1) {\r
 830                         tmpCluster = FAT_int_AllocateCluster(disk, cluster);\r
 831                         if( tmpCluster == 0 ) {\r
 832                                 return Length - remLength;\r
 833                         }\r
 834                 }\r
 835                 cluster = tmpCluster;\r
 836         }\r
 837         \r
 838         while( remLength > disk->BytesPerCluster )\r
 839         {\r
 840                 FAT_int_WriteCluster( disk, cluster, Buffer );\r
 841                 Buffer += disk->BytesPerCluster;\r
 842                 \r
 843                 // Get next cluster (allocating if needed)\r
 844                 tmpCluster = FAT_int_GetFatValue(disk, cluster);\r
 845                 if(tmpCluster == -1) {\r
 846                         bNewCluster = 1;\r
 847                         tmpCluster = FAT_int_AllocateCluster(disk, cluster);\r
 848                         if( tmpCluster == 0 ) {\r
 849                                 return Length - remLength;\r
 850                         }\r
 851                 }\r
 852                 cluster = tmpCluster;\r
 853         }\r
 854         \r
 855         // Finish off\r
 856         tmpBuf = malloc( disk->BytesPerCluster );\r
 857         if( bNewCluster )\r
 858                 memset(tmpBuf, 0, disk->BytesPerCluster);\r
 859         else\r
 860                 FAT_int_ReadCluster( disk, cluster, disk->BytesPerCluster, tmpBuf );\r
 861         memcpy( tmpBuf, Buffer, remLength );\r
 862         FAT_int_WriteCluster( disk, cluster, tmpBuf );\r
 863         free( tmpBuf );\r
 864         \r
 865         return Length;\r
 866 }\r
 867 #endif\r
 868 \r
 869 /* ====================\r
 870  *  File Names & Nodes\r
 871  * ====================\r
 872  */\r
 873 /**\r
 874  * \brief Converts a FAT directory entry name into a proper filename\r
 875  * \param dest  Destination array (must be at least 13 bytes in size)\r
 876  * \param src   8.3 filename (concatenated, e.g 'FILE1   TXT')\r
 877  */\r
 878 void FAT_int_ProperFilename(char *dest, const char *src)\r
 879 {\r
 880          int    inpos, outpos;\r
 881         \r
 882         // Name\r
 883         outpos = 0;\r
 884         for( inpos = 0; inpos < 8; inpos++ ) {\r
 885                 if(src[inpos] == ' ')   break;\r
 886                 dest[outpos++] = src[inpos];\r
 887         }\r
 888         inpos = 8;\r
 889         // Check for empty extensions\r
 890         if(src[8] != ' ')\r
 891         {\r
 892                 dest[outpos++] = '.';\r
 893                 for( ; inpos < 11; inpos++)     {\r
 894                         if(src[inpos] == ' ')   break;\r
 895                         dest[outpos++] = src[inpos];\r
 896                 }\r
 897         }\r
 898         dest[outpos++] = '\0';\r
 899         \r
 900         //LOG("dest='%s'", dest);\r
 901 }\r
 902 \r
 903 /**\r
 904  * \fn char *FAT_int_CreateName(fat_filetable *ft, char *LongFileName)\r
 905  * \brief Converts either a LFN or a 8.3 Name into a proper name\r
 906  * \param ft    Pointer to the file's entry in the parent directory\r
 907  * \param LongFileName  Long file name pointer\r
 908  * \return Filename as a heap string\r
 909  */\r
 910 char *FAT_int_CreateName(fat_filetable *ft, char *LongFileName)\r
 911 {\r
 912         char    *ret;\r
 913         ENTER("pft sLongFileName", ft, LongFileName);\r
 914         #if USE_LFN\r
 915         if(LongFileName && LongFileName[0] != '\0')\r
 916         {       \r
 917                 ret = strdup(LongFileName);\r
 918         }\r
 919         else\r
 920         {\r
 921         #endif\r
 922                 ret = (char*) malloc(13);\r
 923                 FAT_int_ProperFilename(ret, ft->name);\r
 924         #if USE_LFN\r
 925         }\r
 926         #endif\r
 927         LEAVE('s', ret);\r
 928         return ret;\r
 929 }\r
 930 \r
 931 /**\r
 932  * \brief Creates a tVFS_Node structure for a given file entry\r
 933  * \param Parent        Parent directory VFS node\r
 934  * \param Entry File table entry for the new node\r
 935  * \param Pos   Position in the parent of the new node\r
 936  */\r
 937 tVFS_Node *FAT_int_CreateNode(tVFS_Node *Parent, fat_filetable *Entry, int Pos)\r
 938 {\r
 939         tVFS_Node       node;\r
 940         tVFS_Node       *ret;\r
 941         tFAT_VolInfo    *disk = Parent->ImplPtr;\r
 942         \r
 943         ENTER("pParent pFT", Parent, Entry);\r
 944         LOG("disk = %p\n", disk);\r
 945         \r
 946         memset(&node, 0, sizeof(tVFS_Node));\r
 947         \r
 948         // Set Other Data\r
 949         // 0-31: Cluster, 32-63: Parent Cluster\r
 950         node.Inode = Entry->cluster | (Entry->clusterHi<<16) | (Parent->Inode << 32);\r
 951         LOG("node.Inode = %llx", node.Inode);\r
 952         // Position in parent directory\r
 953         node.ImplInt = Pos & 0xFFFF;\r
 954         // Disk Pointer\r
 955         node.ImplPtr = disk;\r
 956         node.Size = Entry->size;\r
 957         LOG("Entry->size = %i", Entry->size);\r
 958         // root:root\r
 959         node.UID = 0;   node.GID = 0;\r
 960         node.NumACLs = 1;\r
 961         \r
 962         node.Flags = 0;\r
 963         if(Entry->attrib & ATTR_DIRECTORY)      node.Flags |= VFS_FFLAG_DIRECTORY;\r
 964         if(Entry->attrib & ATTR_READONLY) {\r
 965                 node.Flags |= VFS_FFLAG_READONLY;\r
 966                 node.ACLs = &gVFS_ACL_EveryoneRX;       // R-XR-XR-X\r
 967         }\r
 968         else {\r
 969                 node.ACLs = &gVFS_ACL_EveryoneRWX;      // RWXRWXRWX\r
 970         }\r
 971         \r
 972         // Create timestamps\r
 973         node.ATime = timestamp(0,0,0,\r
 974                         ((Entry->adate&0x1F) - 1),      // Days\r
 975                         ((Entry->adate&0x1E0) - 1),     // Months\r
 976                         1980+((Entry->adate&0xFF00)>>8) // Years\r
 977                         );\r
 978         \r
 979         node.CTime = Entry->ctimems * 10;       // Miliseconds\r
 980         node.CTime += timestamp(\r
 981                         ((Entry->ctime&0x1F)<<1),       // Seconds\r
 982                         ((Entry->ctime&0x3F0)>>5),      // Minutes\r
 983                         ((Entry->ctime&0xF800)>>11),    // Hours\r
 984                         ((Entry->cdate&0x1F)-1),                // Days\r
 985                         ((Entry->cdate&0x1E0)-1),               // Months\r
 986                         1980+((Entry->cdate&0xFF00)>>8) // Years\r
 987                         );\r
 988                         \r
 989         node.MTime = timestamp(\r
 990                         ((Entry->mtime&0x1F)<<1),       // Seconds\r
 991                         ((Entry->mtime&0x3F0)>>5),      // Minutes\r
 992                         ((Entry->mtime&0xF800)>>11),    // Hours\r
 993                         ((Entry->mdate&0x1F)-1),                // Days\r
 994                         ((Entry->mdate&0x1E0)-1),               // Months\r
 995                         1980+((Entry->mdate&0xFF00)>>8) // Years\r
 996                         );\r
 997         \r
 998         // Set pointers\r
 999         if(node.Flags & VFS_FFLAG_DIRECTORY) {\r
1000                 //Log_Debug("FAT", "Directory %08x has size 0x%x", node.Inode, node.Size);\r
1001                 node.ReadDir = FAT_ReadDir;\r
1002                 node.FindDir = FAT_FindDir;\r
1003                 #if SUPPORT_WRITE\r
1004                 node.MkNod = FAT_Mknod;\r
1005                 node.Relink = FAT_Relink;\r
1006                 #endif\r
1007                 node.Size = -1;\r
1008         }\r
1009         else {\r
1010                 node.Read = FAT_Read;\r
1011                 #if SUPPORT_WRITE\r
1012                 node.Write = FAT_Write;\r
1013                 #endif\r
1014         }\r
1015         node.Close = FAT_CloseFile;\r
1016         \r
1017         ret = Inode_CacheNode(disk->inodeHandle, &node);\r
1018         LEAVE('p', ret);\r
1019         return ret;\r
1020 }\r
1021 \r
1022 /* \r
1023  * ====================\r
1024  *     Directory IO\r
1025  * ====================\r
1026  */\r
1027 \r
1028 /**\r
1029  * \brief Reads a sector from the disk\r
1030  * \param Node  Directory node to read\r
1031  * \param Sector        Sector number in the directory to read\r
1032  * \param Buffer        Destination buffer for the read data\r
1033  */\r
1034 int FAT_int_ReadDirSector(tVFS_Node *Node, int Sector, fat_filetable *Buffer)\r
1035 {\r
1036         Uint64  addr;\r
1037         tFAT_VolInfo    *disk = Node->ImplPtr;\r
1038         \r
1039         ENTER("pNode iSector pEntry", Node, Sector, Buffer);\r
1040         \r
1041         // Parse address\r
1042         if(FAT_int_GetAddress(Node, Sector * 512, &addr, NULL))\r
1043         {\r
1044                 LEAVE('i', 1);\r
1045                 return 1;\r
1046         }\r
1047         \r
1048         LOG("addr = 0x%llx", addr);\r
1049         // Read Sector\r
1050         if(VFS_ReadAt(disk->fileHandle, addr, 512, Buffer) != 512)\r
1051         {\r
1052                 LEAVE('i', 1);\r
1053                 return 1;\r
1054         }\r
1055         \r
1056         LEAVE('i', 0);\r
1057         return 0;\r
1058 }\r
1059 \r
1060 #if SUPPORT_WRITE\r
1061 /**\r
1062  * \brief Writes an entry to the disk\r
1063  * \todo Support expanding a directory\r
1064  * \param Node  Directory node\r
1065  * \param ID    ID of entry to update\r
1066  * \param Entry Entry data\r
1067  * \return Zero on success, non-zero on error\r
1068  */\r
1069 int FAT_int_WriteDirEntry(tVFS_Node *Node, int ID, fat_filetable *Entry)\r
1070 {\r
1071         Uint64  addr = 0;\r
1072          int    tmp;\r
1073         Uint32  cluster = 0;\r
1074         tFAT_VolInfo    *disk = Node->ImplPtr;\r
1075         \r
1076         ENTER("pNode iID pEntry", Node, ID, Entry);\r
1077         \r
1078         tmp = FAT_int_GetAddress(Node, ID * sizeof(fat_filetable), &addr, &cluster);\r
1079         if( tmp )\r
1080         {\r
1081                 //TODO: Allocate a cluster\r
1082                 cluster = FAT_int_AllocateCluster(Node->ImplPtr, cluster);\r
1083                 if(cluster == -1) {\r
1084                         Log_Warning("FAT", "Unable to allocate an other cluster for %p", Node);\r
1085                         LEAVE('i', 1);\r
1086                         return 1;\r
1087                 }\r
1088                 FAT_int_GetAddress(Node, ID * sizeof(fat_filetable), &addr, &cluster);\r
1089         }\r
1090         \r
1091 \r
1092         LOG("addr = 0x%llx", addr);\r
1093         \r
1094         // Read Sector\r
1095         VFS_WriteAt(disk->fileHandle, addr, sizeof(fat_filetable), Entry);      // Read Dir Data\r
1096         \r
1097         LEAVE('i', 0);\r
1098         return 0;\r
1099 }\r
1100 #endif\r
1101 \r
1102 #if USE_LFN\r
1103 // I should probably more tightly associate the LFN cache with the node\r
1104 // somehow, maybe by adding a field to tVFS_Node before locking it\r
1105 // Maybe .Cache or something like that (something that is free'd by the\r
1106 // Inode_UncacheNode function)\r
1107         \r
1108 /**\r
1109  * \fn char *FAT_int_GetLFN(tVFS_Node *node)\r
1110  * \brief Return pointer to LFN cache entry\r
1111  * \param Node  Directory node\r
1112  * \param ID    ID of the short name\r
1113  * \return Pointer to the LFN cache entry\r
1114  */\r
1115 char *FAT_int_GetLFN(tVFS_Node *Node, int ID)\r
1116 {\r
1117         tFAT_LFNCache   *cache;\r
1118          int    i, firstFree;\r
1119         \r
1120         // TODO: Thread Safety (Lock things)\r
1121         cache = Node->Data;\r
1122         \r
1123         // Create a cache if it isn't there\r
1124         if(!cache) {\r
1125                 cache = Node->Data = malloc( sizeof(tFAT_LFNCache) + sizeof(tFAT_LFNCacheEnt) );\r
1126                 cache->NumEntries = 1;\r
1127                 cache->Entries[0].ID = ID;\r
1128                 cache->Entries[0].Data[0] = '\0';\r
1129                 return cache->Entries[0].Data;\r
1130         }\r
1131         \r
1132         // Scan for a current entry\r
1133         firstFree = -1;\r
1134         for( i = 0; i < cache->NumEntries; i++ )\r
1135         {\r
1136                 if( cache->Entries[i].ID == ID )\r
1137                         return cache->Entries[i].Data;\r
1138                 if( cache->Entries[i].ID == -1 && firstFree == -1 )\r
1139                         firstFree = i;\r
1140         }\r
1141         \r
1142         if(firstFree == -1) {\r
1143                 // Use `i` for temp length\r
1144                 i = sizeof(tFAT_LFNCache) + (cache->NumEntries+1)*sizeof(tFAT_LFNCacheEnt);\r
1145                 Node->Data = realloc( Node->Data, i );\r
1146                 if( !Node->Data ) {\r
1147                         Log_Error("FAT", "malloc() fail, unable to allocate %i for LFN cache", i);\r
1148                         return NULL;\r
1149                 }\r
1150                 cache = Node->Data;\r
1151                 i = cache->NumEntries;\r
1152                 cache->NumEntries ++;\r
1153         }\r
1154         else {\r
1155                 i = firstFree;\r
1156         }\r
1157         \r
1158         // Create new entry\r
1159         cache->Entries[ i ].ID = ID;\r
1160         cache->Entries[ i ].Data[0] = '\0';\r
1161         \r
1162         //TODO: Unlock\r
1163         return cache->Entries[ i ].Data;\r
1164 }\r
1165 \r
1166 /**\r
1167  * \fn void FAT_int_DelLFN(tVFS_Node *node)\r
1168  * \brief Delete a LFN cache entry\r
1169  * \param Node  Directory node\r
1170  * \param ID    File Entry ID\r
1171  */\r
1172 void FAT_int_DelLFN(tVFS_Node *Node, int ID)\r
1173 {\r
1174         tFAT_LFNCache   *cache = Node->Data;\r
1175          int    i;\r
1176         \r
1177         // Fast return\r
1178         if(!cache)      return;\r
1179         \r
1180         // Scan for a current entry\r
1181         for( i = 0; i < cache->NumEntries; i++ )\r
1182         {\r
1183                 if( cache->Entries[i].ID == ID )\r
1184                         cache->Entries[i].ID = -1;\r
1185         }\r
1186         return ;\r
1187 }\r
1188 #endif\r
1189 \r
1190 /**\r
1191  * \fn char *FAT_ReadDir(tVFS_Node *Node, int ID)\r
1192  * \param Node  Node structure of directory\r
1193  * \param ID    Directory position\r
1194  * \return Filename as a heap string, NULL or VFS_SKIP\r
1195  */\r
1196 char *FAT_ReadDir(tVFS_Node *Node, int ID)\r
1197 {\r
1198         fat_filetable   fileinfo[16];   // sizeof(fat_filetable)=32, so 16 per sector\r
1199          int    a = 0;\r
1200         char    *ret;\r
1201         #if USE_LFN\r
1202         char    *lfn = NULL;\r
1203         #endif\r
1204         \r
1205         ENTER("pNode iID", Node, ID);\r
1206         \r
1207         if(FAT_int_ReadDirSector(Node, ID/16, fileinfo))\r
1208         {\r
1209                 LOG("End of chain, end of dir");\r
1210                 LEAVE('n');\r
1211                 return NULL;\r
1212         }\r
1213         \r
1214         // Offset in sector\r
1215         a = ID % 16;\r
1216 \r
1217         LOG("fileinfo[%i].name[0] = 0x%x", a, (Uint8)fileinfo[a].name[0]);\r
1218         \r
1219         // Check if this is the last entry\r
1220         if( fileinfo[a].name[0] == '\0' ) {\r
1221                 Node->Size = ID;\r
1222                 LOG("End of list");\r
1223                 LEAVE('n');\r
1224                 return NULL;    // break\r
1225         }\r
1226         \r
1227         // Check for empty entry\r
1228         if( (Uint8)fileinfo[a].name[0] == 0xE5 ) {\r
1229                 LOG("Empty Entry");\r
1230                 #if 0   // Stop on empty entry?\r
1231                 LEAVE('n');\r
1232                 return NULL;    // Stop\r
1233                 #else\r
1234                 LEAVE('p', VFS_SKIP);\r
1235                 return VFS_SKIP;        // Skip\r
1236                 #endif\r
1237         }\r
1238         \r
1239         #if USE_LFN\r
1240         // Get Long File Name Cache\r
1241         if(fileinfo[a].attrib == ATTR_LFN)\r
1242         {\r
1243                 fat_longfilename        *lfnInfo;\r
1244                  int    len;\r
1245                 \r
1246                 lfnInfo = (fat_longfilename *) &fileinfo[a];\r
1247                 \r
1248                 // Get cache for corresponding file\r
1249                 lfn = FAT_int_GetLFN( Node, ID + (lfnInfo->id & 0x3F) );\r
1250                 \r
1251                 // Bit 6 indicates the start of an entry\r
1252                 if(lfnInfo->id & 0x40)  memset(lfn, 0, 256);\r
1253                 \r
1254                 // Get the current length\r
1255                 len = strlen(lfn);\r
1256                 \r
1257                 // Sanity Check (FAT implementations should not allow >255 character names)\r
1258                 if(len + 13 > 255)      return VFS_SKIP;\r
1259                 // Rebase all bytes\r
1260                 for(a=len+1;a--;)       lfn[a+13] = lfn[a];\r
1261                 \r
1262                 // Append new bytes\r
1263                 lfn[ 0] = lfnInfo->name1[0];    lfn[ 1] = lfnInfo->name1[1];\r
1264                 lfn[ 2] = lfnInfo->name1[2];    lfn[ 3] = lfnInfo->name1[3];\r
1265                 lfn[ 4] = lfnInfo->name1[4];    \r
1266                 lfn[ 5] = lfnInfo->name2[0];    lfn[ 6] = lfnInfo->name2[1];\r
1267                 lfn[ 7] = lfnInfo->name2[2];    lfn[ 8] = lfnInfo->name2[3];\r
1268                 lfn[ 9] = lfnInfo->name2[4];    lfn[10] = lfnInfo->name2[5];\r
1269                 lfn[11] = lfnInfo->name3[0];    lfn[12] = lfnInfo->name3[1];\r
1270                 LOG("lfn = '%s'", lfn);\r
1271                 LEAVE('p', VFS_SKIP);\r
1272                 return VFS_SKIP;\r
1273         }\r
1274         #endif\r
1275         \r
1276         // Check if it is a volume entry\r
1277         if(fileinfo[a].attrib & 0x08) {\r
1278                 LEAVE('p', VFS_SKIP);\r
1279                 return VFS_SKIP;\r
1280         }\r
1281         // Ignore . and ..\r
1282         if(fileinfo[a].name[0] == '.') {\r
1283                 LEAVE('p', VFS_SKIP);\r
1284                 return VFS_SKIP;\r
1285         }       \r
1286         \r
1287         LOG("name='%c%c%c%c%c%c%c%c.%c%c%c'",\r
1288                 fileinfo[a].name[0], fileinfo[a].name[1], fileinfo[a].name[2], fileinfo[a].name[3],\r
1289                 fileinfo[a].name[4], fileinfo[a].name[5], fileinfo[a].name[6], fileinfo[a].name[7],\r
1290                 fileinfo[a].name[8], fileinfo[a].name[9], fileinfo[a].name[10] );\r
1291         \r
1292         #if USE_LFN\r
1293         lfn = FAT_int_GetLFN(Node, ID);\r
1294         ret = FAT_int_CreateName(&fileinfo[a], lfn);\r
1295         #else\r
1296         ret = FAT_int_CreateName(&fileinfo[a], NULL);\r
1297         #endif\r
1298         \r
1299         LEAVE('s', ret);\r
1300         return ret;\r
1301 }\r
1302 \r
1303 /**\r
1304  * \fn tVFS_Node *FAT_FindDir(tVFS_Node *node, char *name)\r
1305  * \brief Finds an entry in the current directory\r
1306  */\r
1307 tVFS_Node *FAT_FindDir(tVFS_Node *Node, const char *Name)\r
1308 {\r
1309         fat_filetable   fileinfo[16];\r
1310         char    tmpName[13];\r
1311         #if USE_LFN\r
1312         fat_longfilename        *lfnInfo;\r
1313         char    lfn[256];\r
1314          int    lfnPos=255, lfnId = -1;\r
1315         #endif\r
1316          int    i;\r
1317         tVFS_Node       *tmpNode;\r
1318         tFAT_VolInfo    *disk = Node->ImplPtr;\r
1319         Uint32  cluster;\r
1320         \r
1321         ENTER("pNode sname", Node, Name);\r
1322         \r
1323         // Fast Returns\r
1324         if(!Name || Name[0] == '\0') {\r
1325                 LEAVE('n');\r
1326                 return NULL;\r
1327         }\r
1328         \r
1329         for( i = 0; ; i++ )\r
1330         {\r
1331                 if((i & 0xF) == 0) {\r
1332                         if(FAT_int_ReadDirSector(Node, i/16, fileinfo))\r
1333                         {\r
1334                                 LEAVE('n');\r
1335                                 return NULL;\r
1336                         }\r
1337                 }\r
1338                 \r
1339                 //Check if the files are free\r
1340                 if(fileinfo[i&0xF].name[0] == '\0')     break;  // End of List marker\r
1341                 if(fileinfo[i&0xF].name[0] == '\xE5')   continue;       // Free entry\r
1342                 \r
1343                 \r
1344                 #if USE_LFN\r
1345                 // Long File Name Entry\r
1346                 if(fileinfo[i & 0xF].attrib == ATTR_LFN)\r
1347                 {\r
1348                         lfnInfo = (fat_longfilename *) &fileinfo[i&0xF];\r
1349                         if(lfnInfo->id & 0x40) {\r
1350                                 memset(lfn, 0, 256);\r
1351                                 lfnPos = 255;\r
1352                         }\r
1353                         lfn[lfnPos--] = lfnInfo->name3[1];      lfn[lfnPos--] = lfnInfo->name3[0];\r
1354                         lfn[lfnPos--] = lfnInfo->name2[5];      lfn[lfnPos--] = lfnInfo->name2[4];\r
1355                         lfn[lfnPos--] = lfnInfo->name2[3];      lfn[lfnPos--] = lfnInfo->name2[2];\r
1356                         lfn[lfnPos--] = lfnInfo->name2[1];      lfn[lfnPos--] = lfnInfo->name2[0];\r
1357                         lfn[lfnPos--] = lfnInfo->name1[4];      lfn[lfnPos--] = lfnInfo->name1[3];\r
1358                         lfn[lfnPos--] = lfnInfo->name1[2];      lfn[lfnPos--] = lfnInfo->name1[1];\r
1359                         lfn[lfnPos--] = lfnInfo->name1[0];\r
1360                         if((lfnInfo->id&0x3F) == 1)\r
1361                         {\r
1362                                 memcpy(lfn, lfn+lfnPos+1, 256-lfnPos);\r
1363                                 lfnId = i+1;\r
1364                         }\r
1365                 }\r
1366                 else\r
1367                 {\r
1368                         // Remove LFN if it does not apply\r
1369                         if(lfnId != i)  lfn[0] = '\0';\r
1370                 #else\r
1371                 if(fileinfo[i&0xF].attrib == ATTR_LFN)  continue;\r
1372                 #endif\r
1373                         // Get Real Filename\r
1374                         FAT_int_ProperFilename(tmpName, fileinfo[i&0xF].name);\r
1375                         LOG("tmpName = '%s'", tmpName);\r
1376                 \r
1377                         // Only the long name is case sensitive, 8.3 is not\r
1378                         #if USE_LFN\r
1379                         if(strucmp(tmpName, Name) == 0 || strcmp(lfn, Name) == 0)\r
1380                         #else\r
1381                         if(strucmp(tmpName, Name) == 0)\r
1382                         #endif\r
1383                         {\r
1384                                 cluster = fileinfo[i&0xF].cluster | (fileinfo[i&0xF].clusterHi << 16);\r
1385                                 tmpNode = Inode_GetCache(disk->inodeHandle, cluster);\r
1386                                 if(tmpNode == NULL)     // Node is not cached\r
1387                                 {\r
1388                                         tmpNode = FAT_int_CreateNode(Node, &fileinfo[i&0xF], i);\r
1389                                 }\r
1390                                 LEAVE('p', tmpNode);\r
1391                                 return tmpNode;\r
1392                         }\r
1393                 #if USE_LFN\r
1394                 }\r
1395                 #endif\r
1396         }\r
1397         \r
1398         LEAVE('n');\r
1399         return NULL;\r
1400 }\r
1401 \r
1402 #if SUPPORT_WRITE\r
1403 /**\r
1404  * \fn int FAT_Mknod(tVFS_Node *Node, char *Name, Uint Flags)\r
1405  * \brief Create a new node\r
1406  */\r
1407 int FAT_Mknod(tVFS_Node *Node, char *Name, Uint Flags)\r
1408 {\r
1409         return 0;\r
1410 }\r
1411 \r
1412 /**\r
1413  * \fn int FAT_Relink(tVFS_Node *Node, char *OldName, char *NewName)\r
1414  * \brief Rename / Delete a file\r
1415  */\r
1416 int FAT_Relink(tVFS_Node *Node, char *OldName, char *NewName)\r
1417 {\r
1418         tVFS_Node       *child;\r
1419         fat_filetable   ft = {0};\r
1420          int    ret;\r
1421         \r
1422         child = FAT_FindDir(Node, OldName);\r
1423         if(!child)      return ENOTFOUND;\r
1424         \r
1425         // Delete?\r
1426         if( NewName == NULL )\r
1427         {\r
1428                 child->ImplInt |= FAT_FLAG_DELETE;      // Mark for deletion on close\r
1429                 \r
1430                 // Delete from the directory\r
1431                 ft.name[0] = '\xE9';\r
1432                 FAT_int_WriteDirEntry(Node, child->ImplInt & 0xFFFF, &ft);\r
1433                 \r
1434                 // Return success\r
1435                 ret = EOK;\r
1436         }\r
1437         // Rename\r
1438         else\r
1439         {\r
1440                 Log_Warning("FAT", "Renaming no yet supported %p ('%s' => '%s')",\r
1441                         Node, OldName, NewName);\r
1442                 ret = ENOTIMPL;\r
1443         }\r
1444         \r
1445         // Close child\r
1446         child->Close( child );\r
1447         return ret;\r
1448 }\r
1449 #endif\r
1450 \r
1451 /**\r
1452  * \fn void FAT_CloseFile(tVFS_Node *Node)\r
1453  * \brief Close an open file\r
1454  */\r
1455 void FAT_CloseFile(tVFS_Node *Node)\r
1456 {\r
1457         tFAT_VolInfo    *disk = Node->ImplPtr;\r
1458         if(Node == NULL)        return ;\r
1459         \r
1460         #if SUPPORT_WRITE\r
1461         // Update the node if it's dirty (don't bother if it's marked for\r
1462         // deletion)\r
1463         if( (Node->ImplInt & FAT_FLAG_DIRTY) && !(Node->ImplInt & FAT_FLAG_DELETE) )\r
1464         {\r
1465                 tFAT_VolInfo    buf[16];\r
1466                 tFAT_VolInfo    *ft = &buf[ (Node->ImplInt & 0xFFFF) % 16 ];\r
1467                 \r
1468                 FAT_int_ReadDirSector(Node, (Node->ImplInt & 0xFFFF)/16, buf);\r
1469                 ft->size = Node->Size;\r
1470                 // TODO: update adate, mtime, mdate\r
1471                 FAT_int_WriteDirEntry(Node, Node->ImplInt & 0xFFFF, ft);\r
1472                 \r
1473                 Node->ImplInt &= ~FAT_FLAG_DIRTY;\r
1474         }\r
1475         #endif\r
1476         \r
1477         // TODO: Make this more thread safe somehow, probably by moving the\r
1478         // Inode_UncacheNode higher up and saving the cluster value somewhere\r
1479         if( Node->ReferenceCount == 1 )\r
1480         {               \r
1481                 #if SUPPORT_WRITE\r
1482                 // Delete File\r
1483                 if( Node->ImplInt & FAT_FLAG_DELETE ) {\r
1484                         // Since the node is marked, we only need to remove it's data\r
1485                         Uint32  cluster = Node->Inode & 0xFFFFFFFF;\r
1486                         while( cluster != -1 )\r
1487                                 cluster = FAT_int_FreeCluster(Node->ImplPtr, cluster);\r
1488                 }\r
1489                 #endif\r
1490         }\r
1491         \r
1492         Inode_UncacheNode(disk->inodeHandle, Node->Inode);\r
1493         return ;\r
1494 }\r