Changed tVFS_Node->close on a mount root to be a no-op by convention and added tVFS_D...
[tpg/acess2.git] / Kernel / vfs / fs / fat.c
1 /*\r
2  * Acess2\r
3  * FAT12/16/32 Driver Version (Incl LFN)\r
4  */\r
5 //INCLUDES\r
6 #include <common.h>\r
7 #include <modules.h>\r
8 #include <vfs.h>\r
9 #include "fs_fat.h"\r
10 \r
11 #define DEBUG   0\r
12 #define VERBOSE 1\r
13 \r
14 #if DEBUG\r
15 # define DEBUGS(v...)   Log(v)\r
16 #else\r
17 # define DEBUGS(v...)\r
18 # undef ENTER\r
19 # undef LOG\r
20 # undef LEAVE\r
21 # define ENTER(...)\r
22 # define LOG(...)\r
23 # define LEAVE(...)\r
24 #endif\r
25 \r
26 #define CACHE_FAT       1       //!< Caches the FAT in memory\r
27 #define USE_LFN         1       //!< Enables the use of Long File Names\r
28 \r
29 // === TYPES ===\r
30 #if USE_LFN\r
31 typedef struct s_lfncache {\r
32         Uint    Inode, Impl;\r
33          int    id;\r
34         char    Name[256];\r
35         struct s_lfncache       *Next;\r
36 }       t_lfncache;\r
37 #endif\r
38 \r
39 // === PROTOTYPES ===\r
40  int    FAT_Install(char **Arguments);\r
41 tVFS_Node       *FAT_InitDevice(char *device, char *options);\r
42 void    FAT_Unmount(tVFS_Node *Node);\r
43 Uint64  FAT_Read(tVFS_Node *node, Uint64 offset, Uint64 length, void *buffer);\r
44 Uint64  FAT_Write(tVFS_Node *node, Uint64 offset, Uint64 length, void *buffer);\r
45 char    *FAT_ReadDir(tVFS_Node *dirNode, int dirpos);\r
46 tVFS_Node       *FAT_FindDir(tVFS_Node *dirNode, char *file);\r
47  int    FAT_Mknod(tVFS_Node *Node, char *Name, Uint Flags);\r
48  int    FAT_Relink(tVFS_Node *node, char *OldName, char *NewName);\r
49 void    FAT_CloseFile(tVFS_Node *node);\r
50 \r
51 // === SEMI-GLOBALS ===\r
52 MODULE_DEFINE(0, 0x5B /*v0.90*/, FAT32, FAT_Install, NULL);\r
53 tFAT_VolInfo    gFAT_Disks[8];\r
54  int    giFAT_PartCount = 0;\r
55 #if CACHE_FAT\r
56 Uint32  *fat_cache[8];\r
57 #endif\r
58 #if USE_LFN\r
59 t_lfncache      *fat_lfncache;\r
60 #endif\r
61 tVFS_Driver     gFAT_FSInfo = {\r
62         "fat", 0, FAT_InitDevice, FAT_Unmount, NULL\r
63         };\r
64 \r
65 // === CODE ===\r
66 /**\r
67  * \fn int FAT_Install(char **Arguments)\r
68  * \brief \r
69  */\r
70 int FAT_Install(char **Arguments)\r
71 {\r
72         VFS_AddDriver( &gFAT_FSInfo );\r
73         return 0;\r
74 }\r
75 \r
76 /* 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, CountofClusters;\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                 Warning("FAT_InitDisk - 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                 Warning("FAT_InitDisk - 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         CountofClusters = (TotSec - (bs->resvSectCount + (bs->fatCount * FATSz) + RootDirSectors)) / bs->spc;\r
114         \r
115         if(CountofClusters < 4085)\r
116                 diskInfo->type = FAT12;\r
117         else if(CountofClusters < 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 = CountofClusters * bs->spc / 2;\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                 }\r
133                 if(iSize <= 2*1024) {\r
134                         sSize = "KiB";\r
135                 }\r
136                 else if(iSize <= 2*1024*1024) {\r
137                         sSize = "MiB";\r
138                         iSize >>= 10;\r
139                 }\r
140                 else {\r
141                         sSize = "GiB";\r
142                         iSize >>= 20;\r
143                 }\r
144                 Log("[FAT ] '%s' %s, %i %s", Device, sFatType, iSize, sSize);\r
145         }\r
146         #endif\r
147         \r
148         //Get Name\r
149         //puts(" 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         //puts(diskInfo->name); putch('\n');\r
160         \r
161         //Compute Root directory offset\r
162         if(diskInfo->type == FAT32)\r
163                 diskInfo->rootOffset = bs->spec.fat32.rootClust;\r
164         else\r
165                 diskInfo->rootOffset = (FATSz * bs->fatCount) / bs->spc;\r
166         \r
167         diskInfo->clusterCount = CountofClusters;\r
168         \r
169         diskInfo->firstDataSect = bs->resvSectCount + (bs->fatCount * FATSz) + RootDirSectors;\r
170         \r
171         //Allow for Caching the FAT\r
172         #if CACHE_FAT\r
173         {\r
174         Uint32  Ofs;\r
175         fat_cache[ giFAT_PartCount ] = (Uint32*)malloc(sizeof(Uint32)*CountofClusters);\r
176         if(fat_cache[giFAT_PartCount] == NULL) {\r
177                 Warning("FAT_InitDisk - Heap Exhausted\n");\r
178                 return NULL;\r
179         }\r
180         Ofs = bs->resvSectCount*512;\r
181         if(diskInfo->type == FAT12) {\r
182                 Uint32  val;\r
183                  int    j;\r
184                 char    buf[1536];\r
185                 for(i=0;i<CountofClusters/2;i++) {\r
186                         j = i & 511;    //%512\r
187                         if( j == 0 ) {\r
188                                 VFS_ReadAt(diskInfo->fileHandle, Ofs, 3*512, buf);\r
189                                 Ofs += 3*512;\r
190                         }\r
191                         val = *((int*)(buf+j*3));\r
192                         fat_cache[giFAT_PartCount][i*2] = val & 0xFFF;\r
193                         fat_cache[giFAT_PartCount][i*2+1] = (val>>12) & 0xFFF;\r
194                 }\r
195         }\r
196         if(diskInfo->type == FAT16) {\r
197                 Uint16  buf[256];\r
198                 for(i=0;i<CountofClusters;i++) {\r
199                         if( (i & 255) == 0 ) {\r
200                                 VFS_ReadAt(diskInfo->fileHandle, Ofs, 512, buf);\r
201                                 Ofs += 512;\r
202                         }\r
203                         fat_cache[giFAT_PartCount][i] = buf[i&255];\r
204                 }\r
205         }\r
206         if(diskInfo->type == FAT32) {\r
207                 Uint32  buf[128];\r
208                 for(i=0;i<CountofClusters;i++) {\r
209                         if( (i & 127) == 0 ) {\r
210                                 VFS_ReadAt(diskInfo->fileHandle, Ofs, 512, buf);\r
211                                 Ofs += 512;\r
212                         }\r
213                         fat_cache[giFAT_PartCount][i] = buf[i&127];\r
214                 }\r
215         }\r
216         DEBUGS(" FAT_InitDisk: FAT Fully Cached\n");\r
217         }\r
218         #endif /*CACHE_FAT*/\r
219         \r
220         //Initalise inode cache for FAT\r
221         gFAT_Disks[giFAT_PartCount].inodeHandle = Inode_GetHandle();\r
222         \r
223         #if DEBUG\r
224                 Log(" FAT_InitDisk: Inode Cache handle is %i\n", gFAT_Disks[giFAT_PartCount].inodeHandle);\r
225         #endif\r
226         \r
227         //== VFS Interface\r
228         node = &gFAT_Disks[giFAT_PartCount].rootNode;\r
229         //node->Name = gFAT_Disks[giFAT_PartCount].name;\r
230         node->Inode = diskInfo->rootOffset;\r
231         node->Size = bs->files_in_root; //Unknown - To be set on readdir\r
232         node->ImplInt = giFAT_PartCount;\r
233         \r
234         node->ReferenceCount = 1;\r
235         \r
236         node->UID = 0;  node->GID= 0;\r
237         node->NumACLs = 1;\r
238         node->ACLs = &gVFS_ACL_EveryoneRWX;\r
239         node->Flags = VFS_FFLAG_DIRECTORY;\r
240         node->CTime = node->MTime = node->ATime = now();\r
241         \r
242         node->Read = node->Write = NULL;\r
243         node->ReadDir = FAT_ReadDir;\r
244         node->FindDir = FAT_FindDir;\r
245         node->Relink = FAT_Relink;\r
246         node->MkNod = FAT_Mknod;\r
247         //node->Close = FAT_CloseDevice;\r
248         \r
249         giFAT_PartCount ++;\r
250         return node;\r
251 }\r
252 \r
253 /**\r
254  * \fn void FAT_Unmount(tVFS_Node *Node)\r
255  * \brief Closes a mount and marks it as free\r
256  */\r
257 void FAT_Unmount(tVFS_Node *Node)\r
258 {\r
259         // Close Disk Handle\r
260         VFS_Close( gFAT_Disks[Node->ImplInt].fileHandle );\r
261         // Clear Node Cache\r
262         Inode_ClearCache(gFAT_Disks[Node->ImplInt].inodeHandle);\r
263         // Mark as unused\r
264         gFAT_Disks[Node->ImplInt].fileHandle = -2;\r
265         return;\r
266 }\r
267 \r
268 /**\r
269  * \fn static Uint32 FAT_int_GetFatValue(int handle, Uint32 cluster)\r
270  * \brief Fetches a value from the FAT\r
271  */\r
272 static Uint32 FAT_int_GetFatValue(int handle, Uint32 cluster)\r
273 {\r
274         Uint32  val;\r
275         ENTER("iHandle xCluster", handle, cluster);\r
276         #if CACHE_FAT\r
277         val = fat_cache[handle][cluster];\r
278         #else\r
279         if(gFAT_Disks[handle].type == FAT12) {\r
280                 VFS_ReadAt(gFAT_Disks[handle].fileHandle, 512+(cluster&~1)*3, 3, &val);\r
281                 val = (cluster&1 ? val&0xFFF : val>>12);\r
282         } else if(gFAT_Disks[handle].type == FAT16) {\r
283                 VFS_ReadAt(gFAT_Disks[handle].fileHandle, 512+cluster*2, 2, &val);\r
284         } else {\r
285                 VFS_ReadAt(gFAT_Disks[handle].fileHandle, 512+cluster*4, 4, &val);\r
286         }\r
287         #endif /*CACHE_FAT*/\r
288         LEAVE('x', val);\r
289         return val;\r
290 }\r
291 \r
292 /* Reads a cluster's data\r
293  */\r
294 static void FAT_int_ReadCluster(int Handle, Uint32 Cluster, int Length, void *Buffer)\r
295 {\r
296         #if DEBUG\r
297         ENTER("iHandle xCluster iLength pBuffer", Handle, Cluster, Length, Buffer);\r
298         #endif\r
299         VFS_ReadAt(\r
300                 gFAT_Disks[Handle].fileHandle,\r
301                 (gFAT_Disks[Handle].firstDataSect + (Cluster-2)*gFAT_Disks[Handle].bootsect.spc )\r
302                         * gFAT_Disks[Handle].bootsect.bps,\r
303                 Length,\r
304                 Buffer\r
305                 );\r
306         #if DEBUG\r
307         LEAVE('-');\r
308         #endif\r
309 }\r
310 \r
311 /**\r
312  * \fn Uint64 FAT_Read(tVFS_Node *node, Uint64 offset, Uint64 length, void *buffer)\r
313  * \brief Reads data from a specified file\r
314  */\r
315 Uint64 FAT_Read(tVFS_Node *node, Uint64 offset, Uint64 length, void *buffer)\r
316 {\r
317          int    preSkip, count;\r
318          int    handle = node->ImplInt;\r
319          int    i, cluster, pos;\r
320          int    bpc;\r
321         void    *tmpBuf;\r
322         Uint    eocMarker;\r
323         tFAT_VolInfo    *disk = &gFAT_Disks[node->ImplInt];\r
324         \r
325         ENTER("Xoffset Xlength pbuffer", offset, length, buffer);\r
326         \r
327         // Calculate and Allocate Bytes Per Cluster\r
328         bpc = disk->bootsect.spc * disk->bootsect.bps;\r
329         tmpBuf = (void*) malloc(bpc);\r
330         LOG("malloc'd %i bytes", bpc);\r
331         \r
332         // Cluster is stored in Inode Field\r
333         cluster = node->Inode;\r
334         \r
335         // Get EOC Marker\r
336         if     (disk->type == FAT12)    eocMarker = EOC_FAT12;\r
337         else if(disk->type == FAT16)    eocMarker = EOC_FAT16;\r
338         else if(disk->type == FAT32)    eocMarker = EOC_FAT32;\r
339         else {\r
340                 Log("ERROR: Unsupported FAT Variant.\n");\r
341                 free(tmpBuf);\r
342                 LEAVE('i', 0);\r
343                 return 0;\r
344         }\r
345         \r
346         // Single Cluster including offset\r
347         if(length + offset < bpc)\r
348         {\r
349                 FAT_int_ReadCluster(handle, cluster, bpc, tmpBuf);\r
350                 memcpy( buffer, (void*)( tmpBuf + offset%bpc ), length );\r
351                 free(tmpBuf);\r
352                 LEAVE('i', 1);\r
353                 return 1;\r
354         }\r
355         \r
356         preSkip = offset / bpc;\r
357         \r
358         //Skip previous clusters\r
359         for(i=preSkip;i--;)     {\r
360                 cluster = FAT_int_GetFatValue(handle, cluster);\r
361                 if(cluster == eocMarker) {\r
362                         Warning("FAT_Read - Offset is past end of cluster chain mark");\r
363                 }\r
364         }\r
365         \r
366         // Get Count of Clusters to read\r
367         count = ((offset%bpc+length) / bpc) + 1;\r
368         \r
369         // Get buffer Position after 1st cluster\r
370         pos = bpc - offset%bpc;\r
371         \r
372         // Read 1st Cluster\r
373         FAT_int_ReadCluster(handle, cluster, bpc, tmpBuf);\r
374         memcpy(\r
375                 buffer,\r
376                 (void*)( tmpBuf + (bpc-pos) ),\r
377                 (pos < length ? pos : length)\r
378                 );\r
379         \r
380         if (count == 1) {\r
381                 free(tmpBuf);\r
382                 LEAVE('i', 1);\r
383                 return 1;\r
384         }\r
385         \r
386         cluster = FAT_int_GetFatValue(handle, cluster);\r
387         \r
388         #if DEBUG\r
389         LOG("pos=%i\n", pos);\r
390         LOG("Reading the rest of the clusters\n");\r
391         #endif\r
392         \r
393         \r
394         //Read the rest of the cluster data\r
395         for( i = 1; i < count-1; i++ )\r
396         {\r
397                 FAT_int_ReadCluster(handle, cluster, bpc, tmpBuf);\r
398                 memcpy((void*)(buffer+pos), tmpBuf, bpc);\r
399                 pos += bpc;\r
400                 cluster = FAT_int_GetFatValue(handle, cluster);\r
401                 if(cluster == eocMarker) {\r
402                         Warning("FAT_Read - Read past End of Cluster Chain");\r
403                         free(tmpBuf);\r
404                         LEAVE('i', 0);\r
405                         return 0;\r
406                 }\r
407         }\r
408         \r
409         FAT_int_ReadCluster(handle, cluster, bpc, tmpBuf);\r
410         memcpy((void*)(buffer+pos), tmpBuf, length-pos);\r
411         \r
412         #if DEBUG\r
413         LOG("Free tmpBuf(0x%x) and Return\n", tmpBuf);\r
414         #endif\r
415         \r
416         free(tmpBuf);\r
417         LEAVE('X', length);\r
418         return length;\r
419 }\r
420 \r
421 /**\r
422  * \fn Uint64 FAT_Write(tVFS_Node *node, Uint64 offset, Uint64 length, void *buffer)\r
423  */\r
424 Uint64 FAT_Write(tVFS_Node *node, Uint64 offset, Uint64 length, void *buffer)\r
425 {\r
426         return 0;\r
427 }\r
428 \r
429 /**\r
430  * \fn static void FAT_int_ProperFilename(char *dest, char *src)\r
431  * \brief Converts a FAT directory entry name into a proper filename\r
432  */\r
433 static void FAT_int_ProperFilename(char *dest, char *src)\r
434 {\r
435          int    a, b;\r
436         \r
437         for( a = 0; a < 8; a++) {\r
438                 if(src[a] == ' ')       break;\r
439                 dest[a] = src[a];\r
440         }\r
441         b = a;\r
442         a = 8;\r
443         if(src[8] != ' ')\r
444                 dest[b++] = '.';\r
445         for( ; a < 11; a++, b++)        {\r
446                 if(src[a] == ' ')       break;\r
447                 dest[b] = src[a];\r
448         }\r
449         dest[b] = '\0';\r
450         #if DEBUG\r
451         //Log("FAT_int_ProperFilename: dest='%s'", dest);\r
452         #endif\r
453 }\r
454 \r
455 /**\r
456  * \fn char *FAT_int_CreateName(tVFS_Node *parent, fat_filetable *ft, char *LongFileName)\r
457  * \brief Converts either a LFN or a 8.3 Name into a proper name\r
458  */\r
459 char *FAT_int_CreateName(tVFS_Node *parent, fat_filetable *ft, char *LongFileName)\r
460 {\r
461         char    *ret;\r
462          int    len;\r
463         #if USE_LFN\r
464         if(LongFileName && LongFileName[0] != '\0')\r
465         {       \r
466                 len = strlen(LongFileName);\r
467                 ret = malloc(len+1);\r
468                 strcpy(ret, LongFileName);\r
469         }\r
470         else\r
471         {\r
472         #endif\r
473                 ret = (char*) malloc(13);\r
474                 memset(ret, 13, '\0');\r
475                 FAT_int_ProperFilename(ret, ft->name);\r
476         #if USE_LFN\r
477         }\r
478         #endif\r
479         return ret;\r
480 }\r
481 \r
482 /**\r
483  * \fn tVFS_Node *FAT_int_CreateNode(tVFS_Node *parent, fat_filetable *ft, char *LongFileName)\r
484  * \brief Creates a tVFS_Node structure for a given file entry\r
485  */\r
486 tVFS_Node *FAT_int_CreateNode(tVFS_Node *parent, fat_filetable *ft, char *LongFileName)\r
487 {\r
488         tVFS_Node       node = {0};\r
489         tVFS_Node       *ret;\r
490         \r
491         ENTER("pParent pFT sLongFileName", parent, ft, LongFileName);\r
492         \r
493         // Get Name\r
494         //node.Name = FAT_int_CreateName(parent, ft, LongFileName);\r
495         // Set Other Data\r
496         node.Inode = ft->cluster | (ft->clusterHi<<16);\r
497         node.Size = ft->size;\r
498         node.ImplInt = parent->ImplInt;\r
499         node.UID = 0;   node.GID = 0;\r
500         node.NumACLs = 1;\r
501         node.ACLs = &gVFS_ACL_EveryoneRWX;      // RWXRWXRWX\r
502         \r
503         node.Flags = 0;\r
504         if(ft->attrib & ATTR_DIRECTORY) node.Flags |= VFS_FFLAG_DIRECTORY;\r
505         if(ft->attrib & ATTR_READONLY)  node.Flags |= VFS_FFLAG_READONLY;\r
506         \r
507         node.ATime = timestamp(0,0,0,\r
508                         ((ft->adate&0x1F)-1),   //Days\r
509                         ((ft->adate&0x1E0)-1),          //Months\r
510                         1980+((ft->adate&0xFF00)>>8));  //Years\r
511         \r
512         node.CTime = ft->ctimems * 10;  //Miliseconds\r
513         node.CTime += timestamp(\r
514                         (ft->ctime&0x1F)<<1,    //Seconds\r
515                         ((ft->ctime&0x3F0)>>5), //Minutes\r
516                         ((ft->ctime&0xF800)>>11),       //Hours\r
517                         ((ft->cdate&0x1F)-1),           //Days\r
518                         ((ft->cdate&0x1E0)-1),          //Months\r
519                         1980+((ft->cdate&0xFF00)>>8));  //Years\r
520                         \r
521         node.MTime = timestamp(\r
522                         (ft->mtime&0x1F)<<1,    //Seconds\r
523                         ((ft->mtime&0x3F0)>>5), //Minuites\r
524                         ((ft->mtime&0xF800)>>11),       //Hours\r
525                         ((ft->mdate&0x1F)-1),           //Days\r
526                         ((ft->mdate&0x1E0)-1),          //Months\r
527                         1980+((ft->mdate&0xFF00)>>8));  //Years\r
528         \r
529         if(node.Flags & VFS_FFLAG_DIRECTORY) {\r
530                 node.ReadDir = FAT_ReadDir;\r
531                 node.FindDir = FAT_FindDir;\r
532                 node.MkNod = FAT_Mknod;\r
533         } else {\r
534                 node.Read = FAT_Read;\r
535                 node.Write = FAT_Write;\r
536         }\r
537         node.Close = FAT_CloseFile;\r
538         node.Relink = FAT_Relink;\r
539         \r
540         ret = Inode_CacheNode(gFAT_Disks[parent->ImplInt].inodeHandle, &node);\r
541         LEAVE('p', ret);\r
542         return ret;\r
543 }\r
544 \r
545 #if USE_LFN\r
546 /**\r
547  \fn char *FAT_int_GetLFN(tVFS_Node *node)\r
548  \brief Return pointer to LFN cache entry\r
549  */\r
550 char *FAT_int_GetLFN(tVFS_Node *node)\r
551 {\r
552         t_lfncache      *tmp;\r
553         tmp = fat_lfncache;\r
554         while(tmp)\r
555         {\r
556                 if(tmp->Inode == node->Inode && tmp->Impl == node->ImplInt)\r
557                         return tmp->Name;\r
558                 tmp = tmp->Next;\r
559         }\r
560         tmp = malloc(sizeof(t_lfncache));\r
561         tmp->Inode = node->Inode;\r
562         tmp->Impl = node->ImplInt;\r
563         memset(tmp->Name, 0, 256);\r
564         \r
565         tmp->Next = fat_lfncache;\r
566         fat_lfncache = tmp;\r
567         \r
568         return tmp->Name;\r
569 }\r
570 \r
571 /**\r
572  \fn void FAT_int_DelLFN(tVFS_Node *node)\r
573  \brief Delete a LFN cache entry\r
574 */\r
575 void FAT_int_DelLFN(tVFS_Node *node)\r
576 {\r
577         t_lfncache      *tmp;\r
578         \r
579         if(!fat_lfncache)       return;\r
580         \r
581         if(!fat_lfncache->Next)\r
582         {\r
583                 tmp = fat_lfncache;\r
584                 fat_lfncache = tmp->Next;\r
585                 free(tmp);\r
586                 return;\r
587         }\r
588         tmp = fat_lfncache;\r
589         while(tmp && tmp->Next)\r
590         {\r
591                 if(tmp->Inode == node->Inode && tmp->Impl == node->ImplInt)\r
592                 {\r
593                         free(tmp->Next);\r
594                         tmp->Next = tmp->Next->Next;\r
595                         return;\r
596                 }\r
597                 tmp = tmp->Next;\r
598         }\r
599 }\r
600 #endif\r
601 \r
602 /**\r
603  \fn char *FAT_ReadDir(tVFS_Node *dirNode, int dirPos)\r
604  \param dirNode Node structure of directory\r
605  \param dirPos  Directory position\r
606 **/\r
607 char *FAT_ReadDir(tVFS_Node *dirNode, int dirpos)\r
608 {\r
609         fat_filetable   fileinfo[16];   //Sizeof=32, 16 per sector\r
610          int    a=0;\r
611         tFAT_VolInfo    *disk = &gFAT_Disks[dirNode->ImplInt&7];\r
612         Uint32  cluster, offset;\r
613          int    preSkip;\r
614         char    *ret;\r
615         #if USE_LFN\r
616         char    *lfn = NULL;\r
617         #endif\r
618         \r
619         ENTER("pDirNode iDirPos", dirNode, dirpos);\r
620         \r
621         // Get Byte Offset and skip\r
622         offset = dirpos * sizeof(fat_filetable);\r
623         preSkip = (offset >> 9) / disk->bootsect.spc;   // >>9 == /512\r
624         cluster = dirNode->Inode;       // Cluster ID\r
625         \r
626         // Do Cluster Skip\r
627         // - Pre FAT32 had a reserved area for the root.\r
628         if( !(disk->type != FAT32 && cluster == disk->rootOffset) )\r
629         {\r
630                 //Skip previous clusters\r
631                 for(a=preSkip;a--;)     {\r
632                         cluster = FAT_int_GetFatValue(dirNode->ImplInt, cluster);\r
633                 }\r
634         }\r
635         \r
636         // Check for end of cluster chain\r
637         if((disk->type == FAT12 && cluster == EOC_FAT12)\r
638         || (disk->type == FAT16 && cluster == EOC_FAT16)\r
639         || (disk->type == FAT32 && cluster == EOC_FAT32))\r
640                 return NULL;\r
641         \r
642         // Bounds Checking (Used to spot heap overflows)\r
643         if(cluster > disk->clusterCount + 2)\r
644         {\r
645                 Warning("FAT_ReadDir - Cluster ID is over cluster count (0x%x>0x%x)",\r
646                         cluster, disk->clusterCount+2);\r
647                 LEAVE('n');\r
648                 return NULL;\r
649         }\r
650         \r
651         LOG("cluster=0x%x, dirpos=%i\n", cluster, dirpos);\r
652         \r
653         // Compute Offsets\r
654         // - Pre FAT32 cluster base (in sectors)\r
655         if( cluster == disk->rootOffset && disk->type != FAT32 )\r
656                 offset = disk->bootsect.resvSectCount + cluster*disk->bootsect.spc;\r
657         else\r
658         {       // FAT32 cluster base (in sectors)\r
659                 offset = disk->firstDataSect;\r
660                 offset += (cluster - 2) * disk->bootsect.spc;\r
661         }\r
662         // Sector in cluster\r
663         if(disk->bootsect.spc == 1)\r
664                 offset += (dirpos / 16);\r
665         else\r
666                 offset += (dirpos / 16) % disk->bootsect.spc;\r
667         // Offset in sector\r
668         a = dirpos & 0xF;\r
669 \r
670         LOG("offset=%i, a=%i\n", (Uint)offset, a);\r
671         \r
672         // Read Sector\r
673         VFS_ReadAt(disk->fileHandle, offset*512, 512, fileinfo);        // Read Dir Data\r
674         \r
675         LOG("name[0] = 0x%x\n", (Uint8)fileinfo[a].name[0]);\r
676         //Check if this is the last entry\r
677         if(fileinfo[a].name[0] == '\0') {\r
678                 dirNode->Size = dirpos;\r
679                 LOG("End of list\n");\r
680                 LEAVE('n');\r
681                 return NULL;    // break\r
682         }\r
683         \r
684         // Check for empty entry\r
685         if((Uint8)fileinfo[a].name[0] == 0xE5) {\r
686                 LOG("Empty Entry\n");\r
687                 LEAVE('p', VFS_SKIP);\r
688                 return VFS_SKIP;        // Skip\r
689         }\r
690         \r
691         #if USE_LFN\r
692         // Get Long File Name Cache\r
693         lfn = FAT_int_GetLFN(dirNode);\r
694         if(fileinfo[a].attrib == ATTR_LFN)\r
695         {\r
696                 fat_longfilename        *lfnInfo;\r
697                  int    len;\r
698                 \r
699                 lfnInfo = (fat_longfilename *) &fileinfo[a];\r
700                 if(lfnInfo->id & 0x40)  memset(lfn, 0, 256);\r
701                 // Get the current length\r
702                 len = strlen(lfn);\r
703                 \r
704                 // Sanity Check (FAT implementations do not allow >255 bytes)\r
705                 if(len + 13 > 255)      return VFS_SKIP;\r
706                 // Rebase all bytes\r
707                 for(a=len+1;a--;)       lfn[a+13] = lfn[a];\r
708                 \r
709                 // Append new bytes\r
710                 lfn[ 0] = lfnInfo->name1[0];    lfn[ 1] = lfnInfo->name1[1];\r
711                 lfn[ 2] = lfnInfo->name1[2];    lfn[ 3] = lfnInfo->name1[3];\r
712                 lfn[ 4] = lfnInfo->name1[4];    \r
713                 lfn[ 5] = lfnInfo->name2[0];    lfn[ 6] = lfnInfo->name2[1];\r
714                 lfn[ 7] = lfnInfo->name2[2];    lfn[ 8] = lfnInfo->name2[3];\r
715                 lfn[ 9] = lfnInfo->name2[4];    lfn[10] = lfnInfo->name2[5];\r
716                 lfn[11] = lfnInfo->name3[0];    lfn[12] = lfnInfo->name3[1];\r
717                 LEAVE('p', VFS_SKIP);\r
718                 return VFS_SKIP;\r
719         }\r
720         #endif\r
721         \r
722         //Check if it is a volume entry\r
723         if(fileinfo[a].attrib & 0x08) {\r
724                 LEAVE('p', VFS_SKIP);\r
725                 return VFS_SKIP;\r
726         }\r
727         // Ignore . and ..\r
728         if(fileinfo[a].name[0] == '.') {\r
729                 LEAVE('p', VFS_SKIP);\r
730                 return VFS_SKIP;\r
731         }       \r
732         \r
733         LOG("name='%c%c%c%c%c%c%c%c.%c%c%c'\n",\r
734                 fileinfo[a].name[0], fileinfo[a].name[1], fileinfo[a].name[2], fileinfo[a].name[3],\r
735                 fileinfo[a].name[4], fileinfo[a].name[5], fileinfo[a].name[6], fileinfo[a].name[7],\r
736                 fileinfo[a].name[8], fileinfo[a].name[9], fileinfo[a].name[10] );\r
737         \r
738         #if USE_LFN\r
739         //node = FAT_int_CreateNode(dirNode, &fileinfo[a], lfn);\r
740         ret = FAT_int_CreateName(dirNode, &fileinfo[a], lfn);\r
741         lfn[0] = '\0';\r
742         #else\r
743         //node = FAT_int_CreateNode(dirNode, &fileinfo[a], NULL);\r
744         ret = FAT_int_CreateName(dirNode, &fileinfo[a], NULL);\r
745         #endif\r
746         \r
747         LEAVE('s', ret);\r
748         return ret;\r
749 }\r
750 \r
751 /**\r
752  * \fn tVFS_Node *FAT_FindDir(tVFS_Node *node, char *name)\r
753  * \brief Finds an entry in the current directory\r
754  */\r
755 tVFS_Node *FAT_FindDir(tVFS_Node *node, char *name)\r
756 {\r
757         fat_filetable   fileinfo[16];\r
758         char    tmpName[11];\r
759         #if USE_LFN\r
760         fat_longfilename        *lfnInfo;\r
761         char    *lfn = NULL;\r
762          int    lfnPos=255, lfnId = -1;\r
763         #endif\r
764          int    i=0;\r
765         tVFS_Node       *tmpNode;\r
766         Uint64  diskOffset;\r
767         tFAT_VolInfo    *disk = &gFAT_Disks[node->ImplInt];\r
768         Uint32  dirCluster;\r
769         Uint32  cluster;\r
770         \r
771         ENTER("pnode sname", node, name);\r
772         \r
773         // Fast Returns\r
774         if(!name)       return NULL;\r
775         if(name[0] == '\0')     return NULL;\r
776         \r
777         #if USE_LFN\r
778         lfn = FAT_int_GetLFN(node);\r
779         #endif\r
780         \r
781         dirCluster = node->Inode;\r
782         // Seek to Directory\r
783         if( dirCluster == disk->rootOffset && disk->type != FAT32 )\r
784                 diskOffset = (disk->bootsect.resvSectCount+dirCluster*disk->bootsect.spc) << 9;\r
785         else\r
786                 diskOffset = (disk->firstDataSect+(dirCluster-2)*disk->bootsect.spc) << 9;\r
787         \r
788         for(;;i++)\r
789         {\r
790                 // Load sector\r
791                 if((i & 0xF) == 0) {\r
792                         VFS_ReadAt(disk->fileHandle, diskOffset, 512, fileinfo);\r
793                         diskOffset += 512;\r
794                 }\r
795                 \r
796                 //Check if the files are free\r
797                 if(fileinfo[i&0xF].name[0] == '\0')     break;          //Free and last\r
798                 if(fileinfo[i&0xF].name[0] == '\xE5')   goto loadCluster;       //Free\r
799                 \r
800                 \r
801                 #if USE_LFN\r
802                 // Long File Name Entry\r
803                 if(fileinfo[i&0xF].attrib == ATTR_LFN)\r
804                 {\r
805                         lfnInfo = (fat_longfilename *) &fileinfo[i&0xF];\r
806                         if(lfnInfo->id & 0x40) {\r
807                                 memset(lfn, 0, 256);\r
808                                 lfnPos = 255;\r
809                         }\r
810                         lfn[lfnPos--] = lfnInfo->name3[1];      lfn[lfnPos--] = lfnInfo->name3[0];\r
811                         lfn[lfnPos--] = lfnInfo->name2[5];      lfn[lfnPos--] = lfnInfo->name2[4];\r
812                         lfn[lfnPos--] = lfnInfo->name2[3];      lfn[lfnPos--] = lfnInfo->name2[2];\r
813                         lfn[lfnPos--] = lfnInfo->name2[1];      lfn[lfnPos--] = lfnInfo->name2[0];\r
814                         lfn[lfnPos--] = lfnInfo->name1[4];      lfn[lfnPos--] = lfnInfo->name1[3];\r
815                         lfn[lfnPos--] = lfnInfo->name1[2];      lfn[lfnPos--] = lfnInfo->name1[1];\r
816                         lfn[lfnPos--] = lfnInfo->name1[0];\r
817                         if((lfnInfo->id&0x3F) == 1)\r
818                         {\r
819                                 memcpy(lfn, lfn+lfnPos+1, 256-lfnPos);\r
820                                 lfnId = i+1;\r
821                         }\r
822                 }\r
823                 else\r
824                 {\r
825                         // Remove LFN if it does not apply\r
826                         if(lfnId != i)  lfn[0] = '\0';\r
827                 #endif\r
828                         // Get Real Filename\r
829                         FAT_int_ProperFilename(tmpName, fileinfo[i&0xF].name);\r
830                 \r
831                         LOG("tmpName = '%s'\n", tmpName);\r
832                 \r
833                         //Only Long name is case sensitive, 8.3 is not\r
834                         #if USE_LFN\r
835                         if(strucmp(tmpName, name) == 0 || strcmp(lfn, name) == 0) {\r
836                         #else\r
837                         if(strucmp(tmpName, name) == 0) {\r
838                         #endif\r
839                                 cluster = fileinfo[i&0xF].cluster | (fileinfo[i&0xF].clusterHi << 16);\r
840                                 tmpNode = Inode_GetCache(disk->inodeHandle, cluster);\r
841                                 if(tmpNode == NULL)     // Node is not cached\r
842                                 {\r
843                                         #if USE_LFN\r
844                                         tmpNode = FAT_int_CreateNode(node, &fileinfo[i&0xF], lfn);\r
845                                         #else\r
846                                         tmpNode = FAT_int_CreateNode(node, &fileinfo[i&0xF], NULL);\r
847                                         #endif\r
848                                 }\r
849                                 #if USE_LFN\r
850                                 lfn[0] = '\0';\r
851                                 #endif\r
852                                 LEAVE('p', tmpNode);\r
853                                 return tmpNode;\r
854                         }\r
855                 #if USE_LFN\r
856                 }\r
857                 #endif\r
858                 \r
859         loadCluster:\r
860                 //Load Next cluster?\r
861                 if( ((i+1) >> 4) % disk->bootsect.spc == 0 && ((i+1) & 0xF) == 0)\r
862                 {\r
863                         if( dirCluster == disk->rootOffset && disk->type != FAT32 )\r
864                                 continue;\r
865                         dirCluster = FAT_int_GetFatValue(node->ImplInt, dirCluster);\r
866                         diskOffset = (disk->firstDataSect+(dirCluster-2)*disk->bootsect.spc)*512;\r
867                 }\r
868         }\r
869         \r
870         LEAVE('n');\r
871         return NULL;\r
872 }\r
873 \r
874 /**\r
875  * \fn int FAT_Mknod(tVFS_Node *Node, char *Name, Uint Flags)\r
876  * \brief Create a new node\r
877  */\r
878 int FAT_Mknod(tVFS_Node *Node, char *Name, Uint Flags)\r
879 {\r
880         return 0;\r
881 }\r
882 \r
883 /**\r
884  * \fn int FAT_Relink(tVFS_Node *Node, char *OldName, char *NewName)\r
885  * \brief Rename / Delete a file\r
886  */\r
887 int FAT_Relink(tVFS_Node *Node, char *OldName, char *NewName)\r
888 {\r
889         return 0;\r
890 }\r
891 \r
892 /**\r
893  * \fn void FAT_CloseFile(tVFS_Node *Node)\r
894  * \brief Close an open file\r
895  */\r
896 void FAT_CloseFile(tVFS_Node *Node)\r
897 {\r
898         if(Node == NULL)        return ;\r
899         \r
900         Inode_UncacheNode(gFAT_Disks[Node->ImplInt].inodeHandle, Node->Inode);\r
901         #if USE_LFN\r
902         if(     !Inode_GetCache(gFAT_Disks[Node->ImplInt].inodeHandle, Node->Inode)\r
903         &&      Node->Flags & VFS_FFLAG_DIRECTORY)\r
904                 FAT_int_DelLFN(Node);\r
905         else    // Get Cache references the node, so dereference it\r
906                 Inode_UncacheNode(gFAT_Disks[Node->ImplInt].inodeHandle, Node->Inode);\r
907         #endif\r
908         return ;\r
909 }\r
910 \r
911 /**\r
912  * \fn void fat_install()\r
913  * \brief Add the FAT Filesystem to the VFS\r
914  */\r
915 void fat_install()\r
916 {\r
917         VFS_AddDriver( &gFAT_FSInfo );\r
918 }\r

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