Modules/Filesystems/FAT/fat.c

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