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

UCC git Repository :: git.ucc.asn.au