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