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