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 Uint64  FAT_Read(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer);\r
  71 #if SUPPORT_WRITE\r
  72 void    FAT_int_WriteCluster(tFAT_VolInfo *Disk, Uint32 Cluster, void *Buffer);\r
  73 Uint64  FAT_Write(tVFS_Node *Node, Uint64 Offset, Uint64 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  * \fn Uint64 FAT_Read(tVFS_Node *node, Uint64 offset, Uint64 length, void *buffer)\r
 620  * \brief Reads data from a specified file\r
 621  */\r
 622 Uint64 FAT_Read(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)\r
 623 {\r
 624          int    preSkip, count;\r
 625         Uint64  final_bytes;\r
 626          int    i, cluster, pos;\r
 627         tFAT_VolInfo    *disk = Node->ImplPtr;\r
 628         char    tmpBuf[disk->BytesPerCluster];\r
 629          int    bpc = disk->BytesPerCluster;\r
 630         \r
 631         ENTER("pNode Xoffset Xlength pbuffer", Node, Offset, Length, Buffer);\r
 632         \r
 633         // Sanity Check offset\r
 634         if(Offset > Node->Size) {\r
 635                 LOG("Seek past EOF (%i > %i)", Offset, Node->Size);\r
 636                 LEAVE('i', 0);\r
 637                 return 0;\r
 638         }\r
 639         \r
 640         // Cluster is stored in the low 32-bits of the Inode field\r
 641         cluster = Node->Inode & 0xFFFFFFFF;\r
 642         \r
 643         // Clamp Size\r
 644         if(Offset + Length > Node->Size) {\r
 645                 LOG("Reading past EOF (%lli + %lli > %lli), clamped to %lli",\r
 646                         Offset, Length, Node->Size, Node->Size - Offset);\r
 647                 Length = Node->Size - Offset;\r
 648         }\r
 649         \r
 650         // Skip previous clusters\r
 651         preSkip = Offset / bpc;\r
 652         Offset %= bpc;\r
 653         LOG("preSkip = %i, Offset = %i", preSkip, (int)Offset);\r
 654         for(i = preSkip; i--; )\r
 655         {\r
 656                 cluster = FAT_int_GetFatValue(disk, cluster);\r
 657                 if(cluster == -1) {\r
 658                         Log_Warning("FAT", "Offset is past end of cluster chain mark");\r
 659                         LEAVE('i', 0);\r
 660                         return 0;\r
 661                 }\r
 662         }\r
 663 \r
 664         // Reading from within one cluster\r
 665         if((int)Offset + (int)Length <= bpc)\r
 666         {\r
 667                 LOG("single cluster only");\r
 668                 FAT_int_ReadCluster(disk, cluster, bpc, tmpBuf);\r
 669                 memcpy( Buffer, (void*)( tmpBuf + Offset%bpc ), Length );\r
 670                 LEAVE('X', Length);\r
 671                 return Length;\r
 672         }\r
 673         \r
 674         // Align read to a cluster\r
 675         if( Offset > 0 )\r
 676         {\r
 677                 pos = bpc - Offset;\r
 678                 FAT_int_ReadCluster(disk, cluster, bpc, tmpBuf);\r
 679                 memcpy( Buffer, (void*)( tmpBuf + Offset ), pos );\r
 680                 LOG("pos = %i, Reading the rest of the clusters");\r
 681                 // Get next cluster in the chain\r
 682                 cluster = FAT_int_GetFatValue(disk, cluster);\r
 683                 if(cluster == -1) {\r
 684                         Log_Warning("FAT", "Read past End of Cluster Chain (Align)");\r
 685                         LEAVE('X', pos);\r
 686                         return pos;\r
 687                 }\r
 688         }\r
 689         else\r
 690                 pos = 0;\r
 691 \r
 692         // Get Count of Clusters to read\r
 693 //      count = DivMod64U(Length - pos, bpc, &final_bytes);\r
 694         count = (Length - pos) / bpc;\r
 695         final_bytes = (Length - pos) % bpc;\r
 696         LOG("Offset = %i, Length = %i, count = %i, final_bytes = %i", (int)Offset, (int)Length, count, final_bytes);\r
 697         \r
 698         // Read the rest of the cluster data\r
 699         for( ; count; count -- )\r
 700         {\r
 701                 if(cluster == -1) {\r
 702                         Log_Warning("FAT", "Read past End of Cluster Chain (Bulk)");\r
 703                         LEAVE('X', pos);\r
 704                         return pos;\r
 705                 }\r
 706                 // Read cluster\r
 707                 FAT_int_ReadCluster(disk, cluster, bpc, (void*)(Buffer+pos));\r
 708                 pos += bpc;\r
 709                 // Get next cluster in the chain\r
 710                 cluster = FAT_int_GetFatValue(disk, cluster);\r
 711         }\r
 712 \r
 713         if( final_bytes > 0 )\r
 714         {\r
 715                 if(cluster == -1) {\r
 716                         Log_Warning("FAT", "Read past End of Cluster Chain (Final)");\r
 717                         LEAVE('X', pos);\r
 718                         return pos;\r
 719                 }\r
 720                 // Read final cluster\r
 721                 FAT_int_ReadCluster( disk, cluster, bpc, tmpBuf );\r
 722                 memcpy( (void*)(Buffer+pos), tmpBuf, Length-pos );\r
 723         }\r
 724                 \r
 725         #if DEBUG\r
 726         //Debug_HexDump("FAT_Read", Buffer, Length);\r
 727         #endif\r
 728         \r
 729         LEAVE('X', Length);\r
 730         return Length;\r
 731 }\r
 732 \r
 733 #if SUPPORT_WRITE\r
 734 /**\r
 735  * \brief Write a cluster to disk\r
 736  */\r
 737 void FAT_int_WriteCluster(tFAT_VolInfo *Disk, Uint32 Cluster, void *Buffer)\r
 738 {\r
 739         ENTER("pDisk xCluster pBuffer", Disk, Cluster, Buffer);\r
 740         VFS_ReadAt(\r
 741                 Disk->fileHandle,\r
 742                 (Disk->firstDataSect + (Cluster-2)*Disk->bootsect.spc )\r
 743                         * Disk->bootsect.bps,\r
 744                 Disk->BytesPerCluster,\r
 745                 Buffer\r
 746                 );\r
 747         LEAVE('-');\r
 748 }\r
 749 \r
 750 /**\r
 751  * \brief Write to a file\r
 752  * \param Node  File Node\r
 753  * \param Offset        Offset within file\r
 754  * \param Length        Size of data to write\r
 755  * \param Buffer        Data source\r
 756  */\r
 757 Uint64 FAT_Write(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)\r
 758 {\r
 759         tFAT_VolInfo    *disk = Node->ImplPtr;\r
 760         char    tmpBuf[disk->BytesPerCluster];\r
 761          int    remLength = Length;\r
 762         Uint32  cluster, tmpCluster;\r
 763          int    bNewCluster = 0;\r
 764         \r
 765         if(Offset > Node->Size) return 0;\r
 766         \r
 767         // Seek Clusters\r
 768         cluster = Node->Inode & 0xFFFFFFFF;\r
 769         while( Offset > disk->BytesPerCluster )\r
 770         {\r
 771                 cluster = FAT_int_GetFatValue( disk, cluster );\r
 772                 if(cluster == -1) {\r
 773                         Log_Warning("FAT", "EOC Unexpectedly Reached");\r
 774                         return 0;\r
 775                 }\r
 776                 Offset -= disk->BytesPerCluster;\r
 777         }\r
 778         if( Offset == disk->BytesPerCluster )\r
 779         {\r
 780                 Uint32  tmp = FAT_int_AllocateCluster(disk, cluster);\r
 781                 if(!tmp)        return 0;\r
 782                 cluster = tmp;\r
 783                 Offset -= disk->BytesPerCluster;\r
 784         }\r
 785         \r
 786         if( Offset + Length < disk->BytesPerCluster )\r
 787         {\r
 788                 char    tmpBuf[disk->BytesPerCluster];\r
 789                 \r
 790                 // Read-Modify-Write\r
 791                 FAT_int_ReadCluster( disk, cluster, disk->BytesPerCluster, tmpBuf );\r
 792                 memcpy( tmpBuf + Offset, Buffer, Length );\r
 793                 FAT_int_WriteCluster( disk, cluster, tmpBuf );\r
 794                 \r
 795                 return Length;\r
 796         }\r
 797         \r
 798         // Clean up changes within a cluster\r
 799         if( Offset )\r
 800         {       \r
 801                 // Read-Modify-Write\r
 802                 FAT_int_ReadCluster( disk, cluster, disk->BytesPerCluster, tmpBuf );\r
 803                 memcpy( tmpBuf + Offset, Buffer, disk->BytesPerCluster - Offset );\r
 804                 FAT_int_WriteCluster( disk, cluster, tmpBuf );\r
 805                 \r
 806                 remLength -= disk->BytesPerCluster - Offset;\r
 807                 Buffer += disk->BytesPerCluster - Offset;\r
 808                 \r
 809                 // Get next cluster (allocating if needed)\r
 810                 tmpCluster = FAT_int_GetFatValue(disk, cluster);\r
 811                 if(tmpCluster == -1) {\r
 812                         tmpCluster = FAT_int_AllocateCluster(disk, cluster);\r
 813                         if( tmpCluster == 0 ) {\r
 814                                 return Length - remLength;\r
 815                         }\r
 816                 }\r
 817                 cluster = tmpCluster;\r
 818         }\r
 819         \r
 820         while( remLength > disk->BytesPerCluster )\r
 821         {\r
 822                 FAT_int_WriteCluster( disk, cluster, Buffer );\r
 823                 Buffer += disk->BytesPerCluster;\r
 824                 \r
 825                 // Get next cluster (allocating if needed)\r
 826                 tmpCluster = FAT_int_GetFatValue(disk, cluster);\r
 827                 if(tmpCluster == -1) {\r
 828                         bNewCluster = 1;\r
 829                         tmpCluster = FAT_int_AllocateCluster(disk, cluster);\r
 830                         if( tmpCluster == 0 ) {\r
 831                                 return Length - remLength;\r
 832                         }\r
 833                 }\r
 834                 cluster = tmpCluster;\r
 835         }\r
 836         \r
 837         // Finish off\r
 838         tmpBuf = malloc( disk->BytesPerCluster );\r
 839         if( bNewCluster )\r
 840                 memset(tmpBuf, 0, disk->BytesPerCluster);\r
 841         else\r
 842                 FAT_int_ReadCluster( disk, cluster, disk->BytesPerCluster, tmpBuf );\r
 843         memcpy( tmpBuf, Buffer, remLength );\r
 844         FAT_int_WriteCluster( disk, cluster, tmpBuf );\r
 845         free( tmpBuf );\r
 846         \r
 847         return Length;\r
 848 }\r
 849 #endif\r
 850 \r
 851 /* ====================\r
 852  *  File Names & Nodes\r
 853  * ====================\r
 854  */\r
 855 /**\r
 856  * \brief Converts a FAT directory entry name into a proper filename\r
 857  * \param dest  Destination array (must be at least 13 bytes in size)\r
 858  * \param src   8.3 filename (concatenated, e.g 'FILE1   TXT')\r
 859  */\r
 860 void FAT_int_ProperFilename(char *dest, const char *src)\r
 861 {\r
 862          int    inpos, outpos;\r
 863         \r
 864         // Name\r
 865         outpos = 0;\r
 866         for( inpos = 0; inpos < 8; inpos++ ) {\r
 867                 if(src[inpos] == ' ')   break;\r
 868                 dest[outpos++] = src[inpos];\r
 869         }\r
 870         inpos = 8;\r
 871         // Check for empty extensions\r
 872         if(src[8] != ' ')\r
 873         {\r
 874                 dest[outpos++] = '.';\r
 875                 for( ; inpos < 11; inpos++)     {\r
 876                         if(src[inpos] == ' ')   break;\r
 877                         dest[outpos++] = src[inpos];\r
 878                 }\r
 879         }\r
 880         dest[outpos++] = '\0';\r
 881         \r
 882         //LOG("dest='%s'", dest);\r
 883 }\r
 884 \r
 885 /**\r
 886  * \fn char *FAT_int_CreateName(fat_filetable *ft, char *LongFileName)\r
 887  * \brief Converts either a LFN or a 8.3 Name into a proper name\r
 888  * \param ft    Pointer to the file's entry in the parent directory\r
 889  * \param LongFileName  Long file name pointer\r
 890  * \return Filename as a heap string\r
 891  */\r
 892 char *FAT_int_CreateName(fat_filetable *ft, char *LongFileName)\r
 893 {\r
 894         char    *ret;\r
 895         ENTER("pft sLongFileName", ft, LongFileName);\r
 896         //Log_Debug("FAT", "FAT_int_CreateName(ft=%p, LongFileName=%p'%s')", ft, LongFileName);\r
 897         #if USE_LFN\r
 898         if(LongFileName && LongFileName[0] != '\0')\r
 899         {       \r
 900                 ret = strdup(LongFileName);\r
 901         }\r
 902         else\r
 903         {\r
 904         #endif\r
 905                 ret = (char*) malloc(13);\r
 906                 if( !ret ) {\r
 907                         Log_Warning("FAT", "FAT_int_CreateName: malloc(13) failed");\r
 908                         return NULL;\r
 909                 }\r
 910                 FAT_int_ProperFilename(ret, ft->name);\r
 911         #if USE_LFN\r
 912         }\r
 913         #endif\r
 914         LEAVE('s', ret);\r
 915         return ret;\r
 916 }\r
 917 \r
 918 /**\r
 919  * \brief Creates a tVFS_Node structure for a given file entry\r
 920  * \param Parent        Parent directory VFS node\r
 921  * \param Entry File table entry for the new node\r
 922  * \param Pos   Position in the parent of the new node\r
 923  */\r
 924 tVFS_Node *FAT_int_CreateNode(tVFS_Node *Parent, fat_filetable *Entry, int Pos)\r
 925 {\r
 926         tVFS_Node       node;\r
 927         tVFS_Node       *ret;\r
 928         tFAT_VolInfo    *disk = Parent->ImplPtr;\r
 929         \r
 930         ENTER("pParent pFT", Parent, Entry);\r
 931         LOG("disk = %p", disk);\r
 932         \r
 933         memset(&node, 0, sizeof(tVFS_Node));\r
 934         \r
 935         // Set Other Data\r
 936         // 0-27: Cluster, 32-59: Parent Cluster\r
 937         node.Inode = Entry->cluster | (Entry->clusterHi<<16) | (Parent->Inode << 32);\r
 938         LOG("node.Inode = %llx", node.Inode);\r
 939         // Position in parent directory\r
 940         node.ImplInt = Pos & 0xFFFF;\r
 941         // Disk Pointer\r
 942         node.ImplPtr = disk;\r
 943         node.Size = Entry->size;\r
 944         LOG("Entry->size = %i", Entry->size);\r
 945         // root:root\r
 946         node.UID = 0;   node.GID = 0;\r
 947         node.NumACLs = 1;\r
 948         \r
 949         node.Flags = 0;\r
 950         if(Entry->attrib & ATTR_DIRECTORY)      node.Flags |= VFS_FFLAG_DIRECTORY;\r
 951         if(Entry->attrib & ATTR_READONLY) {\r
 952                 node.Flags |= VFS_FFLAG_READONLY;\r
 953                 node.ACLs = &gVFS_ACL_EveryoneRX;       // R-XR-XR-X\r
 954         }\r
 955         else {\r
 956                 node.ACLs = &gVFS_ACL_EveryoneRWX;      // RWXRWXRWX\r
 957         }\r
 958         \r
 959         // Create timestamps\r
 960         node.ATime = timestamp(0,0,0,\r
 961                         ((Entry->adate&0x1F) - 1),      // Days\r
 962                         ((Entry->adate&0x1E0) - 1),     // Months\r
 963                         1980+((Entry->adate&0xFF00)>>8) // Years\r
 964                         );\r
 965         \r
 966         node.CTime = Entry->ctimems * 10;       // Miliseconds\r
 967         node.CTime += timestamp(\r
 968                         ((Entry->ctime&0x1F)<<1),       // Seconds\r
 969                         ((Entry->ctime&0x3F0)>>5),      // Minutes\r
 970                         ((Entry->ctime&0xF800)>>11),    // Hours\r
 971                         ((Entry->cdate&0x1F)-1),                // Days\r
 972                         ((Entry->cdate&0x1E0)-1),               // Months\r
 973                         1980+((Entry->cdate&0xFF00)>>8) // Years\r
 974                         );\r
 975                         \r
 976         node.MTime = timestamp(\r
 977                         ((Entry->mtime&0x1F)<<1),       // Seconds\r
 978                         ((Entry->mtime&0x3F0)>>5),      // Minutes\r
 979                         ((Entry->mtime&0xF800)>>11),    // Hours\r
 980                         ((Entry->mdate&0x1F)-1),                // Days\r
 981                         ((Entry->mdate&0x1E0)-1),               // Months\r
 982                         1980+((Entry->mdate&0xFF00)>>8) // Years\r
 983                         );\r
 984         \r
 985         // Set pointers\r
 986         if(node.Flags & VFS_FFLAG_DIRECTORY) {\r
 987                 //Log_Debug("FAT", "Directory %08x has size 0x%x", node.Inode, node.Size);\r
 988                 node.Type = &gFAT_DirType;      \r
 989                 node.Size = -1;\r
 990         }\r
 991         else {\r
 992                 node.Type = &gFAT_FileType;\r
 993         }\r
 994         \r
 995         ret = Inode_CacheNode(disk->inodeHandle, &node);\r
 996         LEAVE('p', ret);\r
 997         return ret;\r
 998 }\r
 999 \r
1000 /* \r
1001  * ====================\r
1002  *     Directory IO\r
1003  * ====================\r
1004  */\r
1005 \r
1006 /**\r
1007  * \brief Reads a sector from the disk\r
1008  * \param Node  Directory node to read\r
1009  * \param Sector        Sector number in the directory to read\r
1010  * \param Buffer        Destination buffer for the read data\r
1011  */\r
1012 int FAT_int_ReadDirSector(tVFS_Node *Node, int Sector, fat_filetable *Buffer)\r
1013 {\r
1014         Uint64  addr;\r
1015         tFAT_VolInfo    *disk = Node->ImplPtr;\r
1016         \r
1017         ENTER("pNode iSector pEntry", Node, Sector, Buffer);\r
1018         \r
1019         // Parse address\r
1020         if(FAT_int_GetAddress(Node, Sector * 512, &addr, NULL))\r
1021         {\r
1022                 LEAVE('i', 1);\r
1023                 return 1;\r
1024         }\r
1025         \r
1026         LOG("addr = 0x%llx", addr);\r
1027         // Read Sector\r
1028         if(VFS_ReadAt(disk->fileHandle, addr, 512, Buffer) != 512)\r
1029         {\r
1030                 LEAVE('i', 1);\r
1031                 return 1;\r
1032         }\r
1033         \r
1034         LEAVE('i', 0);\r
1035         return 0;\r
1036 }\r
1037 \r
1038 #if SUPPORT_WRITE\r
1039 /**\r
1040  * \brief Writes an entry to the disk\r
1041  * \todo Support expanding a directory\r
1042  * \param Node  Directory node\r
1043  * \param ID    ID of entry to update\r
1044  * \param Entry Entry data\r
1045  * \return Zero on success, non-zero on error\r
1046  */\r
1047 int FAT_int_WriteDirEntry(tVFS_Node *Node, int ID, fat_filetable *Entry)\r
1048 {\r
1049         Uint64  addr = 0;\r
1050          int    tmp;\r
1051         Uint32  cluster = 0;\r
1052         tFAT_VolInfo    *disk = Node->ImplPtr;\r
1053         \r
1054         ENTER("pNode iID pEntry", Node, ID, Entry);\r
1055         \r
1056         tmp = FAT_int_GetAddress(Node, ID * sizeof(fat_filetable), &addr, &cluster);\r
1057         if( tmp )\r
1058         {\r
1059                 //TODO: Allocate a cluster\r
1060                 cluster = FAT_int_AllocateCluster(Node->ImplPtr, cluster);\r
1061                 if(cluster == -1) {\r
1062                         Log_Warning("FAT", "Unable to allocate an other cluster for %p", Node);\r
1063                         LEAVE('i', 1);\r
1064                         return 1;\r
1065                 }\r
1066                 FAT_int_GetAddress(Node, ID * sizeof(fat_filetable), &addr, &cluster);\r
1067         }\r
1068         \r
1069 \r
1070         LOG("addr = 0x%llx", addr);\r
1071         \r
1072         // Read Sector\r
1073         VFS_WriteAt(disk->fileHandle, addr, sizeof(fat_filetable), Entry);      // Read Dir Data\r
1074         \r
1075         LEAVE('i', 0);\r
1076         return 0;\r
1077 }\r
1078 #endif\r
1079 \r
1080 #if USE_LFN     \r
1081 /**\r
1082  * \fn char *FAT_int_GetLFN(tVFS_Node *node)\r
1083  * \brief Return pointer to LFN cache entry\r
1084  * \param Node  Directory node\r
1085  * \param ID    ID of the short name\r
1086  * \return Pointer to the LFN cache entry\r
1087  */\r
1088 char *FAT_int_GetLFN(tVFS_Node *Node, int ID)\r
1089 {\r
1090         tFAT_LFNCache   *cache;\r
1091          int    i, firstFree;\r
1092         \r
1093         Mutex_Acquire( &Node->Lock );\r
1094         \r
1095         // TODO: Thread Safety (Lock things)\r
1096         cache = Node->Data;\r
1097         \r
1098         // Create a cache if it isn't there\r
1099         if(!cache) {\r
1100                 cache = Node->Data = malloc( sizeof(tFAT_LFNCache) + sizeof(tFAT_LFNCacheEnt) );\r
1101                 cache->NumEntries = 1;\r
1102                 cache->Entries[0].ID = ID;\r
1103                 cache->Entries[0].Data[0] = '\0';\r
1104                 Mutex_Release( &Node->Lock );\r
1105                 //Log_Debug("FAT", "Return = %p (new)", cache->Entries[0].Data);\r
1106                 return cache->Entries[0].Data;\r
1107         }\r
1108         \r
1109         // Scan for this entry\r
1110         firstFree = -1;\r
1111         for( i = 0; i < cache->NumEntries; i++ )\r
1112         {\r
1113                 if( cache->Entries[i].ID == ID ) {\r
1114                         Mutex_Release( &Node->Lock );\r
1115                         //Log_Debug("FAT", "Return = %p (match)", cache->Entries[i].Data);\r
1116                         return cache->Entries[i].Data;\r
1117                 }\r
1118                 if( cache->Entries[i].ID == -1 && firstFree == -1 )\r
1119                         firstFree = i;\r
1120         }\r
1121         \r
1122         if(firstFree == -1) {\r
1123                 // Use `i` for temp length\r
1124                 i = sizeof(tFAT_LFNCache) + (cache->NumEntries+1)*sizeof(tFAT_LFNCacheEnt);\r
1125                 Node->Data = realloc( Node->Data, i );\r
1126                 if( !Node->Data ) {\r
1127                         Log_Error("FAT", "realloc() fail, unable to allocate %i for LFN cache", i);\r
1128                         Mutex_Release( &Node->Lock );\r
1129                         return NULL;\r
1130                 }\r
1131                 //Log_Debug("FAT", "Realloc (%i)\n", i);\r
1132                 cache = Node->Data;\r
1133                 i = cache->NumEntries;\r
1134                 cache->NumEntries ++;\r
1135         }\r
1136         else {\r
1137                 i = firstFree;\r
1138         }\r
1139         \r
1140         // Create new entry\r
1141         cache->Entries[ i ].ID = ID;\r
1142         cache->Entries[ i ].Data[0] = '\0';\r
1143         \r
1144         Mutex_Release( &Node->Lock );\r
1145         //Log_Debug("FAT", "Return = %p (firstFree, i = %i)", cache->Entries[i].Data, i);\r
1146         return cache->Entries[ i ].Data;\r
1147 }\r
1148 \r
1149 /**\r
1150  * \fn void FAT_int_DelLFN(tVFS_Node *node)\r
1151  * \brief Delete a LFN cache entry\r
1152  * \param Node  Directory node\r
1153  * \param ID    File Entry ID\r
1154  */\r
1155 void FAT_int_DelLFN(tVFS_Node *Node, int ID)\r
1156 {\r
1157         tFAT_LFNCache   *cache = Node->Data;\r
1158          int    i;\r
1159         \r
1160         // Fast return\r
1161         if(!cache)      return;\r
1162         \r
1163         // Scan for a current entry\r
1164         for( i = 0; i < cache->NumEntries; i++ )\r
1165         {\r
1166                 if( cache->Entries[i].ID == ID )\r
1167                         cache->Entries[i].ID = -1;\r
1168         }\r
1169         return ;\r
1170 }\r
1171 #endif\r
1172 \r
1173 /**\r
1174  * \fn char *FAT_ReadDir(tVFS_Node *Node, int ID)\r
1175  * \param Node  Node structure of directory\r
1176  * \param ID    Directory position\r
1177  * \return Filename as a heap string, NULL or VFS_SKIP\r
1178  */\r
1179 char *FAT_ReadDir(tVFS_Node *Node, int ID)\r
1180 {\r
1181         fat_filetable   fileinfo[16];   // sizeof(fat_filetable)=32, so 16 per sector\r
1182          int    a = 0;\r
1183         char    *ret;\r
1184         #if USE_LFN\r
1185         char    *lfn = NULL;\r
1186         #endif\r
1187         \r
1188         ENTER("pNode iID", Node, ID);\r
1189         \r
1190         if(FAT_int_ReadDirSector(Node, ID/16, fileinfo))\r
1191         {\r
1192                 LOG("End of chain, end of dir");\r
1193                 LEAVE('n');\r
1194                 return NULL;\r
1195         }\r
1196         \r
1197         // Offset in sector\r
1198         a = ID % 16;\r
1199 \r
1200         LOG("fileinfo[%i].name[0] = 0x%x", a, (Uint8)fileinfo[a].name[0]);\r
1201         \r
1202         // Check if this is the last entry\r
1203         if( fileinfo[a].name[0] == '\0' ) {\r
1204                 Node->Size = ID;\r
1205                 LOG("End of list");\r
1206                 LEAVE('n');\r
1207                 return NULL;    // break\r
1208         }\r
1209         \r
1210         // Check for empty entry\r
1211         if( (Uint8)fileinfo[a].name[0] == 0xE5 ) {\r
1212                 LOG("Empty Entry");\r
1213                 #if 0   // Stop on empty entry?\r
1214                 LEAVE('n');\r
1215                 return NULL;    // Stop\r
1216                 #else\r
1217                 LEAVE('p', VFS_SKIP);\r
1218                 return VFS_SKIP;        // Skip\r
1219                 #endif\r
1220         }\r
1221         \r
1222         #if USE_LFN\r
1223         // Get Long File Name Cache\r
1224         if(fileinfo[a].attrib == ATTR_LFN)\r
1225         {\r
1226                 fat_longfilename        *lfnInfo;\r
1227                 \r
1228                 lfnInfo = (fat_longfilename *) &fileinfo[a];\r
1229                 \r
1230                 // Get cache for corresponding file\r
1231                 // > ID + Index gets the corresponding short node\r
1232                 lfn = FAT_int_GetLFN( Node, ID + (lfnInfo->id & 0x3F) );\r
1233                 \r
1234                 // Bit 6 indicates the start of an entry\r
1235                 if(lfnInfo->id & 0x40)  memset(lfn, 0, 256);\r
1236                 \r
1237                 a = ((lfnInfo->id & 0x3F) - 1) * 13;\r
1238                 //Log_Debug("FAT", "ID = 0x%02x, a = %i", lfnInfo->id, a);\r
1239                 \r
1240                 // Sanity Check (FAT implementations should not allow >255 character names)\r
1241                 if(a > 255)     return VFS_SKIP;\r
1242                 \r
1243                 // Append new bytes\r
1244                 lfn[a+ 0] = lfnInfo->name1[0];  lfn[a+ 1] = lfnInfo->name1[1];\r
1245                 lfn[a+ 2] = lfnInfo->name1[2];  lfn[a+ 3] = lfnInfo->name1[3];\r
1246                 lfn[a+ 4] = lfnInfo->name1[4];  \r
1247                 lfn[a+ 5] = lfnInfo->name2[0];  lfn[a+ 6] = lfnInfo->name2[1];\r
1248                 lfn[a+ 7] = lfnInfo->name2[2];  lfn[a+ 8] = lfnInfo->name2[3];\r
1249                 lfn[a+ 9] = lfnInfo->name2[4];  lfn[a+10] = lfnInfo->name2[5];\r
1250                 lfn[a+11] = lfnInfo->name3[0];  lfn[a+12] = lfnInfo->name3[1];\r
1251                 LOG("lfn = '%s'", lfn);\r
1252                 //Log_Debug("FAT", "lfn = '%s'", lfn);\r
1253                 LEAVE('p', VFS_SKIP);\r
1254                 return VFS_SKIP;\r
1255         }\r
1256         #endif\r
1257         \r
1258         // Check if it is a volume entry\r
1259         if(fileinfo[a].attrib & 0x08) {\r
1260                 LEAVE('p', VFS_SKIP);\r
1261                 return VFS_SKIP;\r
1262         }\r
1263         // Ignore .\r
1264         if(fileinfo[a].name[0] == '.' && fileinfo[a].name[1] == ' ') {\r
1265                 LEAVE('p', VFS_SKIP);\r
1266                 return VFS_SKIP;\r
1267         }\r
1268         // and ..\r
1269         if(fileinfo[a].name[0] == '.' && fileinfo[a].name[1] == '.' && fileinfo[a].name[2] == ' ') {\r
1270                 LEAVE('p', VFS_SKIP);\r
1271                 return VFS_SKIP;\r
1272         }\r
1273         \r
1274         LOG("name='%c%c%c%c%c%c%c%c.%c%c%c'",\r
1275                 fileinfo[a].name[0], fileinfo[a].name[1], fileinfo[a].name[2], fileinfo[a].name[3],\r
1276                 fileinfo[a].name[4], fileinfo[a].name[5], fileinfo[a].name[6], fileinfo[a].name[7],\r
1277                 fileinfo[a].name[8], fileinfo[a].name[9], fileinfo[a].name[10] );\r
1278         \r
1279         #if USE_LFN\r
1280         lfn = FAT_int_GetLFN(Node, ID);\r
1281         //Log_Debug("FAT", "lfn = %p'%s'", lfn, lfn);\r
1282         ret = FAT_int_CreateName(&fileinfo[a], lfn);\r
1283         #else\r
1284         ret = FAT_int_CreateName(&fileinfo[a], NULL);\r
1285         #endif\r
1286         \r
1287         LEAVE('s', ret);\r
1288         return ret;\r
1289 }\r
1290 \r
1291 /**\r
1292  * \fn tVFS_Node *FAT_FindDir(tVFS_Node *node, char *name)\r
1293  * \brief Finds an entry in the current directory\r
1294  */\r
1295 tVFS_Node *FAT_FindDir(tVFS_Node *Node, const char *Name)\r
1296 {\r
1297         fat_filetable   fileinfo[16];\r
1298         char    tmpName[13];\r
1299         #if USE_LFN\r
1300         fat_longfilename        *lfnInfo;\r
1301         char    lfn[256];\r
1302          int    lfnPos=255, lfnId = -1;\r
1303         #endif\r
1304          int    i;\r
1305         tVFS_Node       *tmpNode;\r
1306         tFAT_VolInfo    *disk = Node->ImplPtr;\r
1307         Uint32  cluster;\r
1308         \r
1309         ENTER("pNode sname", Node, Name);       \r
1310 \r
1311         // Fast Returns\r
1312         if(!Name || Name[0] == '\0') {\r
1313                 LEAVE('n');\r
1314                 return NULL;\r
1315         }\r
1316         \r
1317         for( i = 0; ; i++ )\r
1318         {\r
1319                 if((i & 0xF) == 0) {\r
1320                         if(FAT_int_ReadDirSector(Node, i/16, fileinfo))\r
1321                         {\r
1322                                 LEAVE('n');\r
1323                                 return NULL;\r
1324                         }\r
1325                 }\r
1326                 \r
1327                 //Check if the files are free\r
1328                 if(fileinfo[i&0xF].name[0] == '\0')     break;  // End of List marker\r
1329                 if(fileinfo[i&0xF].name[0] == '\xE5')   continue;       // Free entry\r
1330                 \r
1331                 \r
1332                 #if USE_LFN\r
1333                 // Long File Name Entry\r
1334                 if(fileinfo[i & 0xF].attrib == ATTR_LFN)\r
1335                 {\r
1336                         lfnInfo = (fat_longfilename *) &fileinfo[i&0xF];\r
1337                         if(lfnInfo->id & 0x40) {\r
1338                                 memset(lfn, 0, 256);\r
1339                                 lfnPos = (lfnInfo->id & 0x3F) * 13 - 1;\r
1340                         }\r
1341                         // Sanity check the position so we don't overflow\r
1342                         if( lfnPos < 12 )\r
1343                                 continue ;\r
1344                         lfn[lfnPos--] = lfnInfo->name3[1];      lfn[lfnPos--] = lfnInfo->name3[0];\r
1345                         lfn[lfnPos--] = lfnInfo->name2[5];      lfn[lfnPos--] = lfnInfo->name2[4];\r
1346                         lfn[lfnPos--] = lfnInfo->name2[3];      lfn[lfnPos--] = lfnInfo->name2[2];\r
1347                         lfn[lfnPos--] = lfnInfo->name2[1];      lfn[lfnPos--] = lfnInfo->name2[0];\r
1348                         lfn[lfnPos--] = lfnInfo->name1[4];      lfn[lfnPos--] = lfnInfo->name1[3];\r
1349                         lfn[lfnPos--] = lfnInfo->name1[2];      lfn[lfnPos--] = lfnInfo->name1[1];\r
1350                         lfn[lfnPos--] = lfnInfo->name1[0];\r
1351                         if((lfnInfo->id&0x3F) == 1)\r
1352                         {\r
1353                                 lfnId = i+1;\r
1354                         }\r
1355                 }\r
1356                 else\r
1357                 {\r
1358                         // Remove LFN if it does not apply\r
1359                         if(lfnId != i)  lfn[0] = '\0';\r
1360                 #else\r
1361                 if(fileinfo[i&0xF].attrib == ATTR_LFN)  continue;\r
1362                 #endif\r
1363                         // Get Real Filename\r
1364                         FAT_int_ProperFilename(tmpName, fileinfo[i&0xF].name);\r
1365                         LOG("tmpName = '%s'", tmpName);\r
1366                 \r
1367                         // Only the long name is case sensitive, 8.3 is not\r
1368                         #if USE_LFN\r
1369                         if(strucmp(tmpName, Name) == 0 || strcmp(lfn, Name) == 0)\r
1370                         #else\r
1371                         if(strucmp(tmpName, Name) == 0)\r
1372                         #endif\r
1373                         {\r
1374                                 cluster = fileinfo[i&0xF].cluster | (fileinfo[i&0xF].clusterHi << 16);\r
1375                                 tmpNode = Inode_GetCache(disk->inodeHandle, cluster);\r
1376                                 if(tmpNode == NULL)     // Node is not cached\r
1377                                 {\r
1378                                         tmpNode = FAT_int_CreateNode(Node, &fileinfo[i&0xF], i);\r
1379                                 }\r
1380                                 LEAVE('p', tmpNode);\r
1381                                 return tmpNode;\r
1382                         }\r
1383                 #if USE_LFN\r
1384                 }\r
1385                 #endif\r
1386         }\r
1387         \r
1388         LEAVE('n');\r
1389         return NULL;\r
1390 }\r
1391 \r
1392 tVFS_Node *FAT_GetNodeFromINode(tVFS_Node *Root, Uint64 Inode)\r
1393 {\r
1394         tFAT_VolInfo    *disk = Root->ImplPtr;\r
1395          int    ents_per_sector = 512 / sizeof(fat_filetable); \r
1396         fat_filetable   fileinfo[ents_per_sector];\r
1397          int    sector = 0, i;\r
1398         tVFS_Node       stub_node;\r
1399 \r
1400         ENTER("pRoot XInode", Root, Inode);\r
1401 \r
1402         stub_node.ImplPtr = disk;\r
1403         stub_node.Size = -1;\r
1404         stub_node.Inode = Inode >> 32;\r
1405 \r
1406         for( i = 0; ; i ++ )\r
1407         {\r
1408                 if( i == 0 || i == ents_per_sector )\r
1409                 {\r
1410                         if(FAT_int_ReadDirSector(&stub_node, sector, fileinfo))\r
1411                         {\r
1412                                 LOG("ReadDirSector failed");\r
1413                                 LEAVE('n');\r
1414                                 return NULL;\r
1415                         }\r
1416                         i = 0;\r
1417                         sector ++;\r
1418                 }\r
1419         \r
1420                 // Check for free/end of list\r
1421                 if(fileinfo[i].name[0] == '\0') break;  // End of List marker\r
1422                 if(fileinfo[i].name[0] == '\xE5')       continue;       // Free entry\r
1423                 \r
1424                 if(fileinfo[i].attrib == ATTR_LFN)      continue;\r
1425 \r
1426                 LOG("fileinfo[i].cluster = %x %04x", fileinfo[i].clusterHi, fileinfo[i].cluster);\r
1427                 #if DEBUG\r
1428                 {\r
1429                         char    tmpName[13];\r
1430                         FAT_int_ProperFilename(tmpName, fileinfo[i].name);\r
1431                         LOG("tmpName = '%s'", tmpName);\r
1432                 }\r
1433                 #endif\r
1434                 \r
1435         \r
1436                 if(fileinfo[i].cluster != (Inode & 0xFFFF))     continue;\r
1437                 if(fileinfo[i].clusterHi != ((Inode >> 16) & 0xFFFF))   continue;\r
1438 \r
1439                 LEAVE_RET('p', FAT_int_CreateNode(&stub_node, &fileinfo[i], sector*ents_per_sector+i));\r
1440         }\r
1441         LOG("sector = %i, i = %i", sector, i);\r
1442         LEAVE('n');\r
1443         return NULL;\r
1444 }\r
1445 \r
1446 #if SUPPORT_WRITE\r
1447 /**\r
1448  * \fn int FAT_Mknod(tVFS_Node *Node, char *Name, Uint Flags)\r
1449  * \brief Create a new node\r
1450  */\r
1451 int FAT_Mknod(tVFS_Node *Node, char *Name, Uint Flags)\r
1452 {\r
1453         return 0;\r
1454 }\r
1455 \r
1456 /**\r
1457  * \fn int FAT_Relink(tVFS_Node *Node, char *OldName, char *NewName)\r
1458  * \brief Rename / Delete a file\r
1459  */\r
1460 int FAT_Relink(tVFS_Node *Node, char *OldName, char *NewName)\r
1461 {\r
1462         tVFS_Node       *child;\r
1463         fat_filetable   ft = {0};\r
1464          int    ret;\r
1465         \r
1466         child = FAT_FindDir(Node, OldName);\r
1467         if(!child)      return ENOTFOUND;\r
1468         \r
1469         // Delete?\r
1470         if( NewName == NULL )\r
1471         {\r
1472                 child->ImplInt |= FAT_FLAG_DELETE;      // Mark for deletion on close\r
1473                 \r
1474                 // Delete from the directory\r
1475                 ft.name[0] = '\xE9';\r
1476                 FAT_int_WriteDirEntry(Node, child->ImplInt & 0xFFFF, &ft);\r
1477                 \r
1478                 // Return success\r
1479                 ret = EOK;\r
1480         }\r
1481         // Rename\r
1482         else\r
1483         {\r
1484                 Log_Warning("FAT", "Renaming no yet supported %p ('%s' => '%s')",\r
1485                         Node, OldName, NewName);\r
1486                 ret = ENOTIMPL;\r
1487         }\r
1488         \r
1489         // Close child\r
1490         child->Close( child );\r
1491         return ret;\r
1492 }\r
1493 #endif\r
1494 \r
1495 /**\r
1496  * \fn void FAT_CloseFile(tVFS_Node *Node)\r
1497  * \brief Close an open file\r
1498  */\r
1499 void FAT_CloseFile(tVFS_Node *Node)\r
1500 {\r
1501         tFAT_VolInfo    *disk = Node->ImplPtr;\r
1502         if(Node == NULL)        return ;\r
1503         \r
1504         #if SUPPORT_WRITE\r
1505         // Update the node if it's dirty (don't bother if it's marked for\r
1506         // deletion)\r
1507         if( (Node->ImplInt & FAT_FLAG_DIRTY) && !(Node->ImplInt & FAT_FLAG_DELETE) )\r
1508         {\r
1509                 tFAT_VolInfo    buf[16];\r
1510                 tFAT_VolInfo    *ft = &buf[ (Node->ImplInt & 0xFFFF) % 16 ];\r
1511                 \r
1512                 FAT_int_ReadDirSector(Node, (Node->ImplInt & 0xFFFF)/16, buf);\r
1513                 ft->size = Node->Size;\r
1514                 // TODO: update adate, mtime, mdate\r
1515                 FAT_int_WriteDirEntry(Node, Node->ImplInt & 0xFFFF, ft);\r
1516                 \r
1517                 Node->ImplInt &= ~FAT_FLAG_DIRTY;\r
1518         }\r
1519         #endif\r
1520         \r
1521         // TODO: Make this more thread safe somehow, probably by moving the\r
1522         // Inode_UncacheNode higher up and saving the cluster value somewhere\r
1523         if( Node->ReferenceCount == 1 )\r
1524         {               \r
1525                 #if SUPPORT_WRITE\r
1526                 // Delete File\r
1527                 if( Node->ImplInt & FAT_FLAG_DELETE ) {\r
1528                         // Since the node is marked, we only need to remove it's data\r
1529                         Uint32  cluster = Node->Inode & 0xFFFFFFFF;\r
1530                         while( cluster != -1 )\r
1531                                 cluster = FAT_int_FreeCluster(Node->ImplPtr, cluster);\r
1532                 }\r
1533                 #endif\r
1534         }\r
1535         \r
1536         Inode_UncacheNode(disk->inodeHandle, Node->Inode);\r
1537         return ;\r
1538 }\r