source: soft/giet_vm/giet_fat32/fat32.c @ 597

Last change on this file since 597 was 597, checked in by guerin, 9 years ago

fat32: fix warnings

This also fixes a bug where the first directory entry was skipped
because lfn wasn't initialized.

  • Property svn:executable set to *
File size: 158.8 KB
RevLine 
[258]1//////////////////////////////////////////////////////////////////////////////////
[587]2// Date     : 01/06/2015
3// Authors  : Alain Greiner
[258]4// Copyright (c) UPMC-LIP6
5//////////////////////////////////////////////////////////////////////////////////
[569]6// The fat32.h and fat32.c files define a library of access functions
[587]7// to a FAT32 disk on a block device. It is intended to be used by both
8// the boot code and the kernel code.
[258]9//////////////////////////////////////////////////////////////////////////////////
10// Implementation notes:
11// 1. the "lba" (Logical Block Address) is the physical sector index on
12//    the block device. The physical sector size is supposed to be 512 bytes.
13// 2. the "cluster" variable is actually a cluster index. A cluster contains
[587]14//    8 sectors (4K bytes) and the cluster index is a 32 bits word.
15// 3. Each file or directory referenced by the software is represented
16//    by an "inode". The set of "inodes" is organised as a tree, that is
17//    a sub-tree of the complete file system existing on the block device.
18// 4. A given file can be referenced by several software tasks, and each task
19//    will use a private handler, called a "file descriptor", allocated by the OS
20//    when the task open the file, that is organised as an indexed array.
21// 5. This FAT32 library implements (N+1) caches : one private "File_ Cache"
22//    for each referenced file or directory, and a specific "Fat_Cache" for
23//    the FAT itself. Each cache contain a variable number of clusters that are
24//    dynamically allocated when they are accessed, and organised as a 64-Tree.
[258]25//////////////////////////////////////////////////////////////////////////////////
[587]26// General Debug Policy:
27// The global variable GIET_DEBUG_FAT is defined in the giet_config.h file.
28// The debug is activated if (proctime > GIET_DEBUG_FAT) && (GIET_DEBUG_FAT != 0)
29// The GIET_DEBUG_FAT bit 0 defines the level of debug:
30//    if   (GIET_DEBUG_FAT & 0x1)    => detailed debug
31//    else                           => external functions only
32//////////////////////////////////////////////////////////////////////////////////
[258]33
34#include <giet_config.h>
[530]35#include <hard_config.h>
[258]36#include <fat32.h>
[530]37#include <utils.h>
38#include <vmem.h>
[587]39#include <kernel_malloc.h>
[530]40#include <bdv_driver.h>
41#include <hba_driver.h>
42#include <sdc_driver.h>
43#include <rdk_driver.h>
44#include <mmc_driver.h>
[458]45#include <tty0.h>
[258]46
47//////////////////////////////////////////////////////////////////////////////////
[587]48//               Global variables
[258]49//////////////////////////////////////////////////////////////////////////////////
50
[587]51// Fat-Descriptor
52__attribute__((section(".kdata")))
53fat_desc_t _fat __attribute__((aligned(64))); 
[258]54
[587]55// buffer used by boot code as a simple cache when scanning FAT
56__attribute__((section(".kdata")))
57unsigned char  _fat_buffer_fat[4096] __attribute__((aligned(64)));
[530]58
[587]59// buffer used by boot code as a simple cache when scanning a directory in DATA region
60__attribute__((section(".kdata")))
61unsigned char  _fat_buffer_data[4096] __attribute__((aligned(64)));
[530]62
[587]63// lba of cluster in fat_buffer_fat
64__attribute__((section(".kdata")))
65unsigned int   _fat_buffer_fat_lba;
66
67// lba of cluster in fat_buffer_data
68__attribute__((section(".kdata")))
69unsigned int   _fat_buffer_data_lba;
70
71//////////////////////////////////////////////////////////////////////////////////
72//////////////////////////////////////////////////////////////////////////////////
73//                  Static functions declaration
74//////////////////////////////////////////////////////////////////////////////////
75//////////////////////////////////////////////////////////////////////////////////
76
77
78///////////////////////////////////////////////////////////////////////////////////
79// This debug function displays the content of a 512 bytes buffer "buf",
80// with an identifier defined by the "string" and "block_id" arguments.
81///////////////////////////////////////////////////////////////////////////////////
82
83#if GIET_DEBUG_FAT
84static void _display_one_block( unsigned char* buf,
85                                char*          string,
86                                unsigned int   block_id );
[530]87#endif
88
[587]89//////////////////////////////////////////////////////////////////////////////////
90// This debug function displays the FAT descriptor.
91//////////////////////////////////////////////////////////////////////////////////
[530]92
[587]93#if GIET_DEBUG_FAT
94static void _display_fat_descriptor();
[551]95#endif
[530]96
[587]97/////////////////////////////////////////////////////////////////////////////////
98// This debug function displays the sequence of clusters allocated to a
99// file (or directory) identified by the "inode" argument.
100/////////////////////////////////////////////////////////////////////////////////
[530]101
[587]102#if GIET_DEBUG_FAT
103static void _display_clusters_list( fat_inode_t* inode );
[530]104#endif
105
[587]106/////////////////////////////////////////////////////////////////////////////////
107// The following function transfers one or several blocks between the device
108// and a memory buffer identified by a virtual address.
109// It computes the memory buffer physical address, and calls the proper
110// IOC driver depending on the subtype (BDV / HBA / SDC / SPI / RDK).
111// The use_irq argument allows to activate the descheduling mode,
112// if it supported by the IOC driver subtype
113// It returns O  in case of success.
114// It returns -1 in case of error.
115/////////////////////////////////////////////////////////////////////////////////
[530]116
[587]117static int _fat_ioc_access( unsigned int use_irq,
118                            unsigned int to_mem,
119                            unsigned int lba,
120                            unsigned int buf_vaddr,
121                            unsigned int count );
[530]122
[258]123//////////////////////////////////////////////////////////////////////////////////
[587]124// The following function returns in the "desc" argument a pointer on a buffer
125// descriptor contained in a File_Cache, or in the Fat_Cache.
126// The searched buffer is idenfified by the "inode" and "cluster_id" arguments.
127// If the "inode" pointer is not NULL, the searched cache is a File-Cache.
128// If the "inode" pointer is NULL, the searched cache is the Fat-Cache,
129// The "cluster_id" argument is the buffer index in the file (or in the FAT).
130// In case of miss, it allocate a 4 Kbytes buffer and a cluster descriptor
131// from the local kernel heap, and calls the _fat_ioc_access() function to load
132// the missing cluster from the block device.
133// It returns O  in case of success.
134// It returns 1 in case of error.
[258]135//////////////////////////////////////////////////////////////////////////////////
[587]136
137static unsigned int _get_buffer_from_cache( fat_inode_t*        inode,
138                                            unsigned int        cluster_id,
139                                            fat_cache_desc_t**  desc );
140
141////////////////////////////////////////////////////////////////////////////////
142// This function extract a (partial) name from a LFN directory entry.
143////////////////////////////////////////////////////////////////////////////////
144
145static void _get_name_from_long( unsigned char* buffer, 
146                                 char*          name );
147
148////////////////////////////////////////////////////////////////////////////////
149// The following function extract a name from a NORMAL directory entry.
150////////////////////////////////////////////////////////////////////////////////
151
152static void _get_name_from_short( unsigned char* buffer,
153                                  char*          name );
154
155//////////////////////////////////////////////////////////////////////////////////
156// This function returns the number of levels of a File-Cache (or Fat-Cache)
157// from the size of the file (or FAT).
158//////////////////////////////////////////////////////////////////////////////////
159
160static inline unsigned int _get_levels_from_size( unsigned int size );
161
162///////////////////////////////////////////////////////////////////////////////////
163// The following function analyses the "pathname" argument, from the character
164// defined by the "nb_read" argument.
165// It copies the found name in the "name" buffer (without '/'),
166// and updates the "nb_read" argument.
167// It returns 0 if success.
168// It returns 1 if one name length > NAME_MAX_SIZE characters
169///////////////////////////////////////////////////////////////////////////////////
170
171static unsigned int _get_name_from_path( char*          pathname,
172                                         char*          name,
173                                         unsigned int*  nb_read );
174
175////////////////////////////////////////////////////////////////////////////////
176// The following function scan the "pathname" argument, and copies in the
177// "name" buffer the last name in path (leaf name).
178// It returns 0 if success.
179// It returns 1 if one name length > NAME_MAX_SIZE characters
180////////////////////////////////////////////////////////////////////////////////
181static unsigned int _get_last_name( char*   pathname,
182                                    char*   name );
183
184//////////////////////////////////////////////////////////////////////////////////
185// The following function access the Fat-Cache and returns in the "value"
186// argument the content of the FAT slot identified by the "cluster" argument.
187// It loads the missing cluster from block device into cache in case of miss.
188// It returns 0 if success.
189// It returns 1 if error.
190//////////////////////////////////////////////////////////////////////////////////
191
192static unsigned int _get_fat_entry( unsigned int  cluster,
193                                    unsigned int* value );
194
195//////////////////////////////////////////////////////////////////////////////////
196// The following function writes a new "value" in the Fat-Cache, in the slot
197// identified by the "cluster" argument. 
198// It loads the missing cluster from block device into cache in case of miss.
199// It returns 0 if success,
200// It returns 1 if error.
201//////////////////////////////////////////////////////////////////////////////////
202
203static unsigned int _set_fat_entry( unsigned int  cluster,
204                                    unsigned int  value );
205
206//////////////////////////////////////////////////////////////////////////////////
207// The following function introduces the inode identified by the "child" argument,
208// as a new child of the "parent" inode in the Inode-Tree.
209// All checking are supposed to be done by the caller.
210// Nor the File-Cache, neither the block device are modified.
211//////////////////////////////////////////////////////////////////////////////////
212
213static void _add_inode_in_tree( fat_inode_t*  child,
214                                fat_inode_t*  parent );
215
216//////////////////////////////////////////////////////////////////////////////////
217// The following function removes one inode identified by the "inode" argument
218// from the Inode-Tree. All checking are supposed to be done by the caller.
219// Nor the File-Cache, neither the block device are modified.
220//////////////////////////////////////////////////////////////////////////////////
221
222static void _remove_inode_from_tree( fat_inode_t* inode );
223
224//////////////////////////////////////////////////////////////////////////////////
225// This recursive function scan one File-Cache (or Fat-Cache) from root to leaves,
226// to writes all dirty clusters to block device, and reset the dirty bits.
227// The cache is identified by the "root" an "levels" arguments.
228// The "string" argument is only used for debug : inode name or Fat.
229// It returns 0 if success.
230// It returns 1 if error.
231//////////////////////////////////////////////////////////////////////////////////
232
233static unsigned int _update_device_from_cache( unsigned int      levels,
234                                               fat_cache_node_t* root,
235                                               char*             string );
236
237//////////////////////////////////////////////////////////////////////////////////
238// The following function access directly the FS_INFO block on the block device,
239// to update the "first_free_cluster" and "free_clusters_number" values,
240// using only the Fat-Descriptor single block buffer.
241// It return 0 in case of success.
242// It return 1 in case of error.
243//////////////////////////////////////////////////////////////////////////////////
244
245static unsigned int _update_fs_info();
246
247//////////////////////////////////////////////////////////////////////////////
248// The following function read a data field (from one to four bytes)
249// from an unsigned char[] buffer, taking endianness into account.
250// The analysed field is defined by the "offset" and "size" arguments.
251//////////////////////////////////////////////////////////////////////////////
252
253static unsigned int _read_entry( unsigned int    offset,
254                                 unsigned int    size,
255                                 unsigned char*  buffer,
256                                 unsigned int    little_indian );
257
258//////////////////////////////////////////////////////////////////////////////////
259// The following function returns the lba of first sector in DATA region
260// from the cluster index. The cluster index must be larger than 2.
261//////////////////////////////////////////////////////////////////////////////////
262
263static unsigned int _cluster_to_lba( unsigned int cluster );
264
265//////////////////////////////////////////////////////////////////////////////////
266// The following function returns in the "nb_entries" argument the number of files
267// (or directories) contained in a directory identidied by the "inode " pointer.
268// It returns  0 if success.
269// It returns  1 if error.
270//////////////////////////////////////////////////////////////////////////////////
271
272static unsigned int _get_nb_entries( fat_inode_t*   inode,
273                                     unsigned int*  nb_entries );
274
275//////////////////////////////////////////////////////////////////////////////////
276// The following function search in the directory identified by the "parent"
277// inode pointer a child (file or directory) identified by its "name".
278// It returns in the "inode" argument the searched child inode pointer.
279// If the searched name is not found in the Inode-Tree, the function access
280// the "file_cache" associated to the parent directory.
281// If the child exist on block device, the Inode-Tree is updated, and
282// a success code is returned.
283// If the file/dir does not exist on block device, a error code is returned.
284// It returns 0 if inode found.
285// It returns 1 if inode not found.
286// It returns 2 if error in cache access.
287//////////////////////////////////////////////////////////////////////////////////
288
289static unsigned int _get_child_from_parent( fat_inode_t*   parent,
290                                            char*          name,
291                                            fat_inode_t**  inode ); 
292
293/////////////////////////////////////////////////////////////////////////////////
294// For a file (or a directory) identified by the "pathname" argument, the
295// following function returns in the "inode" argument the inode pointer
296// associated to the searched file (or directory), with code (0).
297// If the searched file (or directory) is not found, but the parent directory
298// is found, it returns in the "inode" argument the pointer on the parent inode,
299// with code (1).  Finally, code (2) and code (3) are error codes.
300// Both the Inode-Tree and the involved Cache-Files are updated from the block
301// device in case of miss on one inode during the search in path.
302// Neither the Fat-Cache, nor the block device are updated.
303// It returns 0 if searched inode found
304// It returns 1 if searched inode not found but parent directory found
305// It returns 2 if searched inode not found and parent directory not found
306// It returns 3 if one name too long
307/////////////////////////////////////////////////////////////////////////////////
308
309static unsigned int _get_inode_from_path( char*          pathname,
310                                          fat_inode_t**  inode );
311
312//////////////////////////////////////////////////////////////////////////////////
313// This function computes the length and the number of LFN entries required
314// to store a node name in the "length" and "nb_lfn" arguments.
315// Short name (less than 13 characters) require 1 LFN entry.
316// Medium names (from 14 to 26 characters require 2 LFN entries.
317// Large names (up to 31 characters) require 3 LFN entries.
318// It returns 0 if success.
319// It returns 1 if length larger than 31 characters.
320//////////////////////////////////////////////////////////////////////////////////
321
322static unsigned int _check_name_length( char* name,
323                                        unsigned int* length,
324                                        unsigned int* nb_lfn );
325
326//////////////////////////////////////////////////////////////////////////////////
327// For a node identified by the "inode" argument, this function updates the
328// "size" and "cluster" values in the entry of the parent directory File-Cache.
329// It set the dirty bit in the modified buffer of the parent directory File-Cache.
330//////////////////////////////////////////////////////////////////////////////////
331
332static unsigned int _update_dir_entry( fat_inode_t*  inode );
333
334//////////////////////////////////////////////////////////////////////////////////
335// The following function add new "child" in Cache-File of "parent" directory.
336// It access the File_Cache associated to the parent directory, and scan the
337// clusters allocated to this directory to find the NO_MORE entry.
338// This entry will be the first modified entry in the directory.
339// Regarding the name storage, it uses LFN entries for all names.
340// Therefore, it writes 1, 2, or 3 LFN entries (depending on the child name
341// actual length, it writes one NORMAL entry, and writes the new NOMORE entry.
342// It updates the dentry field in the child inode.
343// It set the dirty bit for all modified File-Cache buffers.
344// The block device is not modified by this function.
345//////////////////////////////////////////////////////////////////////////////////
346
347static unsigned int _add_dir_entry( fat_inode_t* child,
348                                    fat_inode_t* parent );
349
350//////////////////////////////////////////////////////////////////////////////////
351// The following function invalidates all dir_entries associated to the "inode"
352// argument from its parent directory.
353// It set the dirty bit for all modified buffers in parent directory Cache-File.
354// The inode itself is not modified by this function.
355// The block device is not modified by this function.
356//////////////////////////////////////////////////////////////////////////////////
357
358static unsigned int _remove_dir_entry( fat_inode_t*  inode );
359
360//////////////////////////////////////////////////////////////////////////////////
361// The following function add the special entries "." and ".." in the File-Cache
362// of the directory identified by the "child" argument.
363// The parent directory is defined by the "parent" argument.
364// The child directory File-Cache is supposed to be empty.
365// We use two NORMAL entries for these "." and ".." entries.
366// The block device is not modified by this function.
367//////////////////////////////////////////////////////////////////////////////////
368
369static void _add_special_directories( fat_inode_t* child,
370                                      fat_inode_t* parent );
371
372//////////////////////////////////////////////////////////////////////////////////
373// The following function releases all clusters allocated to a file or directory,
374// from the cluster index defined by the "cluster" argument, until the end
375// of the FAT linked list.
376// It calls _get_fat_entry() and _set_fat_entry() functions to scan the FAT,
377// and to update the clusters chaining.
378// The FAT region on block device is updated.
379// It returns 0 if success.
380// It returns 1 if error.
381//////////////////////////////////////////////////////////////////////////////////
382
383static unsigned int _clusters_release( unsigned int cluster );
384
385//////////////////////////////////////////////////////////////////////////////////
386// This function allocate "nb_clusters_more" new clusters to a file (or directory)
387// identified by the "inode" pointer. It allocates also the associated buffers
388// and buffer descriptors in the Cache-File.
389// It calls _get_fat_entry() and _set_fat_entry() functions to update the
390// clusters chaining in the Cache-Fat. The FAT region on block device is updated.
391// It returns 0 if success.
392// It returns 1 if error.
393//////////////////////////////////////////////////////////////////////////////////
394
395static unsigned int _clusters_allocate( fat_inode_t* inode, 
396                                        unsigned int nb_clusters_current,
397                                        unsigned int nb_clusters_more );
398
399//////////////////////////////////////////////////////////////////////////////////
400// This recursive function scan one File-Cache (or Fat-Cache) from root to leaves.
401// The cache 64-Tree infrastructure is kept, but all memory allocated for 4 Kbytes
402// buffers, and for buffer descriptors (in leaves) is released.
403// The cache is identified by the "root" an "levels" arguments.
404// It should not contain any dirty clusters.
405// It returns 0 if success.
406// It returns 1 if error.
407//////////////////////////////////////////////////////////////////////////////////
408
409static unsigned int _release_cache_memory( fat_cache_node_t*  root,
410                                           unsigned int       levels );
411
412//////////////////////////////////////////////////////////////////////////////////
413// The following function allocates and initializes a new inode,
414// using the values defined by the arguments.
415// If the "cache_allocate" argument is true ans empty cache is allocated.
416// The Fat-Cache is initialised as empty: all children set to NULL.
417// It returns a pointer on the new inode.
418//////////////////////////////////////////////////////////////////////////////////
419
420static fat_inode_t* _allocate_one_inode( char*        name,
421                                         unsigned int is_dir,
422                                         unsigned int cluster,
423                                         unsigned int size,
424                                         unsigned int count,
425                                         unsigned int dentry,
426                                         unsigned int cache_allocate );
427
428//////////////////////////////////////////////////////////////////////////////////
429// The following function allocates one 4 Kbytes buffer and associated cluster
430// descriptor for the file (or directory) identified by the "inode" argument,
431// and updates the Cache_File slot identified by the "cluster_id" argument.
432// The File-Cache slot must be empty.
433// It updates the cluster descriptor, using the "cluster" argument, that is
434// the cluster index in FAT.  The cluster descriptor dirty field is set.
435// It traverse the 64-tree Cache-file from top to bottom to find the last level.
436//////////////////////////////////////////////////////////////////////////////////
437
438static void _allocate_one_buffer( fat_inode_t*    inode,
439                                  unsigned int    cluster_id,
440                                  unsigned int    cluster );
441
442//////////////////////////////////////////////////////////////////////////////////
443// The following function allocates one free cluster from the FAT "heap" of free
444// clusters, and returns the cluster index in the "cluster" argument.
445// It updates the FAT slot, and the two FAT global variables: first_free_cluster,
446// and free_clusters_number.
447// It returns O if success.
448// It returns 1 if error.
449//////////////////////////////////////////////////////////////////////////////////
450
451static unsigned int _allocate_one_cluster( unsigned int*  cluster );
452
453/////////////////////////////////////////////////////////////////////////////
454// This function remove from the file system a file or a directory
455// identified by the "inode" argument.
456// The remove condition must be checked by the caller.
457// The relevant lock(s) must have been taken by te caller.
458// It returns O if success.
459// It returns 1 if error.
460/////////////////////////////////////////////////////////////////////////////
461
462static unsigned int _remove_node_from_fs( fat_inode_t* inode );
463
464/////////////////////////////////////////////////////////////////////////////
465// This function return the cluster index and the size for a file
466// identified by the "pathname" argument, scanning directly the block
467// device DATA region.
468// It is intended to be called only by the _fat_load_no_cache() function,
469// it does not use the dynamically allocated File Caches, but uses only
470// the 4 Kbytes _fat_buffer_data.
471// It returns 0 if success.
472// It returns 1 if error.
473/////////////////////////////////////////////////////////////////////////////
474
475static unsigned int _file_info_no_cache( char*          pathname,
476                                         unsigned int*  file_cluster,
477                                         unsigned int*  file_size );
478
479/////////////////////////////////////////////////////////////////////////////
480// This function scan directly the FAT region on the block device,
481// and returns in the "next" argument the value stored in the fat slot
482// identified by the "cluster" argument.
483// It is intended to be called only by the _fat_load_no_cache() function,
484// as it does not use the dynamically allocated Fat-Cache, but uses only
485// the 4 Kbytes _fat_buffer_fat.
486// It returns 0 if success.
487// It returns 1 if error.
488/////////////////////////////////////////////////////////////////////////////
489
490static unsigned int _next_cluster_no_cache( unsigned int   cluster,
491                                            unsigned int*  next );
492
493
494//////////////////////////////////////////////////////////////////////////////////
495// The following functions return the length or the size of a FAT field,
496// identified by an (offset,length) mnemonic defined in the fat32.h file.
497//////////////////////////////////////////////////////////////////////////////////
498
499static inline int get_length( int offset , int length ) { return length; }
500
501static inline int get_offset( int offset , int length ) { return offset; }
502
503
504
505
506
507//////////////////////////////////////////////////////////////////////////////////
508//////////////////////////////////////////////////////////////////////////////////
509//                  Static functions definition
510//////////////////////////////////////////////////////////////////////////////////
511//////////////////////////////////////////////////////////////////////////////////
512
513#if GIET_DEBUG_FAT
514///////////////////////////////////////////////////
515static void _display_one_block( unsigned char* buf,
516                                char*          string,
517                                unsigned int   block_id )
[258]518{
519    unsigned int line;
520    unsigned int word;
521
[587]522    _printf("\n***  <%s>  block %x  ***********************************\n",
523            string , block_id );
[258]524
[417]525    for ( line = 0 ; line < 16 ; line++ )
[258]526    {
[417]527        // display line index
[587]528        _printf("%x : ", line );
[258]529
[417]530        // display 8*4 bytes hexa
[258]531        for ( word=0 ; word<8 ; word++ )
532        {
533            unsigned int byte  = (line<<5) + (word<<2);
[587]534            unsigned int hexa  = (buf[byte  ]<<24) |
535                                 (buf[byte+1]<<16) |
536                                 (buf[byte+2]<< 8) |
537                                 (buf[byte+3]      );
538            _printf(" %X |", hexa );
[258]539        }
[587]540        _printf("\n");
[258]541    }
[587]542    _printf("*******************************************************************\n"); 
543} // end _display_one_block() 
[530]544#endif
[291]545
[587]546
547
[530]548#if GIET_DEBUG_FAT
[587]549/////////////////////////////////////
550static void _display_fat_descriptor()
[530]551{
[587]552    _printf("\n###############  FAT DESCRIPTOR  ################################" 
[530]553            "\nFAT initialised                  %x"
[587]554            "\nBlock Size  (bytes)              %x"
555            "\nCluster Size  (bytes)            %x"
[530]556            "\nFAT region first lba             %x"
[587]557            "\nFAT region size (blocks)         %x"
558            "\nDATA region first lba            %x"
559            "\nDATA region size (blocks)        %x"
[530]560            "\nNumber of free clusters          %x"
[587]561            "\nFirst free cluster index         %x" 
562            "\nFat_cache_levels                 %d" 
[530]563            "\n#################################################################\n",
564            _fat.initialised,
565            _fat.sector_size,
[587]566            _fat.cluster_size,
[530]567            _fat.fat_lba,
[587]568            _fat.fat_sectors,
[530]569            _fat.data_lba,
[587]570            _fat.data_sectors,
571            _fat.free_clusters_number,
572            _fat.first_free_cluster,
573            _fat.fat_cache_levels );
574
575} // end _display_fat_descriptor()
[530]576#endif
577
[587]578
579
580#if GIET_DEBUG_FAT
581////////////////////////////////////////////////////////
582static void _display_clusters_list( fat_inode_t* inode )
[258]583{
[587]584    _printf("\n**************** clusters for <%s> ***********************\n", inode->name );
585    unsigned int next;
586    unsigned int n       = 0;
587    unsigned int current = inode->cluster;
588    while( (current < END_OF_CHAIN_CLUSTER_MIN) && (n < 1024) )
589    {
590        _get_fat_entry( current , &next );
591        _printf(" > %X", current );
592        n++;
593        if ( (n & 0x7) == 0 ) _printf("\n");
594        current = next;
595    }
596    _printf("\n");
597}  // end _display_clusters_list()
598#endif
[258]599
[587]600
601
602/////////////////////////////////////////////////////////////////////////////////
603static int _fat_ioc_access( unsigned int use_irq,       // descheduling if non zero
604                            unsigned int to_mem,        // read / write
605                            unsigned int lba,           // first sector on device
606                            unsigned int buf_vaddr,     // memory buffer vaddr
607                            unsigned int count )        // number of sectors
[291]608{
[587]609    // compute memory buffer physical address
610    unsigned int       flags;         // for _v2p_translate
611    unsigned long long buf_paddr;     // buffer physical address
[291]612
[587]613    if ( ((_get_mmu_mode() & 0x4) == 0 ) || USE_IOC_RDK )  // identity
614    { 
615        buf_paddr = (unsigned long long)buf_vaddr;
616    }
617    else                                // V2P translation required
[291]618    {
[587]619        buf_paddr = _v2p_translate( buf_vaddr , &flags );
[291]620    }
[587]621
622#if (GIET_DEBUG_FAT & 1)
623if ( _get_proctime() > GIET_DEBUG_FAT )
624_printf("\n[DEBUG FAT] _fat_ioc_access() : enters at cycle %d\n"
625        "  to_mem = %d / vaddr = %x / paddr = %l / sectors = %d / lba = %x\n",
626        _get_proctime(), to_mem, buf_vaddr, buf_paddr, count, lba );
627#endif
628
629
630#if GIET_NO_HARD_CC     // L1 cache inval (virtual addresses)
631    if ( to_mem ) _dcache_buf_invalidate( buf_vaddr, count<<9 );
632#endif
633
634
635#if   ( USE_IOC_BDV )   // call the proper driver
636    return( _bdv_access( use_irq , to_mem , lba , buf_paddr , count ) ); 
637#elif ( USE_IOC_HBA )
638    return( _hba_access( use_irq , to_mem , lba , buf_paddr , count ) );
639#elif ( USE_IOC_SDC )
640    return( _sdc_access( use_irq , to_mem , lba , buf_paddr , count ) );
641#elif ( USE_IOC_SPI )
642    return( _spi_access( use_irq , to_mem , lba , buf_paddr , count ) );
643#elif ( USE_IOC_RDK )
644    return( _rdk_access( use_irq , to_mem , lba , buf_paddr , count ) );
645#else
646    _printf("\n[FAT ERROR] in _fat_ioc_access() : no IOC driver\n");
647    _exit();
648#endif
649
650}  // end _fat_ioc_access()
651
652
653
654
655/////////////////////////////////////////////////////////////////////
656static inline unsigned int _get_levels_from_size( unsigned int size )
657{ 
658    if      ( size <= (1<<18) ) return 1;     // 64 clusters == 256 Kbytes
659    else if ( size <= (1<<24) ) return 2;     // 64 * 64 clusters => 16 Mbytes
660    else if ( size <= (1<<30) ) return 3;     // 64 * 64 * 64 cluster => 1 Gbytes
661    else                        return 4;     // 64 * 64 * 64 * 64 clusters
[291]662}
663
[587]664
665
666////////////////////////////////////////////////////////
667static unsigned int _read_entry( unsigned int    offset,
668                                 unsigned int    size,
669                                 unsigned char*  buffer,
670                                 unsigned int    little_endian )
[258]671{
[587]672    unsigned int n;
[258]673    unsigned int res  = 0;
674
[587]675    if ( little_endian)
[258]676    {
[587]677        for( n = size ; n > 0 ; n-- ) res = (res<<8) | buffer[offset+n-1];
[258]678    }
679    else
680    {
[587]681        for( n = 0 ; n < size ; n++ ) res = (res<<8) | buffer[offset+n];
[258]682    }
683    return res;
684
[587]685}  // end _read_entry
[258]686
687
688
[587]689//////////////////////////////////////////////////////////////////
690static inline unsigned int _cluster_to_lba( unsigned int cluster )       
[258]691{
[587]692    if ( cluster < 2 )
693    { 
694        _printf("\n[FAT ERROR] in _cluster_to_lba() cluster smaller than 2\n"); 
695        _exit();
[530]696    }
[258]697
[587]698   return  ((cluster - 2) << 3) + _fat.data_lba;
[258]699}
700
[587]701
[258]702//////////////////////////////////////////////////////
[596]703static inline unsigned char _to_lower(unsigned char c)
704{
705   if (c >= 'A' && c <= 'Z') return (c | 0x20);
706   else                      return c;
707}
708
709
710//////////////////////////////////////////////////////
[587]711static inline unsigned char _to_upper(unsigned char c)
[258]712{
713   if (c >= 'a' && c <= 'z') return (c & ~(0x20));
714   else                      return c;
715}
716
717
718
[587]719///////////////////////////////////////////////////////////////////////////
720static unsigned int _get_name_from_path( char*          pathname,  // input
721                                         char*          name,      // output
722                                         unsigned int*  nb_read )  // input & output   
[291]723{
[587]724    // skip leading "/" character
725    if ( pathname[*nb_read] == '/' ) *nb_read = *nb_read + 1;
[291]726
[587]727    // initialises current indexes
728    unsigned int i = *nb_read;
729    unsigned int j = 0;
[291]730   
[587]731    while ( (pathname[i] != '/') && (pathname[i] != 0) )
[291]732    {
[587]733        name[j++] = pathname[i++];   
734        if ( j > NAME_MAX_SIZE ) return 1;
[291]735    }
[587]736
737    // set end of string
[291]738    name[j] = 0;
739
[587]740    // skip trailing "/" character
[291]741    if ( pathname[i] == '/' ) *nb_read += j+1;
742    else                      *nb_read += j;
743
[587]744    return 0;
[291]745}
746
[587]747
748
749////////////////////////////////////////////////////////////////////
750static unsigned int _get_last_name( char*   pathname,       // input
751                                    char*   name )          // output
752{
753    unsigned int nb_read = 0;     
754    while ( pathname[nb_read] != 0 )
755    {
756        if ( _get_name_from_path( pathname, name, &nb_read ) ) return 1;
757    }
758
759    return 0;
760}   // end _get_last_name()
761
762
763
[258]764////////////////////////////////////////////////////////////////////////////////
[587]765static void _get_name_from_short( unsigned char* buffer,  // input:  SFN dir_entry
766                                  char*          name )   // output: name
[258]767{
[596]768    unsigned int i;
769    unsigned int j = 0;
[258]770
[596]771    // get name
772    for ( i = 0; i < 8 && buffer[i] != ' '; i++ )
[258]773    {
[596]774        name[j] = _to_lower( buffer[i] );
775        j++;
[258]776    }
[596]777
778    // get extension
779    for ( i = 8; i < 8 + 3 && buffer[i] != ' '; i++ )
780    {
781        // we entered the loop so there is an extension. add the dot
782        if ( i == 8 )
783        {
784            name[j] = '.';
785            j++;
786        }
787
788        name[j] = _to_lower( buffer[i] );
789        j++;
790    }
791
792    name[j] = '\0';
[258]793}
[291]794
[258]795///////////////////////////////////////////////////////////////////////////////
[587]796static void _get_name_from_long( unsigned char*  buffer, // input : LFN dir_entry
797                                 char*           name )  // output : name
[258]798{
[587]799    unsigned int   name_offset         = 0;
800    unsigned int   buffer_offset       = get_length(LDIR_ORD);
[258]801    unsigned int   l_name_1            = get_length(LDIR_NAME_1);
802    unsigned int   l_name_2            = get_length(LDIR_NAME_2);
803    unsigned int   l_name_3            = get_length(LDIR_NAME_3);
804    unsigned int   l_attr              = get_length(LDIR_ATTR);
805    unsigned int   l_type              = get_length(LDIR_TYPE);
806    unsigned int   l_chksum            = get_length(LDIR_CHKSUM);
807    unsigned int   l_rsvd              = get_length(LDIR_RSVD);
808
809    unsigned int j            = 0;
810    unsigned int eof          = 0;
811
[587]812    while ( (buffer_offset != DIR_ENTRY_SIZE)  && (!eof) )
[258]813    {
814        while (j != l_name_1 && !eof )
815        {
[587]816            if ( (buffer[buffer_offset] == 0x00) || 
817                 (buffer[buffer_offset] == 0xFF) )
[258]818            {
819                eof = 1;
820                continue;
821            }
[587]822            name[name_offset] = buffer[buffer_offset];
823            buffer_offset += 2;
[258]824            j += 2;
[587]825            name_offset++;
[258]826        }
827
[587]828        buffer_offset += (l_attr + l_type + l_chksum);
[258]829        j = 0;
830
831        while (j != l_name_2 && !eof )
832        {
[587]833            if ( (buffer[buffer_offset] == 0x00) || 
834                 (buffer[buffer_offset] == 0xFF) )
[258]835            {
836                eof = 1;
837                continue;
838            }
[587]839            name[name_offset] = buffer[buffer_offset];
840            buffer_offset += 2;
[258]841            j += 2;
[587]842            name_offset++;
[258]843        }
844
[587]845        buffer_offset += l_rsvd;
[258]846        j = 0;
847
848        while (j != l_name_3 && !eof )
849        {
[587]850            if ( (buffer[buffer_offset] == 0x00) || 
851                 (buffer[buffer_offset] == 0xFF) )
[258]852            {
853                eof = 1;
854                continue;
855            }
[587]856            name[name_offset] = buffer[buffer_offset];
857            buffer_offset += 2;
[258]858            j += 2;
[587]859            name_offset++;
[258]860        }
861    }
[587]862    name[name_offset] = 0;
[258]863} // end get_name_from_long()
864
[587]865
866
867
868////////////////////////////////////////////////////////////
869static fat_inode_t* _allocate_one_inode( char*        name,
870                                         unsigned int is_dir,
871                                         unsigned int cluster,
872                                         unsigned int size, 
873                                         unsigned int count,
874                                         unsigned int dentry,
875                                         unsigned int cache_allocate )
[291]876{
[587]877    fat_inode_t* new_inode  = _malloc( sizeof(fat_inode_t) );
[291]878
[587]879    new_inode->parent   = NULL;                 // set by _add_inode_in_tree()
880    new_inode->next     = NULL;                 // set by _add_inode_in_tree()
881    new_inode->child    = NULL;                 // set by _add_inode_in_tree()
882    new_inode->cluster  = cluster;
883    new_inode->size     = size; 
884    new_inode->cache    = NULL;
885    new_inode->levels   = 0;
886    new_inode->count    = count;
887    new_inode->is_dir   = (is_dir != 0);
888    new_inode->dentry   = dentry;             
[291]889
[587]890    _strcpy( new_inode->name , name ); 
891
892    if ( cache_allocate )
[291]893    {
[587]894        fat_cache_node_t* new_cache  = _malloc( sizeof(fat_cache_node_t) );
895
896        new_inode->cache    = new_cache;
897        new_inode->levels   = _get_levels_from_size( size );
898       
899        unsigned int index;
900        for ( index = 0 ; index < 64 ; index ++ )  new_cache->children[index] = NULL;
[291]901    }
902
[587]903    return new_inode;
904}   // end _allocate_one_inode()
[291]905
[587]906
907
908
909////////////////////////////////////////////////////
910static void _add_inode_in_tree( fat_inode_t*  child,
911                                fat_inode_t*  parent )
912{
913    child->parent = parent;
914    child->next   = parent->child;
915    parent->child = child;
916}   // end _add_inode-in_tree()
917
918
919
920
921//////////////////////////////////////////////////////////
922static void _remove_inode_from_tree( fat_inode_t*  inode )
923{
924    fat_inode_t*  current;
925    fat_inode_t*  prev = inode->parent->child;
926
927    if ( inode == prev )  // removed inode is first in its linked list
[291]928    {
[587]929        inode->parent->child = inode->next;
[291]930    }
[587]931    else                  // removed inode is not the first
[291]932    {
[587]933        for( current = prev->next ; current ; current = current->next )
[291]934        {
[587]935            if ( current == inode )
[291]936            {
[587]937                prev->next = current->next;
[291]938            }
[587]939            prev = current;
940        }   
941    }   
942}  // end _delete_one_inode()
[291]943
944
[587]945
946
947//////////////////////////////////////////////////////////////////////
948static unsigned int _get_buffer_from_cache( fat_inode_t*        inode,
949                                            unsigned int        cluster_id,
950                                            fat_cache_desc_t**  desc )
951{
952    // get cache pointer and levels
953    fat_cache_node_t*   node;         // pointer on a 64-tree node
954    unsigned int        level;        // cache level
955
956    if ( inode == NULL )   // searched cache is the Fat-Cache
957    {
958        node   = _fat.fat_cache_root;
959        level  = _fat.fat_cache_levels;
960
961#if (GIET_DEBUG_FAT & 1)
962if ( _get_proctime() > GIET_DEBUG_FAT )
963_printf("\n[DEBUG FAT] _get_buffer_from_cache() : enters in FAT-Cache"
964        " for cluster_id = %d\n", cluster_id );
965#endif
966
967    }
968    else                   // searched cache is a File-Cache
969    {
970        node   = inode->cache;
971        level  = inode->levels;
972
973#if (GIET_DEBUG_FAT & 1)
974if ( _get_proctime() > GIET_DEBUG_FAT )
975_printf("\n[DEBUG FAT] _get_buffer_from_cache() : enters in File-Cache <%s>"
976        " for cluster_id = %d\n", inode->name , cluster_id );
977#endif
978
979    }
980
981    // search the 64-tree cache from top to bottom
982    while ( level )
983    {
984        // compute child index at each level
985        unsigned int index = (cluster_id >> (6*(level-1))) & 0x3F;
986
987        if ( level == 1 )        // last level => children are cluster descriptors
[291]988        {
[587]989            fat_cache_desc_t* pdesc = (fat_cache_desc_t*)node->children[index];
[291]990
[587]991            if ( pdesc == NULL )      // miss
[291]992            {
[587]993                // allocate one cluster descriptor and one 4K buffer
994                unsigned char* buf = _malloc( 4096 );
995                pdesc              = _malloc( sizeof(fat_cache_desc_t) );
[291]996
[587]997                // get missing cluster index lba
998                unsigned int lba;
999                unsigned int next;
1000                unsigned int current = inode->cluster;
1001                unsigned int count   = cluster_id;
1002
1003                if ( inode == NULL )      // searched cache is the Fat-Cache
[291]1004                {
[587]1005
1006#if (GIET_DEBUG_FAT & 1)
1007if ( _get_proctime() > GIET_DEBUG_FAT )
1008_printf("\n[DEBUG FAT] _get_buffer_from_cache() : miss in FAT-Cache for cluster_id %d\n",
1009        cluster_id );
1010#endif
1011                    lba = _fat.fat_lba + (cluster_id << 3);
[291]1012                }
[587]1013                else                      // searched cache is a File-Cache
1014                {
1015
1016#if (GIET_DEBUG_FAT & 1)
1017if ( _get_proctime() > GIET_DEBUG_FAT )
1018_printf("\n[DEBUG FAT] _get_buffer_from_cache() : miss in File-Cache <%s> "
1019        "for cluster_id %d\n", inode->name, cluster_id );
1020#endif
1021                    while ( count )
1022                    { 
1023                        if ( _get_fat_entry( current , &next ) ) return 1;
1024                        current = next;
1025                        count--;
1026                    }
1027                    lba = _cluster_to_lba( current );
1028                }
1029
1030                // load one cluster (8 blocks) from block device
1031                if ( _fat_ioc_access( 1,         // descheduling
1032                                      1,         // to memory
1033                                      lba,
1034                                      (unsigned int)buf,
1035                                      8 ) )
1036                {
1037                    _printf("\n[FAT ERROR] in _get_buffer_from_cache()"
1038                            " : cannot access block device for lba = %x\n", lba );
1039                    return 1;
1040                }
1041
1042                // update cache and buffer descriptor
1043                node->children[index] = pdesc;
1044                pdesc->lba     = lba;
1045                pdesc->buffer  = buf;
1046                pdesc->dirty   = 0;
1047
1048#if (GIET_DEBUG_FAT & 1)
1049if ( _get_proctime() > GIET_DEBUG_FAT )
1050_printf("\n[DEBUG FAT] _get_buffer_from_cache() : buffer loaded from device"
1051        " at vaddr = %x\n", (unsigned int)buf );
1052#endif
[291]1053            }
[587]1054
1055            // return pdesc pointer
1056            *desc = pdesc;
1057
1058            // prepare next iteration
1059            level--;
1060        }
1061        else                      // not last level => children are 64-tree nodes
1062        {
1063            fat_cache_node_t* child = (fat_cache_node_t*)node->children[index];
1064            if ( child == NULL )  // miss
[291]1065            {
[587]1066                // allocate a cache node if miss
1067                child = (fat_cache_node_t*)_malloc( sizeof(fat_cache_node_t) );
1068                node->children[index] = child;   
[291]1069            }
[587]1070
1071            // prepare next iteration
1072            node = child;
1073            level--;
[291]1074        }
[587]1075    } // end while
[291]1076
[530]1077    return 0;
[587]1078}  // end _get_buffer_from_cache()
[530]1079
1080
[291]1081
1082
[587]1083/////////////////////////////////////
1084static unsigned int _update_fs_info()
1085{
1086    // update buffer if miss
1087    if ( _fat.fs_info_lba != _fat.block_buffer_lba )
[291]1088    {
[587]1089        if ( _fat_ioc_access( 1,                 // descheduling
[530]1090                              1,                 // read
[587]1091                              _fat.fs_info_lba, 
1092                              (unsigned int)_fat.block_buffer, 
1093                              1 ) )              // one block
[291]1094        {
[530]1095            _printf("\n[FAT_ERROR] in _update_fs_info() cannot read block\n");
[291]1096            return 1;
1097        }
[587]1098        _fat.block_buffer_lba = _fat.fs_info_lba;
[291]1099    }
1100
[587]1101    // update FAT buffer
1102    unsigned int* ptr;
1103    ptr  = (unsigned int*)(_fat.block_buffer + get_offset(FS_FREE_CLUSTERS) );
1104    *ptr = _fat.free_clusters_number;
1105
1106    ptr  = (unsigned int*)(_fat.block_buffer + get_offset(FS_FREE_CLUSTER_HINT) );
1107    *ptr = _fat.first_free_cluster;
[530]1108   
1109    // write bloc to FAT
[587]1110    if ( _fat_ioc_access( 1,                // descheduling
[530]1111                          0,                // write
[587]1112                          _fat.fs_info_lba,
1113                          (unsigned int)_fat.block_buffer, 
1114                          1 ) )             // one block
[530]1115    {
1116        _printf("\n[FAT_ERROR] in _update_fs_info() cannot write block\n");
1117        return 1;
1118    }
1119
[587]1120#if (GIET_DEBUG_FAT & 1)
1121if ( _get_proctime() > GIET_DEBUG_FAT )
1122_printf("\n[DEBUG FAT] _update_fs_info() : nb_free = %x / first_free = %x\n",
1123        _fat.free_clusters_number , _fat.first_free_cluster );
1124#endif
1125
[530]1126    return 0;
1127}  // end _update_fs_info()
1128
[587]1129
1130
1131/////////////////////////////////////////////////////////////////
1132static inline unsigned int _get_fat_entry( unsigned int  cluster,
1133                                           unsigned int* value )
[291]1134{
[587]1135    // compute cluster_id & entry_id in FAT
1136    // a FAT cluster is an array of 1024 unsigned int entries
1137    unsigned int       cluster_id = cluster >> 10;       
1138    unsigned int       entry_id   = cluster & 0x3FF;
[291]1139
[587]1140    // get pointer on the relevant cluster descriptor in FAT cache
1141    fat_cache_desc_t*  pdesc;
1142    unsigned int*      buffer;
1143    if ( _get_buffer_from_cache( NULL,               // Fat-Cache
1144                                 cluster_id,
1145                                 &pdesc ) ) return 1;
1146
1147    // get value from FAT slot
1148    buffer = (unsigned int*)pdesc->buffer;
1149    *value = buffer[entry_id];
1150
1151    return 0;
1152}  // end _get_fat_entry()
1153
1154
1155
1156////////////////////////////////////////////////////////////////
1157static inline unsigned int _set_fat_entry( unsigned int cluster, 
1158                                           unsigned int value  )
1159{
1160    // compute cluster_id & entry_id in FAT
1161    // a FAT cluster is an array of 1024 unsigned int entries
1162    unsigned int cluster_id = cluster >> 10;
1163    unsigned int entry_id   = cluster & 0x3FF;
1164
1165    // get pointer on the relevant cluster descriptor in FAT cache
1166    fat_cache_desc_t*  pdesc;
1167    unsigned int*      buffer; 
1168    if ( _get_buffer_from_cache( NULL,               // Fat-Cache
1169                                 cluster_id,
1170                                 &pdesc ) )  return 1;           
1171
1172    // set value into FAT slot
1173    buffer           = (unsigned int*)pdesc->buffer;
1174    buffer[entry_id] = value;
1175    pdesc->dirty     = 1;
1176
1177    return 0;
1178} // end _set_fat_entry()
1179
1180
1181
1182//////////////////////////////////////////////////////
1183static void _allocate_one_buffer( fat_inode_t*  inode,
1184                                  unsigned int  cluster_id,
1185                                  unsigned int  cluster )
1186{
1187    // search the 64-tree cache from top to bottom
1188    fat_cache_node_t*  node   = inode->cache;
1189    unsigned int       level  = inode->levels;
1190
1191    while ( level )
1192    {
1193        // compute child index
1194        unsigned int index = (cluster_id >> (6*(level-1))) & 0x3F;
1195
1196        if ( level == 1 )        // last level => children are cluster descriptors
1197        {
1198            fat_cache_desc_t* pdesc = (fat_cache_desc_t*)node->children[index];
1199            if ( pdesc != NULL )      // slot not empty!!!
1200            {
1201                _printf("\n[FAT ERROR] in allocate_one buffer() : slot not empty "
1202                        "in File-Cache <%s> / cluster_id = %d\n", inode->name , cluster_id );
1203                _exit();
1204            }
1205 
1206            // allocate a cluster descriptor and a 4K buffer
1207            pdesc = _malloc( sizeof(fat_cache_desc_t) );
1208            unsigned char* buffer = _malloc( 4096 );
1209
1210#if (GIET_DEBUG_FAT & 1)
[569]1211if ( _get_proctime() > GIET_DEBUG_FAT )
[587]1212_printf("\n[DEBUG FAT] _allocate_one_buffer() : buffer allocated to <%s> for cluster_id %d\n",
1213        inode->name, cluster_id );
[291]1214#endif
1215
[587]1216            // update cache and pdesc
1217            node->children[index] = pdesc;
1218            pdesc->lba     = _cluster_to_lba( cluster );
1219            pdesc->buffer  = buffer;
1220            pdesc->dirty   = 1;
1221
1222            // prepare next iteration
1223            level--;
1224        }
1225        else                      // not last level => children are 64-tree nodes
[291]1226        {
[587]1227            fat_cache_node_t* child = (fat_cache_node_t*)node->children[index];
1228            if ( child == NULL )  // miss
1229            {
1230                // allocate a cache node if miss
1231                child = (fat_cache_node_t*)_malloc( sizeof(fat_cache_node_t) );
1232                node->children[index] = child;   
1233            }
1234
1235            // prepare next iteration
1236            node  = child;
1237            level--;
[291]1238        }
[587]1239    } // end while
1240} // end _allocate_one_buffer
[530]1241
1242
[587]1243
1244
1245///////////////////////////////////////////////////////////////////
1246static unsigned int _allocate_one_cluster( unsigned int*  cluster ) 
1247{
1248    unsigned int nb_free = _fat.free_clusters_number;
1249    unsigned int free    = _fat.first_free_cluster;
1250
1251    // scan FAT to get next free cluster index
1252    unsigned int current = free;
1253    unsigned int found   = 0;
1254    unsigned int max     = (_fat.data_sectors >> 3);
1255    unsigned int value;
1256    do
[530]1257    {
[587]1258        // increment current
1259        current++;
1260
1261        // get FAT entry indexed by current
1262        if ( _get_fat_entry( current , &value ) ) return 1;
1263        // test if free
1264        if ( value == FREE_CLUSTER ) found = 1;
1265    }
1266    while ( (current < max) && (found == 0) );
1267       
1268    // check found 
1269    if ( found == 0 )
1270    {
1271        _printf("\n[FAT_ERROR] in _allocate_one_cluster() : unconsistent FAT state");
[530]1272        return 1;
1273    }
1274
[587]1275    // update allocated FAT slot
1276    if ( _set_fat_entry( free , END_OF_CHAIN_CLUSTER_MAX ) ) return 1;
1277
1278    // update FAT descriptor global variables
1279    _fat.free_clusters_number = nb_free - 1;
1280    _fat.first_free_cluster   = current;
1281
1282#if (GIET_DEBUG_FAT & 1)
1283if ( _get_proctime() > GIET_DEBUG_FAT )
1284_printf("\n[DEBUG FAT] _allocate_one_cluster() : cluster = %x / first_free = %x\n",
1285        free , current );
1286#endif
1287
1288    // returns free cluster index
1289    *cluster = free;
[530]1290    return 0;
[291]1291
[587]1292}  // end _allocate_one_cluster()
1293
1294
1295
1296
1297//////////////////////////////////////////////////////////////////////////
1298static unsigned int _update_device_from_cache( unsigned int        levels,
1299                                               fat_cache_node_t*   root,
1300                                               char*               string )
[291]1301{
[587]1302    unsigned int index;
1303    unsigned int ret = 0;
[291]1304
[587]1305    if ( levels == 1 )  // last level => children are cluster descriptors
[291]1306    {
[587]1307        for( index = 0 ; index < 64 ; index++ )
1308        { 
1309            fat_cache_desc_t* pdesc = root->children[index];
1310            if ( pdesc != NULL )
1311            { 
1312                // update cluster on device if dirty
1313                if ( pdesc->dirty )
1314                {
1315                    if ( _fat_ioc_access( 1,           // descheduling
1316                                          0,           // to block device
1317                                          pdesc->lba,
1318                                          (unsigned int)pdesc->buffer,
1319                                          8 ) )
1320                    {
1321                        _printf("\n[FAT_ERROR] in _update_device from_cache() : "
1322                                " cannot access lba = %x\n", pdesc->lba );
1323                        ret = 1;
1324                    }
1325                    else
1326                    {
1327                        pdesc->dirty = 0;
1328
1329#if (GIET_DEBUG_FAT & 1)
1330if ( _get_proctime() > GIET_DEBUG_FAT )
1331_printf("\n[DEBUG FAT] _update_device_from_cache() : cluster_id = %d for <%s>\n",
1332        index , string );
1333#endif
1334
1335                    }
1336                }
1337            }
1338        }
[291]1339    }
[587]1340    else               // not the last level = recursive call on each children
[291]1341    {
[587]1342        for( index = 0 ; index < 64 ; index++ )
1343        { 
1344            fat_cache_node_t* pnode = root->children[index];
1345            if ( pnode != NULL )
1346            {
1347                if ( _update_device_from_cache( levels - 1,
1348                                                root->children[index],
1349                                                string ) ) ret = 1;
1350            }   
1351        }
[291]1352    }
[587]1353    return ret;
1354}  // end _update_device_from_cache()
[291]1355
1356
[587]1357
1358///////////////////////////////////////////////////////////////////
1359static unsigned int _release_cache_memory( fat_cache_node_t*  root,
1360                                           unsigned int       levels )
1361{
1362    unsigned int index;
1363    unsigned int ret = 0;
1364
1365    if ( levels == 1 )  // last level => children are cluster descriptors
[503]1366    {
[587]1367        for( index = 0 ; index < 64 ; index++ )
1368        { 
1369            fat_cache_desc_t* pdesc = root->children[index];
1370
1371            if ( pdesc != NULL )
1372            { 
1373                // check dirty
1374                if ( pdesc->dirty )
1375                {
1376                    _printf("\n[FAT_ERROR] in _release_cache_memory() : dirty cluster\n");
1377                    ret = 1;
1378                }
1379                else
1380                {
1381                    _free( pdesc->buffer );
1382                    _free( pdesc );
1383                    root->children[index] = NULL;
1384                }
1385            }
1386        }
[503]1387    }
[587]1388    else               // not the last level = recursive call on each children
1389    {
1390        for( index = 0 ; index < 64 ; index++ )
1391        { 
1392            fat_cache_node_t*    cnode = root->children[index];
[291]1393
[587]1394            if ( cnode != NULL ) ret   = _release_cache_memory( root->children[index],
1395                                                                levels - 1 );
1396        }
1397    }
1398    return ret;
1399}  // end _release_cache_memory()
1400
1401
1402
1403
1404
1405/////////////////////////////////////////////////////////////
1406static unsigned int _clusters_allocate( fat_inode_t* inode, 
1407                                        unsigned int nb_current_clusters,
1408                                        unsigned int nb_required_clusters )
1409{
1410    // Check if FAT contains enough free clusters
1411    if ( nb_required_clusters > _fat.free_clusters_number )
[291]1412    {
[587]1413        _printf("\n[FAT ERROR] in _clusters_allocate() : required_clusters = %d"
1414                " / free_clusters = %d\n", nb_required_clusters , _fat.free_clusters_number );
1415        return 1;
1416    }
[291]1417
[587]1418#if (GIET_DEBUG_FAT & 1)
[569]1419if ( _get_proctime() > GIET_DEBUG_FAT )
[587]1420_printf("\n[DEBUG FAT] _clusters_allocate() : enters for <%s> / nb_current_clusters = %d "
1421        "/ nb_required_clusters = %d\n", 
1422        inode->name , nb_current_clusters , nb_required_clusters );
[291]1423#endif
[587]1424 
1425    // compute last allocated cluster index when (nb_current_clusters > 0)
1426    unsigned int current = inode->cluster;
1427    unsigned int next;
1428    unsigned int last;
1429    if ( nb_current_clusters )   // clusters allocated => search last
1430    {   
1431        while ( current < END_OF_CHAIN_CLUSTER_MIN )
[291]1432        {
[587]1433            // get next cluster
1434            if ( _get_fat_entry( current , &next ) )  return 1;
1435            last    = current;
1436            current = next;
[291]1437        }
[587]1438    } 
[291]1439
[587]1440    // Loop on the new clusters to be allocated
1441    // if (nb_current_clusters == 0) the first new cluster index must
1442    //                               be written in inode->cluster field
1443    // if (nb_current_clusters >  0) the first new cluster index must
1444    //                               be written in FAT[last]
1445    unsigned int      cluster_id;
1446    unsigned int      new;
1447    for ( cluster_id = nb_current_clusters ; 
1448          cluster_id < (nb_current_clusters + nb_required_clusters) ; 
1449          cluster_id ++ )
1450    {
1451        // allocate one cluster on block device
1452        if ( _allocate_one_cluster( &new ) ) return 1;
[291]1453
[587]1454        // allocate one 4K buffer to File-Cache
1455        _allocate_one_buffer( inode,
1456                              cluster_id,
1457                              new );
1458
1459        if ( cluster_id == 0 )  // update inode
[291]1460        {
[587]1461            inode->cluster = new;
[291]1462        }
[587]1463        else                    // update FAT
[291]1464        {
[587]1465            if ( _set_fat_entry( last , new ) ) return 1;
[291]1466        }
1467
[587]1468#if (GIET_DEBUG_FAT & 1)
1469if ( _get_proctime() > GIET_DEBUG_FAT )
1470_printf("\n[DEBUG FAT] _clusters_allocate() : done for cluster_id = %d / cluster = %x\n",
1471        cluster_id , new );
1472#endif
[291]1473
[587]1474        // update loop variables
1475        last = new;
1476
1477    } // end for loop
1478
1479    // update FAT : last slot should contain END_OF_CHAIN_CLUSTER_MAX
1480    if ( _set_fat_entry( last , END_OF_CHAIN_CLUSTER_MAX ) )  return 1;
1481
1482    // update the FAT on block device
1483    if ( _update_device_from_cache( _fat.fat_cache_levels,
1484                                    _fat.fat_cache_root,
1485                                    "FAT" ) )              return 1;
1486    return 0;
1487}  // end _clusters_allocate()
1488
1489
1490
1491//////////////////////////////////////////////////////////////
1492static unsigned int _clusters_release( unsigned int cluster )
1493{
1494    // scan the FAT
1495    unsigned int current = cluster;
1496    unsigned int next;
1497    do
1498    { 
1499        // get next_cluster index
1500        if ( _get_fat_entry( current , &next ) )  return 1;
1501
1502        // release current_cluster
1503        if ( _set_fat_entry( current , FREE_CLUSTER ) )   return 1;
1504
1505        // update first_free_cluster and free_clusters_number in FAT descriptor
1506        _fat.free_clusters_number = _fat.free_clusters_number + 1;
1507        if ( _fat.first_free_cluster > current ) _fat.first_free_cluster = current;
1508
1509        // update loop variable
1510        current = next;
[291]1511    }
[587]1512    while ( next < END_OF_CHAIN_CLUSTER_MIN );
[291]1513
[587]1514    // update the FAT on block device
1515    if ( _update_device_from_cache( _fat.fat_cache_levels,
1516                                    _fat.fat_cache_root,
1517                                    "FAT" ) )                return 1;
[291]1518    return 0;
[587]1519}  // end _clusters_release()
[291]1520
[587]1521
1522
1523///////////////////////////////////////////////////////////
1524static void _add_special_directories( fat_inode_t*  child, 
1525                                      fat_inode_t*  parent )
[258]1526{
[587]1527    // get first File-Cache buffer for child
1528    fat_cache_desc_t*   pdesc  = (fat_cache_desc_t*)child->cache->children[0];
1529    unsigned char*      entry;
[258]1530
[587]1531    unsigned int i;
1532    unsigned int cluster;
1533    unsigned int size;
[417]1534
[587]1535    // set "." entry (32 bytes)
1536    cluster = child->cluster;
1537    size    = child->size;
1538    entry   = pdesc->buffer;
1539   
1540    for ( i = 0 ; i < 32 ; i++ )
1541    {
1542        if      (i == 0 )     entry[i] = 0x2E;          // SFN
1543        else if (i <  11)     entry[i] = 0x20;          // SFN
1544        else if (i == 11)     entry[i] = 0x10;          // ATTR == dir
1545        else if (i == 20)     entry[i] = cluster>>16;   // cluster.B2
1546        else if (i == 21)     entry[i] = cluster>>24;   // cluster.B3
1547        else if (i == 26)     entry[i] = cluster>>0;    // cluster.B0
1548        else if (i == 27)     entry[i] = cluster>>8;    // cluster.B1
1549        else if (i == 28)     entry[i] = size>>0;       // size.B0
1550        else if (i == 29)     entry[i] = size>>8;       // size.B1
1551        else if (i == 30)     entry[i] = size>>16;      // size.B2
1552        else if (i == 31)     entry[i] = size>>24;      // size.B3
1553        else                  entry[i] = 0x00;
1554    }
[258]1555
[587]1556    // set ".." entry (32 bytes)
1557    cluster = parent->cluster;
1558    size    = parent->size;
1559    entry   = pdesc->buffer + 32;
[258]1560
[587]1561    for ( i = 0 ; i < 32 ; i++ )
[258]1562    {
[587]1563        if      (i <  2 )     entry[i] = 0x2E;          // SFN
1564        else if (i <  11)     entry[i] = 0x20;          // SFN
1565        else if (i == 11)     entry[i] = 0x10;          // ATTR == dir
1566        else if (i == 20)     entry[i] = cluster>>16;   // cluster.B2
1567        else if (i == 21)     entry[i] = cluster>>24;   // cluster.B3
1568        else if (i == 26)     entry[i] = cluster>>0;    // cluster.B0
1569        else if (i == 27)     entry[i] = cluster>>8;    // cluster.B1
1570        else if (i == 28)     entry[i] = size>>0;       // size.B0
1571        else if (i == 29)     entry[i] = size>>8;       // size.B1
1572        else if (i == 30)     entry[i] = size>>16;      // size.B2
1573        else if (i == 31)     entry[i] = size>>24;      // size.B3
1574        else                  entry[i] = 0x00;
[258]1575    }
[587]1576}  // end _add_special_directories
[258]1577
[358]1578
[587]1579
1580////////////////////////////////////////////////////////////
1581static unsigned int _check_name_length( char* name,
1582                                        unsigned int* length,
1583                                        unsigned int* nb_lfn )
1584{
1585    unsigned int len = _strlen( name );
1586    if      ( len <= 13 )
[258]1587    {
[587]1588        *length  = len;
1589        *nb_lfn  = 1;
1590        return 0;
1591    }
1592    else if ( len <= 26 )
1593    {
1594        *length  = len;
1595        *nb_lfn  = 2;
1596        return 0;
1597    }
1598    else if ( len <= 31 )
1599    {
1600        *length  = len;
1601        *nb_lfn  = 3;
1602        return 0;
1603    }
1604    else
1605    {
1606        return 1;
1607    }
1608}  // _check_name_length()
1609
1610
1611
1612
1613///////////////////////////////////////////////////////////
1614static unsigned int _get_nb_entries( fat_inode_t*   inode,
1615                                     unsigned int*  nb_entries )
1616{
1617    // scan directory until "end of directory" with two embedded loops:
1618    // - scan the clusters allocated to this directory
1619    // - scan the entries to find NO_MORE_ENTRY
1620    fat_cache_desc_t*  pdesc;                      // pointer on buffer descriptor
1621    unsigned char*     buffer;                     // 4 Kbytes buffer (one cluster)
1622    unsigned int       ord;                        // ORD field in directory entry
1623    unsigned int       attr;                       // ATTR field in directory entry
1624    unsigned int       cluster_id = 0;             // cluster index in directory
1625    unsigned int       offset     = 0;             // position in scanned buffer
1626    unsigned int       found      = 0;             // NO_MORE_ENTRY found
1627    unsigned int       count      = 0;             // number of valid NORMAL entries
1628
1629    // loop on clusters allocated to directory
1630    while ( found == 0 )
1631    {
1632        // get one 4 Kytes buffer from File_Cache 
1633        if ( _get_buffer_from_cache( inode,
1634                                     cluster_id,
1635                                     &pdesc ) )   return 1;
1636
1637        buffer = pdesc->buffer;
1638       
1639        // loop on directory entries in buffer
1640        while ( (offset < 4096) && (found == 0) )
[258]1641        {
[587]1642            attr = _read_entry( DIR_ATTR , buffer + offset , 0 );   
1643            ord  = _read_entry( LDIR_ORD , buffer + offset , 0 );
1644
1645            if ( ord == NO_MORE_ENTRY )
[258]1646            {
[587]1647                found = 1;
1648            } 
1649            else if ( ord == FREE_ENTRY )             // free entry => skip
1650            {
1651                offset = offset + 32;
[258]1652            }
[587]1653            else if ( attr == ATTR_LONG_NAME_MASK )   // LFN entry => skip
[258]1654            {
[587]1655                offset = offset + 32;
1656            }
1657            else                                      // NORMAL entry
1658            {
1659                count++;
1660            }
[258]1661
[587]1662            offset = offset + 32;
[258]1663
[587]1664        }  // end loop on directory entries
1665
1666        cluster_id++;
1667        offset = 0;
1668
1669    }  // end loop on clusters
1670
1671    // return nb_entries
1672    *nb_entries = count;
1673   
1674    return 0;
1675}  // end dir_not_empty()
1676
1677
1678
1679///////////////////////////////////////////////////////////
1680static unsigned int _add_dir_entry( fat_inode_t*   child,
1681                                    fat_inode_t*   parent )
1682{
1683    // get child attributes
1684    unsigned int      is_dir  = child->is_dir;     
1685    unsigned int      size    = child->size;
1686    unsigned int      cluster = child->cluster;
1687
1688    // compute number of required entries to store child->name
1689    // - Short name (less than 13 characters) require 3 entries:
1690    //   one LFN entry / one NORMAL entry / one NO_MORE_ENTRY entry.
1691    // - Longer names (up to 31 characters) can require 4 or 5 entries:
1692    //   2 or 3 LFN entries / one NORMAL entry / one NO_MORE entry.
1693    unsigned int length;
1694    unsigned int nb_lfn;
1695    if ( _check_name_length( child->name, 
1696                             &length,
1697                             &nb_lfn ) )  return 1;
1698
1699#if (GIET_DEBUG_FAT & 1)
1700if ( _get_proctime() > GIET_DEBUG_FAT )
1701_printf("\n[DEBUG FAT] _add_dir_entry() : try to add <%s> in <%s> / nb_lfn = %d\n", 
1702        child->name , parent->name, nb_lfn );
1703#endif
1704
1705    // Find end of directory : two embedded loops:
1706    // - scan the clusters allocated to this directory
1707    // - scan the entries to find NO_MORE_ENTRY
1708    fat_cache_desc_t*  pdesc;                      // pointer on buffer descriptor
1709    unsigned char*     buffer;                     // 4 Kbytes buffer (one cluster)
1710    unsigned int       cluster_id = 0;             // cluster index in directory
1711    unsigned int       offset     = 0;             // position in scanned buffer
1712    unsigned int       found      = 0;             // NO_MORE_ENTRY found
1713
1714    // loop on clusters allocated to directory
1715    while ( found == 0 )
1716    {
1717        // get one 4 Kytes buffer from File_Cache 
1718        if ( _get_buffer_from_cache( parent,
1719                                     cluster_id,
1720                                     &pdesc ) )   return 1;
1721
1722        buffer = pdesc->buffer;
1723       
1724        // loop on directory entries in buffer
1725        while ( (offset < 4096) && (found == 0) )
1726        {
1727            if ( _read_entry( LDIR_ORD , buffer + offset , 0 ) == NO_MORE_ENTRY )
[258]1728            {
[587]1729                found        = 1;
1730                pdesc->dirty = 1;
1731            } 
1732            else
1733            {
1734                offset = offset + 32;
[258]1735            }
[587]1736        }  // end loop on entries
1737        if ( found == 0 )
1738        {
1739            cluster_id++;
1740            offset = 0;
[258]1741        }
[587]1742    }  // end loop on clusters
[258]1743
[587]1744#if (GIET_DEBUG_FAT & 1)
1745if ( _get_proctime() > GIET_DEBUG_FAT )
1746_printf("\n[DEBUG FAT] _add_dir_entry() : get NO_MORE directory entry : "
1747        " buffer = %x / offset = %x / cluster_id = %d\n",
1748        (unsigned int)buffer , offset , cluster_id );
1749#endif
[258]1750
[587]1751    // enter FSM :
1752    // The new child requires to write 3, 4, or 5 directory entries.
1753    // To actually register the new child, we use a 5 steps FSM
1754    // (one state per entry to be written), that is traversed as:
1755    //    LFN3 -> LFN2 -> LFN1 -> NORMAL -> NOMORE
1756    // The buffer and first directory entry to be  written are identified
1757    // by the variables : buffer / cluster_id / offset
[417]1758
[587]1759    unsigned char* name  = (unsigned char*)child->name;
1760
1761    unsigned int step;          // FSM state
1762
1763    if      ( nb_lfn == 1 ) step = 3;
1764    else if ( nb_lfn == 2 ) step = 4;
1765    else if ( nb_lfn == 3 ) step = 5;
1766   
1767    unsigned int   i;           // byte index in 32 bytes directory
1768    unsigned int   c;           // character index in name
1769    unsigned char* entry;       // buffer + offset;
1770
1771    while ( step )   
1772    {
1773        // get another buffer if required
1774        if ( offset >= 4096 )  // new buffer required
[417]1775        {
[587]1776            if ( cluster_id == 63 )   // we need to increase depth of File-Cache
[258]1777            {
[587]1778                _printf("\n[FAT ERROR] in add_dir_entry() File Cache depth extension "
1779                        " not implemented\n" );
1780                _exit();  // TODO   
[258]1781            }
[587]1782            else
[258]1783            {
[587]1784                if ( _get_buffer_from_cache( parent,
1785                                             cluster_id + 1,
1786                                             &pdesc ) )      return 1;       
1787                buffer       = pdesc->buffer;
1788                pdesc->dirty = 1;
1789                offset       = 0;
1790            }
1791        }
[417]1792
[587]1793        // compute directory entry address
1794        entry = buffer + offset;
[417]1795
[587]1796#if (GIET_DEBUG_FAT & 1)
1797if ( _get_proctime() > GIET_DEBUG_FAT )
1798_printf("\n[DEBUG FAT] _add_dir_entry() : FSM step = %d /"
1799        " offset = %x / nb_lfn = %d\n", step, offset, nb_lfn );
1800#endif
1801
1802        // write one 32 bytes directory entry per iteration
1803        switch ( step )
1804        {
1805            case 5:   // write LFN3 entry
1806            {
1807                c = 26;
1808                // scan the 32 bytes in dir_entry
1809                for ( i = 0 ; i < 32 ; i++ )
[258]1810                {
[587]1811                    if (i == 0)
1812                    {
1813                        if ( nb_lfn == 3) entry[i] = 0x43;
1814                        else              entry[i] = 0x03;
1815                    }
1816                    else if ( ( ((i >= 1 ) && (i<=10) && ((i&1)==1))   ||
1817                                ((i >= 14) && (i<=25) && ((i&1)==0))   ||
1818                                ((i >= 28) && (i<=31) && ((i&1)==0)) ) &&
1819                              ( c < length ) )
1820                    {
1821                                          entry[i] = name[c];
1822                                          c++;
1823                    }
1824                    else if (i == 11)     entry[i] = 0x0F;
1825                    else if (i == 12)     entry[i] = 0xCA;
1826                    else                  entry[i] = 0x00;
[258]1827                }
[587]1828                step--;
1829                break;
1830            }
1831            case 4:   // write LFN2 entry 
1832            {
1833                c = 13;
1834                // scan the 32 bytes in dir_entry
1835                for ( i = 0 ; i < 32 ; i++ )
[258]1836                {
[587]1837                    if (i == 0)
1838                    {
1839                        if ( nb_lfn == 2) entry[i] = 0x42;
1840                        else              entry[i] = 0x02;
1841                    }
1842                    else if ( ( ((i >= 1 ) && (i<=10) && ((i&1)==1))   ||
1843                                ((i >= 14) && (i<=25) && ((i&1)==0))   ||
1844                                ((i >= 28) && (i<=31) && ((i&1)==0)) ) &&
1845                              ( c < length ) )
1846                    {
1847                                          entry[i] = name[c];
1848                                          c++;
1849                    }
1850                    else if (i == 11)     entry[i] = 0x0F;
1851                    else if (i == 12)     entry[i] = 0xCA;
1852                    else                  entry[i] = 0x00;
[258]1853                }
[587]1854                step--;
1855                break;
[258]1856            }
[587]1857            case 3:   // Write LFN1 entry   
[258]1858            {
[587]1859                c = 0;
1860                // scan the 32 bytes in dir_entry
1861                for ( i = 0 ; i < 32 ; i++ )
1862                {
1863                    if (i == 0)
1864                    {
1865                        if ( nb_lfn == 1) entry[i] = 0x41;
1866                        else              entry[i] = 0x01;
1867                    }
1868                    else if ( ( ((i >= 1 ) && (i<=10) && ((i&1)==1))   ||
1869                                ((i >= 14) && (i<=25) && ((i&1)==0))   ||
1870                                ((i >= 28) && (i<=31) && ((i&1)==0)) ) &&
1871                              ( c < length ) )
1872                    {
1873                                          entry[i] = name[c];
1874                                          c++;
1875                    }
1876                    else if (i == 11)     entry[i] = 0x0F;
1877                    else if (i == 12)     entry[i] = 0xCA;
1878                    else                  entry[i] = 0x00;
1879                }
1880                step--;
1881                break;
[258]1882            }
[587]1883            case 2:   // write NORMAL entry     
[258]1884            {
[587]1885                c = 0;
1886                // scan the 32 bytes in dir_entry
1887                for ( i = 0 ; i < 32 ; i++ )
[258]1888                {
[587]1889                    if      ( (i < 8) && (c < length) )             // SFN
[417]1890                    {
[587]1891                                          entry[i] = _to_upper( name[c] );
1892                                          c++;
[417]1893                    }
[587]1894                    else if (i <  11)     entry[i] = 0x20;          // EXT
1895                    else if (i == 11)                               // ATTR
1896                    {
1897                        if (is_dir)       entry[i] = 0x10;
1898                        else              entry[i] = 0x20;
1899                    }
1900                    else if (i == 20)     entry[i] = cluster>>16;   // cluster.B2
1901                    else if (i == 21)     entry[i] = cluster>>24;   // cluster.B3
1902                    else if (i == 26)     entry[i] = cluster>>0;    // cluster.B0
1903                    else if (i == 27)     entry[i] = cluster>>8;    // cluster.B1
1904                    else if (i == 28)     entry[i] = size>>0;       // size.B0
1905                    else if (i == 29)     entry[i] = size>>8;       // size.B1
1906                    else if (i == 30)     entry[i] = size>>16;      // size.B2
1907                    else if (i == 31)     entry[i] = size>>24;      // size.B3
1908                    else                  entry[i] = 0x00;
[258]1909                }
[587]1910
1911                // update the dentry field in child inode
1912                child->dentry = ((cluster_id<<12) + offset)>>5;
1913
1914                step--;
1915                break;
[417]1916            }
[587]1917            case 1:   // write NOMORE entry 
[417]1918            {
[587]1919                step--;
1920                entry [0] = 0x00;
1921                break;
1922            }
1923        } // end switch step
1924        offset += 32;
1925    } // exit while => exit FSM   
1926
1927#if (GIET_DEBUG_FAT & 1)
1928if ( _get_proctime() > GIET_DEBUG_FAT )
1929{
1930    _printf("\n[DEBUG FAT] _add_dir_entry() : <%s> successfully added in <%s>\n",
1931            child->name , parent->name );
1932}
1933#endif
1934
1935    return 0;       
1936} // end _add_dir_entry
1937
1938
1939
1940////////////////////////////////////////////////////////////
1941static unsigned int _remove_dir_entry( fat_inode_t*  inode )
1942{
1943    // compute number of LFN entries
1944    unsigned int length;
1945    unsigned int nb_lfn;
1946    if ( _check_name_length( inode->name, 
1947                             &length,
1948                             &nb_lfn ) )  return 1;
1949
1950    // get cluster_id and offset in parent directory cache
1951    unsigned int  dentry     = inode->dentry;
1952    unsigned int  cluster_id = dentry >> 7;
1953    unsigned int  offset     = (dentry & 0x7F)<<5;
1954
1955    // get buffer from parent directory cache
1956    unsigned char*     buffer;
1957    fat_cache_desc_t*  pdesc;
1958
1959    if ( _get_buffer_from_cache( inode->parent,
1960                                 cluster_id,
1961                                 &pdesc ) ) return 1;
1962    buffer       = pdesc->buffer;
1963    pdesc->dirty = 1;
1964
1965    // invalidate NORMAL entry in directory cache
1966    buffer[offset] = 0xE5;
1967
1968    // invalidate LFN entries
1969    while ( nb_lfn )
1970    {
1971        if (offset == 0)  // me must load buffer for (cluster_id - 1)
1972        {
1973            if ( _get_buffer_from_cache( inode->parent,
1974                                         cluster_id - 1,
1975                                         &pdesc ) )   return 1;
1976            buffer       = pdesc->buffer;
1977            pdesc->dirty = 1;
1978            offset       = 4064;
1979        }
1980        else
1981        {
1982            offset = offset - 32;
1983        }
1984
1985        // invalidate LFN entry
1986        buffer[offset] = 0xE5;
1987
1988        nb_lfn--;
1989    }     
1990         
1991    return 0;
1992}  // end _remove_dir_entry
1993
1994
1995
1996
1997////////////////////////////////////////////////////////////
1998static unsigned int _update_dir_entry( fat_inode_t*  inode )
1999{ 
2000    // get Cache-File buffer containing the parent directory entry
2001    // 128 directories entries in one 4 Kbytes buffer
2002    fat_cache_desc_t*  pdesc;
2003    unsigned char*     buffer;   
2004    unsigned int       cluster_id = inode->dentry>>7;
2005    unsigned int       offset     = (inode->dentry & 0x3F)<<5;
2006
2007    if ( _get_buffer_from_cache( inode->parent,
2008                                 cluster_id,
2009                                 &pdesc ) )    return 1;
2010    buffer       = pdesc->buffer;
2011    pdesc->dirty = 1;
2012
2013    // update size field
2014    buffer[offset + 28] = inode->size>>0;       // size.B0
2015    buffer[offset + 29] = inode->size>>8;       // size.B1
2016    buffer[offset + 30] = inode->size>>16;      // size.B2
2017    buffer[offset + 31] = inode->size>>24;      // size.B3
2018
2019    // update cluster field
2020    buffer[offset + 26] = inode->cluster>>0;    // cluster.B0
2021    buffer[offset + 27] = inode->cluster>>8;    // cluster.B1
2022    buffer[offset + 20] = inode->cluster>>16;   // cluster.B2
2023    buffer[offset + 21] = inode->cluster>>24;   // cluster.B3
2024   
2025    return 0;
2026} // end _update_dir_entry()
2027
2028
2029
2030
2031//////////////////////////////////////////////////////////////////
2032static unsigned int _get_child_from_parent( fat_inode_t*   parent,
2033                                            char*          name, 
2034                                            fat_inode_t**  inode )
2035{
2036    fat_inode_t*   current;
2037
2038#if (GIET_DEBUG_FAT & 1)
2039if ( _get_proctime() > GIET_DEBUG_FAT )
2040_printf("\n[DEBUG FAT] _get_child_from_parent() : search <%s> in directory <%s>\n",
2041        name , parent->name );
2042#endif
2043
2044    // compute name lenth
2045    unsigned int length = _strlen( name );
2046   
2047    // scan inodes in the parent directory
2048    for ( current = parent->child ; current ; current = current->next )
2049    {
2050        if ( _strncmp( name , current->name , length ) == 0 ) 
2051        {
2052
2053#if (GIET_DEBUG_FAT & 1)
2054if ( _get_proctime() > GIET_DEBUG_FAT )
2055_printf("\n[DEBUG FAT] _get_child_from_parent() : found inode <%s> in directory <%s>\n", 
2056        name , parent->name );
2057#endif
2058            *inode = current;
2059            return 0;           // name found
2060        }
2061    }
2062
2063    // not found in Inode-Tree => access the parent directory
2064    // file_cache.  Two embedded loops:
2065    // - scan the clusters allocated to this directory
2066    // - scan the directory entries in each 4 Kbytes buffer
2067
2068    unsigned char*    buffer;           // pointer on one cache buffer
2069    char              cname[32];        // buffer for one full entry name
2070    char              lfn1[16];         // buffer for one partial name
2071    char              lfn2[16];         // buffer for one partial name
2072    char              lfn3[16];         // buffer for one partial name
2073    unsigned int      size;             // searched file/dir size (bytes)
2074    unsigned int      cluster;          // searched file/dir cluster index
2075    unsigned int      is_dir;           // searched file/dir type
2076    unsigned int      attr;             // directory entry ATTR field
2077    unsigned int      ord;              // directory entry ORD field
[597]2078    unsigned int      lfn = 0;          // LFN entries number
[587]2079    unsigned int      dentry;           // directory entry index
2080    unsigned int      offset     = 0;   // byte offset in buffer
2081    unsigned int      cluster_id = 0;   // cluster index in directory
2082    int               found      = 0;   // not found (0) / name found (1) / end of dir (-1)
2083
2084#if (GIET_DEBUG_FAT & 1)
2085if ( _get_proctime() > GIET_DEBUG_FAT )
2086_printf("\n[DEBUG FAT] _get_child_from_parent() : does not found inode <%s>"
2087        " in directory <%s> => search in cache\n", name , parent->name );
2088#endif
2089
2090    // scan the clusters allocated to parent directory
2091    while ( found == 0 )
2092    {
2093        // get one 4 Kytes buffer from parent File_Cache 
2094        fat_cache_desc_t*  pdesc;
2095        if ( _get_buffer_from_cache( parent,
2096                                     cluster_id,
2097                                     &pdesc ) )    return 2;
2098        buffer = pdesc->buffer;
2099
2100        // scan this buffer until end of directory, end of buffer, or name found
2101        while( (offset < 4096) && (found == 0) )
2102        {
2103
2104#if (GIET_DEBUG_FAT & 1)
2105if ( _get_proctime() > GIET_DEBUG_FAT )
2106_printf("\n[DEBUG FAT] _get_child_from_parent() : scan buffer %d for <%s>\n",
2107        cluster_id , name );
2108#endif
2109            attr = _read_entry( DIR_ATTR , buffer + offset , 0 );   
2110            ord  = _read_entry( LDIR_ORD , buffer + offset , 0 );
2111
2112            if (ord == NO_MORE_ENTRY)                 // no more entry in directory => break
2113            {
2114                found = -1;
2115            }
2116            else if ( ord == FREE_ENTRY )             // free entry => skip
2117            {
2118                offset = offset + 32;
2119            }
2120            else if ( attr == ATTR_LONG_NAME_MASK )   // LFN entry => get partial name
2121            {
2122                unsigned int seq = ord & 0x3;
2123                lfn = (seq > lfn) ? seq : lfn;   
2124                if      ( seq == 1 ) _get_name_from_long( buffer + offset, lfn1 );
2125                else if ( seq == 2 ) _get_name_from_long( buffer + offset, lfn2 );
2126                else if ( seq == 3 ) _get_name_from_long( buffer + offset, lfn3 );
2127                offset = offset + 32;
2128            }
2129            else                                 // NORMAL entry
2130            {
2131                // build the extracted name
2132                if      ( lfn == 0 )
[258]2133                {
[587]2134                    _get_name_from_short( buffer + offset , cname );
[258]2135                }
[587]2136                else if ( lfn == 1 )
[417]2137                {
[587]2138                    _strcpy( cname      , lfn1 );
2139                }   
2140                else if ( lfn == 2 ) 
2141                {
2142                    _strcpy( cname      , lfn1 );
2143                    _strcpy( cname + 13 , lfn2 );
[417]2144                }
[587]2145                else if ( lfn == 3 ) 
2146                {
2147                    _strcpy( cname      , lfn1 );
2148                    _strcpy( cname + 13 , lfn2 );
2149                    _strcpy( cname + 26 , lfn3 );
2150                }
2151                   
2152                // test if extracted name == searched name
2153                if ( _strncmp( name , cname , length ) == 0 )
2154                {
2155                    cluster = (_read_entry( DIR_FST_CLUS_HI , buffer + offset , 1 ) << 16) |
2156                              (_read_entry( DIR_FST_CLUS_LO , buffer + offset , 1 )      ) ;
2157                    dentry  = ((cluster_id<<12) + offset)>>5;
2158                    is_dir  = ((attr & ATTR_DIRECTORY) == ATTR_DIRECTORY);
2159                    size    = _read_entry( DIR_FILE_SIZE , buffer + offset , 1 );
2160                    found   = 1;
2161                }
2162                offset = offset + 32;
2163                lfn    = 0;
[258]2164            }
[587]2165        }  // end loop on directory entries
2166        cluster_id++;
2167        offset = 0;
2168    }  // end loop on buffers
2169
2170    if ( found == -1 )  // found end of directory in parent directory
2171    {
2172
2173#if (GIET_DEBUG_FAT & 1)
2174if ( _get_proctime() > GIET_DEBUG_FAT )
2175_printf("\n[DEBUG FAT] _get_child_from_parent() : found end of directory in <%s>\n",
2176        parent->name );
2177#endif
2178        *inode = NULL;
2179        return 1;
2180    }
2181    else               // found searched name in parent directory
2182    {
2183        // allocate a new inode and an empty Cache-File
2184        *inode = _allocate_one_inode( name,
2185                                      is_dir,
2186                                      cluster,
2187                                      size,
2188                                      0,             // count
2189                                      dentry,
2190                                      1 );           // cache_allocate
2191
2192        // introduce it in Inode-Tree
2193        _add_inode_in_tree( *inode , parent );
2194
2195#if (GIET_DEBUG_FAT & 1)
2196if ( _get_proctime() > GIET_DEBUG_FAT )
2197_printf("\n[DEBUG FAT] _get_child_from_parent() : found <%s> on device\n", name );
2198#endif
2199        return 0;
2200    }
2201}  // end _get_child_from_parent()
2202
2203
2204
2205
2206//////////////////////////////////////////////////////////////////
2207static unsigned int _get_inode_from_path( char*          pathname,
2208                                          fat_inode_t**  inode )
2209{
2210    char                 name[32];         // buffer for one name in pathname
2211    unsigned int         nb_read;              // number of characters written in name[]
2212    fat_inode_t*         parent;           // parent inode
2213    fat_inode_t*         child;            // child inode
2214    unsigned int         last;             // while exit condition
2215    unsigned int         code;             // return value
2216
2217#if (GIET_DEBUG_FAT & 1)
2218if ( _get_proctime() > GIET_DEBUG_FAT )
2219_printf("\n[DEBUG FAT] _get_inode_from_path() : enters for path <%s>\n", pathname );
2220#endif
2221
2222    // handle root directory case
2223    if ( _strncmp( pathname , "/" , 2 ) == 0 )
2224    {
2225
2226#if (GIET_DEBUG_FAT & 1)
2227if ( _get_proctime() > GIET_DEBUG_FAT )
2228_printf("\n[DEBUG FAT] _get_inode_from_path() : found root inode for <%s>\n", 
2229        pathname );
2230#endif
2231        *inode  = _fat.inode_tree_root;
2232        return 0;
2233    }
2234
2235    // If the pathname is not "/", we traverse the inode tree from the root.
2236    // We use _get_name_from_path() to scan pathname and extract inode names.
2237    // We use _get_child_from_parent() to scan each directory in the path.
2238
2239    last       = 0;
2240    nb_read    = 0;                      // number of characters analysed in path
2241    parent     = _fat.inode_tree_root;   // Inode-Tree root
2242   
2243    while ( last == 0 )
2244    {
2245        // get searched file/dir name
2246        if ( _get_name_from_path( pathname, name, &nb_read ) )
2247        {
2248            return 3;   // error : name too long
[258]2249        }
2250
[587]2251        // compute last iteration condition
2252        last = (pathname[nb_read] == 0);
[258]2253
[587]2254#if (GIET_DEBUG_FAT & 1)
[569]2255if ( _get_proctime() > GIET_DEBUG_FAT )
[587]2256_printf("\n[DEBUG FAT] _get_inode_from_path() : got name <%s>\n", name );
[417]2257#endif
2258
[587]2259        // get child inode from parent directory
2260        code = _get_child_from_parent( parent,
2261                                       name,
2262                                       &child );
[417]2263
[587]2264        // we  need to find the child inode for all non terminal names
2265        if ( (code == 2) || ((code == 1 ) && (last == 0)) )
2266        {
[417]2267
[587]2268#if (GIET_DEBUG_FAT & 1)
2269if ( _get_proctime() > GIET_DEBUG_FAT )
2270_printf("\n[DEBUG FAT] _get_inode_from_path() : neither parent, nor child found for <%s>\n", 
2271        pathname );
2272#endif
2273            return 2;  // error : parent inode not found
2274        }
2275       
2276        // update parent if not the last iteration
2277        if ( last == 0 ) parent = child;
2278
2279    } // end while
2280
2281    // returns inode pointer
2282    if (code == 0 )
2283    {
2284
2285#if (GIET_DEBUG_FAT & 1)
2286if ( _get_proctime() > GIET_DEBUG_FAT )
2287_printf("\n[DEBUG FAT] _get_inode_from_path() : found inode for <%s>\n", 
2288        pathname );
2289#endif
2290        *inode  = child;
2291    }
2292    else
2293    {
2294
2295#if (GIET_DEBUG_FAT & 1)
2296if ( _get_proctime() > GIET_DEBUG_FAT )
2297_printf("\n[DEBUG FAT] _get_inode_from_path() : found only parent inode for <%s>\n",
2298        pathname );
2299#endif
2300        *inode  = parent;
2301    }
2302
2303    return code;                 // can be 0 (found) or 1 (not found)
2304
2305}  // end _get_inode_from_path()
2306
2307
2308
2309
2310//////////////////////////////////////////////////////////////
2311static unsigned int _remove_node_from_fs( fat_inode_t* inode )
[258]2312{
[587]2313    // remove entry in parent directory
2314    if ( _remove_dir_entry( inode ) ) return 1;
2315
2316    // update parent directory on device
2317    if ( _update_device_from_cache( inode->parent->levels,
2318                                    inode->parent->cache,
2319                                    inode->parent->name ) ) return 1;
2320
2321    // release clusters allocated to file/dir in DATA region
2322    if ( _clusters_release( inode->cluster ) ) return 1;
2323
2324    // release File-Cache
2325    if ( _release_cache_memory( inode->cache,
2326                                inode->levels ) ) return 1;
2327
2328    // remove inode from Inode-Tree
2329    _remove_inode_from_tree( inode );
2330
2331    // release inode
2332    _free ( inode );
2333
[258]2334    return 0;
[587]2335}  // end _remove_node_from_fs()
[258]2336
2337
[587]2338//////////////////////////////////////////////////////////////////
2339static unsigned int _next_cluster_no_cache( unsigned int   cluster,
2340                                            unsigned int*  next )
2341{
2342    // compute cluster_id and slot_id
2343    // each cluster contains 1024 slots (4 bytes per slot)
2344    unsigned int cluster_id  = cluster >> 10;
2345    unsigned int slot_id     = cluster & 0x3FF;
[258]2346
[587]2347    // compute lba of cluster identified by cluster_id
2348    unsigned int lba = _fat.fat_lba + (cluster_id << 3);
[258]2349
[587]2350    // get cluster containing the adressed FAT slot in FAT buffer
2351    if ( _fat_buffer_fat_lba != lba )
2352    {
2353        if ( _fat_ioc_access( 0,         // no descheduling
2354                              1,         // read
2355                              lba,
2356                              (unsigned int)_fat_buffer_fat,
2357                              8 ) )
2358        {
2359            _printf("\n[FAT ERROR] in _next_cluster_no_cache() : "
2360                    "cannot load lba = %x into fat_buffer\n", lba );
2361            return 1;
2362        }
2363
2364        _fat_buffer_fat_lba = lba;
2365    }
2366
2367    // return next cluster index
2368    unsigned int* buf = (unsigned int*)_fat_buffer_fat;
2369    *next = buf[slot_id];
2370    return 0;
2371   
2372}  // end _next_cluster_no_cache()
2373
2374
2375
2376
2377/////////////////////////////////////////////////////////////////
2378static unsigned int _file_info_no_cache( char*          pathname,
2379                                         unsigned int*  file_cluster,
2380                                         unsigned int*  file_size )
[258]2381{
[587]2382   
2383#if (GIET_DEBUG_FAT & 1)
2384if ( _get_proctime() > GIET_DEBUG_FAT )
2385_printf("\n[DEBUG FAT] _file_info_no_cache() : enters for path <%s>\n", pathname );
2386#endif
[258]2387
[587]2388    char            name[32];             // buffer for one name in the analysed pathname
2389    char            lfn1[16];             // buffer for a partial name in LFN entry
2390    char            lfn2[16];             // buffer for a partial name in LFN entry
2391    char            lfn3[16];             // buffer for a partial name in LFN entry
2392    char            cname[32];            // buffer for a full name in a directory entry
2393    unsigned int    nb_read;              // number of characters analysed in path
2394    unsigned int    length;               // searched name length
2395    unsigned int    parent_cluster;       // cluster index for the parent directory
[597]2396    unsigned int    child_cluster = 0;    // cluster index for the searched file/dir
2397    unsigned int    child_size = 0;       // size of the searched file/dir
[587]2398    unsigned int    child_is_dir;         // type of the searched file/dir
2399    unsigned int    offset;               // offset in a 4 Kbytes buffer
2400    unsigned int    ord;                  // ORD field in a directory entry
2401    unsigned int    attr;                 // ATTR field in a directory entry
[597]2402    unsigned int    lfn = 0;              // number of lfn entries
[587]2403    unsigned char*  buf;                  // pointer on a 4 Kbytes buffer
2404    unsigned int    found;                // name found in current directory entry
2405
2406    // Three embedded loops:
2407    // - scan pathname to extract file/dir names,
2408    // - for each name, scan the clusters of the parent directory
2409    // - for each cluster, scan the 4 Kbytes buffer to find the file/dir name
2410    // The starting point is the root directory (cluster 2)
2411
2412    nb_read        = 0;
2413    parent_cluster = 2; 
2414
2415    // scan pathname 
2416    while ( pathname[nb_read] != 0 )   
2417    {
2418        // get searched file/dir name
2419        if ( _get_name_from_path( pathname, name, &nb_read ) ) return 1;
2420
2421#if (GIET_DEBUG_FAT & 1)
2422if ( _get_proctime() > GIET_DEBUG_FAT )
2423_printf("\n[DEBUG FAT] _file_info_no_cache() : search name <%s>"
2424        " in cluster %x\n", name , parent_cluster );
2425#endif
2426        found  = 0;
2427        length = _strlen( name );
2428
2429        // scan clusters containing the parent directory
2430        while ( found == 0 ) 
2431        {
2432            // compute lba
2433            unsigned int lba = _cluster_to_lba( parent_cluster );
2434
2435            // load one cluster of the parent directory into data_buffer
2436            if ( _fat_buffer_data_lba != lba )
2437            {
2438                if ( _fat_ioc_access( 0,         // no descheduling
2439                                      1,         // read
2440                                      lba,
2441                                      (unsigned int)_fat_buffer_data,
2442                                      8 ) )
2443                {
2444                    _printf("\n[FAT ERROR] in _file_info_no_cache() : "
2445                            "cannot load lba = %x into data_buffer\n", lba );
2446                    return 1;
2447                }
2448
2449                _fat_buffer_data_lba = lba;
2450            }
2451
2452            offset = 0;
2453
2454            // scan this 4 Kbytes buffer
2455            while ( (offset < 4096) && (found == 0) )
2456            {
2457                buf  = _fat_buffer_data + offset;
2458                attr = _read_entry( DIR_ATTR , buf , 0 );   
2459                ord  = _read_entry( LDIR_ORD , buf , 0 );
2460
2461                if (ord == NO_MORE_ENTRY)               // no more entry => break
2462                {
2463                    found = 2;
2464                }
2465                else if ( ord == FREE_ENTRY )           // free entry => skip
2466                {
2467                    offset = offset + 32;
2468                }
2469                else if ( attr == ATTR_LONG_NAME_MASK ) // LFN entry => get partial name
2470                {
2471                    unsigned int seq = ord & 0x3;
2472                    lfn = (seq > lfn) ? seq : lfn;   
2473                    if      ( seq == 1 ) _get_name_from_long( buf, lfn1 );
2474                    else if ( seq == 2 ) _get_name_from_long( buf, lfn2 );
2475                    else if ( seq == 3 ) _get_name_from_long( buf, lfn3 );
2476                    offset = offset + 32;
2477                }
2478                else                                    // NORMAL entry
2479                {
2480                    // build the full mame for current directory entry
2481                    if      ( lfn == 0 )
2482                    {
2483                        _get_name_from_short( buf , cname );
2484                    }
2485                    else if ( lfn == 1 )
2486                    {
2487                        _strcpy( cname      , lfn1 );
2488                    }   
2489                    else if ( lfn == 2 ) 
2490                    {
2491                        _strcpy( cname      , lfn1 );
2492                        _strcpy( cname + 13 , lfn2 );
2493                    }
2494                    else if ( lfn == 3 ) 
2495                    {
2496                        _strcpy( cname      , lfn1 );
2497                        _strcpy( cname + 13 , lfn2 );
2498                        _strcpy( cname + 26 , lfn3 );
2499                    }
2500                   
2501                    // test if extracted name == searched name
2502                    if ( _strncmp( name , cname , length ) == 0 )
2503                    {
2504                        child_cluster = (_read_entry( DIR_FST_CLUS_HI , buf , 1 ) << 16) |
2505                                        (_read_entry( DIR_FST_CLUS_LO , buf , 1 )      ) ;
2506                        child_is_dir  = ((attr & ATTR_DIRECTORY) == ATTR_DIRECTORY);
2507                        child_size    = _read_entry( DIR_FILE_SIZE , buf , 1 );
2508                        found         = 1;
2509                    }
2510                    offset = offset + 32;
2511                    lfn = 0;
2512                }
2513            }  // en loop on directory entries
2514           
2515            // compute next cluster index
2516            unsigned int next;
2517            if ( _next_cluster_no_cache ( parent_cluster , &next ) ) return 1;
2518            parent_cluster = next;
2519        } // end loop on clusters
2520
2521        if ( found == 2 )  // found end of directory => error
2522        { 
2523            _printf("\n[FAT ERROR] in _file_info_no_cache() : <%s> not found\n",
2524                    name );
2525            return 1;
2526        }
2527 
2528        // check type
2529        if ( ((pathname[nb_read] == 0) && (child_is_dir != 0)) ||
2530             ((pathname[nb_read] != 0) && (child_is_dir == 0)) )
2531        {
2532            _printf("\n[FAT ERROR] in _file_info_no_cache() : illegal type for <%s>\n", name );
2533            return 1;
2534        }
2535
2536        // update parent_cluster for next name
2537        parent_cluster = child_cluster;
2538
2539    }  // end loop on names
2540
2541#if (GIET_DEBUG_FAT & 1)
2542if ( _get_proctime() > GIET_DEBUG_FAT )
2543_printf("\n[DEBUG FAT] _file_info_no_cache() : success for <%s> / "
2544        "file_size = %x / file_cluster = %x\n", pathname, child_size, child_cluster );
2545#endif
2546
2547    // return file cluster and size
2548    *file_size    = child_size;
2549    *file_cluster = child_cluster;
2550    return 0;
2551
2552}  // end _file_info_no_cache()
2553
2554
2555
2556/////////////////////////////////////////////////////////////////////////////
2557/////////////////////////////////////////////////////////////////////////////
2558//             Extern functions                                               
2559/////////////////////////////////////////////////////////////////////////////
2560/////////////////////////////////////////////////////////////////////////////
2561
2562
2563/////////////////////////////////////////////////////////////////////////////
2564// This function initializes the FAT structures.
2565// - The Fat-Descriptor is always initialised.
2566// - The dynamically allocated structures (the Inode-Tre, the Fat_Cache,
2567//   and the File-Cache for the root directory) are only allocated
2568//   and initialised if the "kernel_mode" argument is set.
2569/////////////////////////////////////////////////////////////////////////////
2570// Implementation note:
2571// This function is called twice, by the boot-loader, and by the kernel_init.
2572// It does not use dynamic memory allocation from the distributed heap.
2573// It use informations found in the boot sector and FS-INFO sector.
2574// that are loaded in the Fat-Descriptor temporary block_buffer.
2575/////////////////////////////////////////////////////////////////////////////
2576// Returns 0 if success.
2577// Returns -1 if error.
2578/////////////////////////////////////////////////////////////////////////////
2579int _fat_init( unsigned int kernel_mode ) 
2580{
2581
[258]2582#if GIET_DEBUG_FAT
[569]2583if ( _get_proctime() > GIET_DEBUG_FAT )
[587]2584_printf("\n[DEBUG FAT] _fat_init() : enters at cycle %d\n", _get_proctime() );
[258]2585#endif
[458]2586
2587    // FAT initialisation should be done only once
[530]2588    if ( _fat.initialised == FAT_INITIALISED )
[458]2589    {
[587]2590        _printf("\n[FAT ERROR] in _fat_init() : FAT already initialised\n");
2591        return -1;
[458]2592    }
2593
[587]2594    // load Boot sector (VBR) into FAT buffer
2595    if ( _fat_ioc_access( 0,                                  // no descheduling
2596                          1,                                  // read
2597                          0,                                  // block index
2598                          (unsigned int)_fat.block_buffer,
2599                          1 ) )                               // one block
[258]2600    {
[503]2601        _printf("\n[FAT ERROR] in _fat_init() cannot load VBR\n");
[587]2602        return -1;
[258]2603    }
2604
[587]2605    _fat.block_buffer_lba = 0;
2606   
2607#if GIET_DEBUG_FAT
[569]2608if ( _get_proctime() > GIET_DEBUG_FAT )
[587]2609{
2610    _printf("\n[DEBUG FAT] _fat_init() : Boot sector loaded\n");
2611    _display_one_block( _fat.block_buffer, "block device", _fat.block_buffer_lba );
2612}
[258]2613#endif
2614
2615    // checking various FAT32 assuptions from boot sector
[587]2616    if( _read_entry( BPB_BYTSPERSEC, _fat.block_buffer, 1 ) != 512 )
[258]2617    {
[503]2618        _printf("\n[FAT ERROR] The sector size must be 512 bytes\n");
[587]2619        return -1;
[258]2620    }
[587]2621    if( _read_entry( BPB_SECPERCLUS, _fat.block_buffer, 1 ) != 8 )
[258]2622    {
[587]2623        _printf("\n[FAT ERROR] The cluster size must be 8 blocks\n");
2624        return -1;
2625    }
2626    if( _read_entry( BPB_NUMFATS, _fat.block_buffer, 1 ) != 1 )
2627    {
[503]2628        _printf("\n[FAT ERROR] The number of FAT copies in FAT region must be 1\n");
[587]2629        return -1;
[258]2630    }
[587]2631    if( (_read_entry( BPB_FAT32_FATSZ32, _fat.block_buffer, 1 ) & 0xF) != 0 )
[258]2632    {
[587]2633        _printf("\n[FAT ERROR] The FAT region must be multiple of 16 sectors\n");
2634        return -1;
[258]2635    }
[587]2636    if( _read_entry( BPB_FAT32_ROOTCLUS, _fat.block_buffer, 1 ) != 2 )
[258]2637    {
[587]2638        _printf("\n[FAT ERROR] The root directory must be at cluster 2\n");
2639        return -1;
[258]2640    }
2641
[587]2642    // initialise Fat-Descriptor from VBR
2643    _fat.sector_size         = 512;
2644    _fat.cluster_size        = 4096;
2645    _fat.fat_sectors         = _read_entry( BPB_FAT32_FATSZ32 , _fat.block_buffer , 1 );
2646    _fat.fat_lba             = _read_entry( BPB_RSVDSECCNT , _fat.block_buffer , 1 );
2647    _fat.data_sectors        = _fat.fat_sectors << 10;
[530]2648    _fat.data_lba            = _fat.fat_lba + _fat.fat_sectors;
[587]2649    _fat.fs_info_lba         = _read_entry( BPB_FAT32_FSINFO , _fat.block_buffer , 1 );
2650    _fat_buffer_fat_lba      = 0xFFFFFFFF;
2651    _fat_buffer_data_lba     = 0xFFFFFFFF;
[530]2652    _fat.initialised         = FAT_INITIALISED;
[258]2653
[587]2654    // load FS_INFO sector into FAT buffer
2655    if ( _fat_ioc_access( 0,                                // no descheduling
2656                          1,                                // read
2657                          _fat.fs_info_lba,                 // lba
2658                          (unsigned int)_fat.block_buffer,
2659                          1 ) )                             // one block
2660    { 
2661        _printf("\n[FAT ERROR] in _fat_init() cannot load FS_INFO Sector\n"); 
2662        return -1;
2663    }
[458]2664
[587]2665    _fat.block_buffer_lba = _fat.fs_info_lba;
[258]2666
[291]2667#if GIET_DEBUG_FAT
[569]2668if ( _get_proctime() > GIET_DEBUG_FAT )
[587]2669{
2670    _printf("\n[DEBUG FAT] _fat_init() : FS-INFO sector loaded\n");
2671    _display_one_block( _fat.block_buffer, "block device", _fat.block_buffer_lba );
2672}
[291]2673#endif
2674
[587]2675    // initialise Fat-Descriptor from FS_INFO
2676    _fat.free_clusters_number   = _read_entry( FS_FREE_CLUSTERS    , _fat.block_buffer, 1);
2677    _fat.first_free_cluster     = _read_entry( FS_FREE_CLUSTER_HINT, _fat.block_buffer, 1);
[291]2678
[587]2679    // This is done only when the _fat_init() is called in kernel mode
[291]2680
[587]2681    if ( kernel_mode )
2682    {
2683        unsigned int   n;
2684
2685        // allocate and initialise the Inode-Tree root
2686        fat_inode_t*      inode  = _malloc( sizeof(fat_inode_t) );
2687        fat_cache_node_t* cache  = _malloc( sizeof(fat_cache_node_t) );
2688
2689        inode->parent   = NULL;        // no parent
2690        inode->next     = NULL;        // no brother
2691        inode->child    = NULL;        // children come later
2692        inode->cache    = cache;       // empty cache
2693        inode->cluster  = 2;           // forced value
2694        inode->size     = 0;           // no size for a directory
2695        inode->count    = 0;           // children come later
2696        inode->dentry   = 0;           // no parent => no dentry
2697        inode->levels   = 1;           // one level cache
2698        inode->is_dir   = 1;           // it's a directory
2699        _strcpy( inode->name , "/" ); 
2700
2701        for ( n = 0 ; n < 64 ; n ++ )  cache->children[n] = NULL;
2702
2703        _fat.inode_tree_root = inode;
2704
2705        // initialise the lock
2706        _spin_lock_init( &_fat.fat_lock );
2707
2708        // initialise File Descriptor Array
2709        for( n = 0 ; n < GIET_OPEN_FILES_MAX ; n++ ) _fat.fd[n].allocated = 0;
2710
2711        // initialise fat_cache root
2712        fat_cache_node_t*  fat_cache_root = _malloc( sizeof(fat_cache_node_t) );
2713        _fat.fat_cache_root   = fat_cache_root;
2714        _fat.fat_cache_levels = _get_levels_from_size( _fat.fat_sectors << 9 );
2715        for ( n = 0 ; n < 64 ; n++ ) _fat.fat_cache_root->children[n] = NULL;
2716
2717    }  // end if kernel_mode
2718
[291]2719#if GIET_DEBUG_FAT
[569]2720if ( _get_proctime() > GIET_DEBUG_FAT )
[587]2721_display_fat_descriptor();
[291]2722#endif
2723
[258]2724    return 0;
2725}  // end _fat_init()
2726
[587]2727
2728
2729
[258]2730///////////////////////////////////////////////////////////////////////////////
[587]2731// This function implements the giet_fat_open() system call.
2732// The semantic is similar to the UNIX open() function, but only the O_CREATE
2733// and O_RDONLY flags are supported. The UNIX access rights are not supported.
2734// If the file does not exist in the specified directory, it is created.
2735// If the specified directory does not exist, an error is returned.
2736// It allocates a file descriptor to the calling task, for the file identified
2737// by "pathname". If several tasks try to open the same file, each task 
2738// obtains a private file descriptor.
2739// A node name (file or directory) cannot be larger than 31 characters.
[258]2740///////////////////////////////////////////////////////////////////////////////
[587]2741// Returns file descriptor index if success
2742// Returns a negative value if error:
2743//   -1  :  "fat not initialised"
2744//   -2  :  "path to parent not found"
2745//   -3  :  "one name in path too long"
2746//   -4  :  "file not found"
2747//   -5  :  "Cannot update parent directory"
2748//   -6  :  "Cannot update DATA region"
2749//   -7  :  "Cannot update FAT region"
2750//   -8  :  "Cannot update FS_INFO sector"
2751//   -9  :  "file descriptor array full"
[258]2752///////////////////////////////////////////////////////////////////////////////
[587]2753int _fat_open( char*        pathname,     // absolute path from root
2754               unsigned int flags )       // O_CREATE and O_RDONLY
[258]2755{
[587]2756    unsigned int         fd_id;            // index in File-Descriptor-Array
2757    unsigned int         code;             // error code
2758    fat_inode_t*         inode;            // anonymous inode pointer
2759    fat_inode_t*         child;            // pointer on searched file inode
2760    fat_inode_t*         parent;           // pointer on parent directory inode
[258]2761   
[587]2762    // get flags
2763    unsigned int create    = ((flags & O_CREATE) != 0);
2764    unsigned int read_only = ((flags & O_RDONLY) != 0); 
2765
[258]2766#if GIET_DEBUG_FAT
[295]2767unsigned int procid  = _get_procid();
[429]2768unsigned int x       = procid >> (Y_WIDTH + P_WIDTH);
2769unsigned int y       = (procid >> P_WIDTH) & ((1<<Y_WIDTH)-1);
2770unsigned int p       = procid & ((1<<P_WIDTH)-1);
[569]2771if ( _get_proctime() > GIET_DEBUG_FAT )
[587]2772_printf("\n[DEBUG FAT] _fat_open() : P[%d,%d,%d] enters for path <%s> / "
2773        " create = %d / read_only = %d\n",
2774        x, y, p, pathname , create , read_only );
[258]2775#endif
2776
[458]2777    // checking FAT initialised
[530]2778    if( _fat.initialised != FAT_INITIALISED )
[458]2779    {
[503]2780        _printf("\n[FAT ERROR] in _fat_open() : FAT not initialised\n");
[458]2781        return -1;
2782    }
[587]2783
2784    // takes the lock
[530]2785    _spin_lock_acquire( &_fat.fat_lock );
[295]2786
[587]2787    // get inode pointer
2788    code = _get_inode_from_path( pathname , &inode );
2789
2790    if ( code == 2 ) 
[258]2791    {
[587]2792        _spin_lock_release( &_fat.fat_lock );
2793        _printf("\n[FAT ERROR] in _fat_open() : path to parent not found"
2794                " for file <%s>\n", pathname );
2795        return -2;
2796    }
2797    else if ( code == 3 ) 
2798    {
2799        _spin_lock_release( &_fat.fat_lock );
2800        _printf("\n[FAT ERROR] in _fat_open() : one name in path too long"
2801                " for file <%s>\n", pathname );
2802        return -3;
2803    }
2804    else if ( (code == 1) && (create == 0) )   
2805    {
2806        _spin_lock_release( &_fat.fat_lock );
2807        _printf("\n[FAT ERROR] in _fat_open() : file not found"
2808                " for file <%s>\n", pathname );
2809        return -4;
2810    }
2811    else if ( (code == 1) && (create != 0) )   // file name not found => create
2812    {
2813        // set parent inode pointer
2814        parent = inode;
[258]2815
2816#if GIET_DEBUG_FAT
[569]2817if ( _get_proctime() > GIET_DEBUG_FAT )
[587]2818_printf("\n[DEBUG FAT] _fat_open() : P[%d,%d,%d] create a new file <%s>\n",
2819        x , y , p , pathname );
[258]2820#endif
[291]2821
[587]2822        // get new file name / error check already done by _get_inode_from_path()
2823        char name[32];       
2824        _get_last_name( pathname , name );
2825
2826        // allocate a new inode and an empty Cache-File
2827        child = _allocate_one_inode( name,
2828                                     0,                         // not a directory
2829                                     END_OF_CHAIN_CLUSTER_MAX,  // no cluster allocated
2830                                     0,                         // size : new file is empty
2831                                     0,                         // count incremented later
2832                                     0,                         // dentry set by add_dir_entry
2833                                     1 );                       // cache_allocate
2834
2835        // introduce inode into Inode-Tree
2836        _add_inode_in_tree( child , parent );
2837
2838        // add an entry in the parent directory Cache_file
2839        if ( _add_dir_entry( child , parent ) )
[258]2840        {
[587]2841            _spin_lock_release( &_fat.fat_lock );
2842            _printf("\n[FAT ERROR] in _fat_open() : cannot update parent directory"
2843                    " for file <%s>\n" , pathname );
2844            return -5;
2845        } 
2846
2847        // update DATA region on block device for parent directory
2848        if ( _update_device_from_cache( parent->levels,
2849                                        parent->cache,
2850                                        parent->name ) )
2851        {
2852            _spin_lock_release( &_fat.fat_lock );
2853            _printf("\n[FAT ERROR] in _fat_open() : cannot update DATA region "
2854                    " for parent of file <%s>\n", pathname );
2855            return -6;
[258]2856        }
2857
[587]2858        // update FAT region on block device
2859        if ( _update_device_from_cache( _fat.fat_cache_levels,
2860                                        _fat.fat_cache_root,
2861                                        "FAT" ) )
[258]2862        {
[587]2863            _spin_lock_release( &_fat.fat_lock );
2864            _printf("\n[FAT ERROR] in _fat_open() : cannot update FAT region"
2865                    " for file <%s>\n", pathname );
2866            return -7;
[258]2867        }
[587]2868
2869        // update FS_INFO sector
2870        if ( _update_fs_info() )
[258]2871        {
[530]2872            _spin_lock_release( &_fat.fat_lock );
[587]2873            _printf("\n[FAT ERROR] in _fat_open() : cannot update FS-INFO"
2874                    " for file <%s>\n", pathname );
2875            return -8;
[258]2876        }
2877    }
[587]2878    else // code == 0
2879    {
2880        // set searched file inode pointer
2881        child = inode;
[258]2882
[417]2883#if GIET_DEBUG_FAT
[569]2884if ( _get_proctime() > GIET_DEBUG_FAT )
[587]2885_printf("\n[DEBUG FAT] _fat_open() : P[%d,%d,%d] found file <%s> on device : inode = %x\n",
2886        x , y , p , pathname , child );
[417]2887#endif
2888
[587]2889    }
[258]2890
[587]2891    // Search an empty slot in file descriptors array
2892    fd_id = 0;
2893    while ( (_fat.fd[fd_id].allocated) != 0 && (fd_id < GIET_OPEN_FILES_MAX) )
[258]2894    {
[587]2895        fd_id++;
2896    }
2897
2898    // set file descriptor if an empty slot has been found
2899    if ( fd_id < GIET_OPEN_FILES_MAX )
2900    {
2901        // update file descriptor
2902        _fat.fd[fd_id].allocated  = 1;
2903        _fat.fd[fd_id].seek       = 0;
2904        _fat.fd[fd_id].read_only  = read_only;
2905        _fat.fd[fd_id].inode      = child;
2906
2907        // increment the refcount
2908        child->count = child->count + 1;
2909
2910        // releases the lock
2911        _spin_lock_release( &_fat.fat_lock );
2912
2913#if GIET_DEBUG_FAT
2914if ( _get_proctime() > GIET_DEBUG_FAT )
2915_printf("\n[DEBUG FAT] _fat_open() : P[%d,%d,%d] got fd = %d for <%s> / "
2916        "read_only = %d\n",
2917        x , y , p , fd_id , pathname , read_only );
2918#endif
2919        return fd_id;
2920    }
2921    else
2922    {
2923        _spin_lock_release( &_fat.fat_lock );
2924        _printf("\n[FAT ERROR] in _fat_open() : File-Descriptors-Array full\n");
2925        return -9;
2926    }
2927} // end _fat_open()
2928
2929
2930
2931
2932/////////////////////////////////////////////////////////////////////////////////
2933// This function implements the "giet_fat_close()" system call.
2934// It decrements the inode reference count, and release the fd_id entry
2935// in the file descriptors array.
2936// If the reference count is zero, it writes all dirty clusters on block device,
2937// and releases the memory allocated to the file_cache: The cache 64-Tree
2938// infrastructure (depending on file size) is kept, but all buffers and all
2939// buffer descriptors are released.
2940/////////////////////////////////////////////////////////////////////////////////
2941// Returns 0 on success.
2942// Returns negative value if error:
2943//  -1  : "FAT not initialised"
2944//  -2  : "Illegal file descriptor"
2945//  -3  : "Cannot update DATA region for closed file"
2946//  -4  : "Cannot release memory"
2947/////////////////////////////////////////////////////////////////////////////////
2948int _fat_close( unsigned int fd_id )
2949{
2950    // checking FAT initialised
2951    if( _fat.initialised != FAT_INITIALISED )
2952    {
2953        _printf("\n[FAT ERROR] in _fat_close() : FAT not initialised\n");
2954        return -1;
2955    }
2956
2957    if( (fd_id >= GIET_OPEN_FILES_MAX) )
2958    {
2959        _printf("\n[FAT ERROR] in _fat_close() : illegal file descriptor index\n");
2960        return -2;
2961    } 
2962
2963    // takes lock
2964    _spin_lock_acquire( &_fat.fat_lock );
2965
2966    // get the inode pointer
2967    fat_inode_t*  inode = _fat.fd[fd_id].inode;
2968
2969    // decrement reference count
2970    inode->count = inode->count - 1;
2971   
2972#if GIET_DEBUG_FAT
2973if ( _get_proctime() > GIET_DEBUG_FAT )
2974_printf("\n[FAT DEBUG] _fat_close() for file <%s> : refcount = %d\n",
2975        inode->name , inode->count );
2976#endif
2977
2978    // update block device and release File-Cache if no more references
2979    if ( inode->count == 0 )
2980    {
2981        // update all dirty clusters for closed file
2982        if ( _update_device_from_cache( inode->levels, 
2983                                        inode->cache,
2984                                        inode->name ) ) 
[258]2985        {
[587]2986            _spin_lock_release( &_fat.fat_lock );
2987            _printf("\n[FAT ERROR] in _fat_close() : cannot write dirty clusters "
2988                    "for file <%s>\n", inode->name );
2989            return -3;
[258]2990        }
2991
[587]2992#if GIET_DEBUG_FAT
2993if ( _get_proctime() > GIET_DEBUG_FAT )
2994_printf("\n[FAT DEBUG] _fat_close() update device for file <%s>\n", inode->name );
2995#endif
2996
2997        // update directory dirty clusters for parent directory
2998        if ( _update_device_from_cache( inode->parent->levels, 
2999                                        inode->parent->cache,
3000                                        inode->parent->name ) ) 
[258]3001        {
[587]3002            _spin_lock_release( &_fat.fat_lock );
3003            _printf("\n[FAT ERROR] in _fat_close() : cannot write dirty clusters "
3004                    "for directory <%s>\n", inode->parent->name );
3005            return -4;
3006        }
[258]3007
3008#if GIET_DEBUG_FAT
[569]3009if ( _get_proctime() > GIET_DEBUG_FAT )
[587]3010_printf("\n[FAT DEBUG] _fat_close() update device for parent directory <%s>\n",
3011        inode->parent->name );
[258]3012#endif
3013
[587]3014        // release memory allocated to File-Cache
3015        if ( _release_cache_memory( inode->cache,
3016                                    inode-> levels ) )
[258]3017        {
[530]3018            _spin_lock_release( &_fat.fat_lock );
[587]3019            _printf("\n[FAT ERROR] in _fat_close() : cannot release cache memory "
3020                    "for file <%s>\n", _fat.fd[fd_id].inode->name );
3021            return -5;
[258]3022        }
[587]3023
3024#if GIET_DEBUG_FAT
3025if ( _get_proctime() > GIET_DEBUG_FAT )
3026_printf("\n[FAT DEBUG] _fat_close() release memory for File-Cache <%s>\n",
3027        inode->name );
3028#endif
3029
[258]3030    }
[587]3031
3032    // release fd_id entry in file descriptor array
3033    _fat.fd[fd_id].allocated = 0;
3034
3035    // release lock
3036    _spin_lock_release( &_fat.fat_lock );
3037
3038    return 0;
3039} // end fat_close()
3040
3041
3042
3043
3044/////////////////////////////////////////////////////////////////////////////////
3045// This function implements the giet_fat_file_info() system call.
3046// It returns the size and the current offset value for a file identified
3047// by the "fd_id" argument.
3048/////////////////////////////////////////////////////////////////////////////////
3049// Returns  0 if success.
3050// Returns negative value if error.
3051//  -1  : "FAT not initialised"
3052//  -2  : "Illegal file descriptor"
3053//  -3  : "File not open"
3054/////////////////////////////////////////////////////////////////////////////////
3055int _fat_file_info( unsigned int   fd_id,
3056                    unsigned int*  size,
3057                    unsigned int*  offset )
3058{
3059    // checking FAT initialised
3060    if( _fat.initialised != FAT_INITIALISED )
[258]3061    {
[587]3062        _printf("\n[FAT ERROR] in _fat_file_info() : FAT not initialised\n");
[258]3063        return -1;
3064    }
3065
3066
[587]3067    if( fd_id >= GIET_OPEN_FILES_MAX )
3068    {
3069        _printf("\n[FAT ERROR] in _fat_file_info() : illegal file descriptor index\n");
3070        return -2;
3071    } 
[258]3072
[587]3073    if ( _fat.fd[fd_id].allocated == 0 )
3074    {
3075        _printf("\n[FAT ERROR] in _fat_file_info() : file <%s> not open\n",
3076                _fat.fd[fd_id].inode->name );
3077        return -3;
[258]3078    }
[587]3079
3080    *size   = _fat.fd[fd_id].inode->size;
3081    *offset = _fat.fd[fd_id].seek; 
3082    return 0;
3083
3084} // end _fat_file_info()
3085
3086
3087
3088
3089/////////////////////////////////////////////////////////////////////////////////
3090// The following function implements the "giet_fat_read()" system call.
3091// It transfers "count" bytes from the File_Cache associated to the file
3092// identified by "fd_id", to the user "buffer", from the current file offset.
3093// It has the same semantic as the UNIX "read()" function.
3094// In case of miss in the File_Cache, it loads all involved clusters into cache.
3095/////////////////////////////////////////////////////////////////////////////////
3096// Returns number of bytes actually transfered if success .
3097// Returns 0 if EOF encountered (offset + count > file_size).
3098// Returns a negative value if error:
3099//   -1 :  "fat not initialised"
3100//   -2 :  "file not open"
3101//   -3 :  "cannot load file from device"
3102/////////////////////////////////////////////////////////////////////////////////
3103int _fat_read( unsigned int fd_id,     // file descriptor index
3104               void*        buffer,    // destination buffer
3105               unsigned int count )    // number of bytes to read
3106{
3107    // checking FAT initialised
3108    if( _fat.initialised != FAT_INITIALISED )
[258]3109    {
[587]3110        _printf("\n[FAT ERROR] in _fat_write() : FAT not initialised\n");
[258]3111        return -1;
3112    }
[587]3113
3114    // check fd_id overflow
3115    if ( fd_id >= GIET_OPEN_FILES_MAX )
[258]3116    {
[587]3117        _printf("\n[FAT ERROR] in _fat_read() : illegal file descriptor\n");
[258]3118        return -1;
3119    }
[358]3120
[587]3121    // check file is open
3122    if ( _fat.fd[fd_id].allocated == 0 )
3123    {
3124        _printf("\n[FAT ERROR] in _fat_read() : file not open\n");
3125        return -2;
3126    }
[358]3127
[587]3128    // takes lock
3129    _spin_lock_acquire( &_fat.fat_lock );
3130           
3131    // get file inode pointer and offset
3132    fat_inode_t* inode  = _fat.fd[fd_id].inode;
3133    unsigned int seek   = _fat.fd[fd_id].seek;
3134
3135    // check count & seek versus file size
3136    if ( count + seek > inode->size )
[258]3137    {
[587]3138        _spin_lock_release( &_fat.fat_lock );
3139        _printf("\n[FAT ERROR] in _fat_read() : file too small"
3140                " / seek = %x / count = %x / file_size = %x\n",
3141                seek , count , inode->size );
3142        return 0;
[258]3143    }
3144
[587]3145    // compute first_cluster_id and first_byte_to_move
3146    unsigned int first_cluster_id   = seek >> 12;
3147    unsigned int first_byte_to_move = seek & 0xFFF;   
[258]3148
[587]3149    // compute last_cluster and last_byte_to_move
3150    unsigned int last_cluster_id   = (seek + count - 1) >> 12;   
3151    unsigned int last_byte_to_move = (seek + count - 1) & 0xFFF;
[258]3152
3153#if GIET_DEBUG_FAT
[354]3154unsigned int procid  = _get_procid();
[429]3155unsigned int x       = procid >> (Y_WIDTH + P_WIDTH);
3156unsigned int y       = (procid >> P_WIDTH) & ((1<<Y_WIDTH)-1);
3157unsigned int p       = procid & ((1<<P_WIDTH)-1);
[569]3158if ( _get_proctime() > GIET_DEBUG_FAT )
[587]3159_printf("\n[DEBUG FAT] _fat_read() : P[%d,%d,%d] enters for file <%s> "
3160        " / bytes = %x / offset = %x\n"
3161        "first_cluster_id = %x / first_byte_to_move = %x"
3162        " / last_cluster_id = %x / last_byte_to_move = %x\n",
3163        x , y , p , inode->name , count , seek ,
3164        first_cluster_id , first_byte_to_move , last_cluster_id , last_byte_to_move );
[258]3165#endif
3166
[587]3167    // loop on all cluster covering the requested transfer
3168    unsigned int cluster_id;
3169    unsigned int done = 0;
3170    for ( cluster_id = first_cluster_id ; cluster_id <= last_cluster_id ; cluster_id++ )
[258]3171    {
[587]3172        // get pointer on the cluster_id buffer in cache
3173        unsigned char*     cbuf;
3174        fat_cache_desc_t*  pdesc;
3175        if ( _get_buffer_from_cache( inode, 
3176                                     cluster_id,
3177                                     &pdesc ) )
3178        {
3179            _spin_lock_release( &_fat.fat_lock );
3180            _printf("\n[FAT ERROR] in _fat_read() : cannot load file <%s>\n",
3181                    inode->name );
3182            return -3;
3183        }
3184        cbuf = pdesc->buffer;
3185
3186#if GIET_DEBUG_FAT
3187if ( _get_proctime() > GIET_DEBUG_FAT )
3188_printf("\n[DEBUG FAT] _fat_read() : P[%d,%d,%d] moves cluster_id %d from Cache-File <%s>\n",
3189        x , y , p , cluster_id, inode->name );
3190#endif
3191
3192        // compute memcpy arguments
3193        unsigned char*  source;
3194        unsigned int    nbytes;
3195        unsigned char*  dest = (unsigned char*)buffer + done;
3196        if ( (cluster_id == first_cluster_id) && (cluster_id == last_cluster_id) )
3197        {
3198            source = cbuf + first_byte_to_move; 
3199            nbytes = last_byte_to_move - first_byte_to_move + 1;
3200        }
3201        else if ( cluster_id == first_cluster_id )
3202        {
3203            source = cbuf + first_byte_to_move; 
3204            nbytes = 4096 - first_byte_to_move;
3205        }
3206        else if ( cluster_id == last_cluster_id )
3207        {
3208            source = cbuf; 
3209            nbytes = last_byte_to_move + 1;
3210        }
3211        else  // not first / not last
3212        {
3213            source = cbuf; 
3214            nbytes = 4096;
3215        }
3216
3217        // move data
3218        memcpy( dest , source , nbytes );
3219        done = done + nbytes;
[258]3220    }
3221
[587]3222#if GIET_DEBUG_FAT
3223if ( _get_proctime() > GIET_DEBUG_FAT )
3224_printf("\n[DEBUG FAT] _fat_read() : P[%d,%d,%d] loaded file <%s> from Cache-File\n",
3225        x , y , p , inode->name );
3226#endif
[258]3227
[587]3228    // update seek
3229    _fat.fd[fd_id].seek += done;
[258]3230
[587]3231    // release lock
3232    _spin_lock_release( &_fat.fat_lock );
3233
3234    return done;
3235} // end _fat_read()
3236
3237
3238
3239
3240/////////////////////////////////////////////////////////////////////////////////
3241// The following function implements the "giet_fat_write()" system call.
3242// It transfers "count" bytes to the fat_cache associated to the file
3243// identified by "fd_id", from the user "buffer", using the current file offset.
3244// It has the same semantic as the UNIX "write()" function.
3245// It increases the file size and allocate new clusters if (count + offset)
3246// is larger than the current file size. Then it loads and updates all
3247// involved clusters in the cache.
3248/////////////////////////////////////////////////////////////////////////////////
3249// Returns number of bytes actually written if success.
3250// Returns a negative value if error:
3251//   -1 :  "FAT not initialised"
3252//   -2 :  "Illegal file descriptor"
3253//   -3 :  "File not open"
3254//   -4 :  "File not writable"
3255//   -5 :  "No free clusters"
3256//   -6 :  "Cannot update parent directory entry"
3257//   -7 :  "Cannot access File-Cache"
3258/////////////////////////////////////////////////////////////////////////////////
3259int _fat_write( unsigned int fd_id,    // file descriptor index
3260                void*        buffer,   // source buffer
3261                unsigned int count )   // number of bytes to write
3262{
3263    // checking FAT initialised
3264    if( _fat.initialised != FAT_INITIALISED )
[258]3265    {
[587]3266        _printf("\n[FAT ERROR] in _fat_write() : FAT not initialised\n");
3267        return -1;
3268    }
[258]3269
[587]3270    // takes lock
3271    _spin_lock_acquire( &_fat.fat_lock );
3272           
3273    // check fd_id overflow
3274    if ( fd_id >= GIET_OPEN_FILES_MAX )
3275    {
3276        _spin_lock_release( &_fat.fat_lock );
3277        _printf("\n[FAT ERROR] in _fat_write() : illegal file descriptor\n");
3278        return -2;
3279    }
3280
3281    // check file open
3282    if ( _fat.fd[fd_id].allocated == 0 )
3283    {
3284        _spin_lock_release( &_fat.fat_lock );
3285        _printf("\n[FAT ERROR] in _fat_write() : file not open\n" );
3286        return -3;
3287    }
3288
3289    // check file writable
3290    if ( _fat.fd[fd_id].read_only )
3291    {
3292        _spin_lock_release( &_fat.fat_lock );
3293        _printf("\n[FAT ERROR] in _fat_write() : file <%s> is read-only\n",
3294                _fat.fd[fd_id].inode->name );
3295        return -4;
3296    }
3297
3298    // get file inode pointer and seek
3299    fat_inode_t* inode  = _fat.fd[fd_id].inode;
3300    unsigned int seek   = _fat.fd[fd_id].seek;
3301
[258]3302#if GIET_DEBUG_FAT
[587]3303unsigned int procid  = _get_procid();
3304unsigned int x       = procid >> (Y_WIDTH + P_WIDTH);
3305unsigned int y       = (procid >> P_WIDTH) & ((1<<Y_WIDTH)-1);
3306unsigned int p       = procid & ((1<<P_WIDTH)-1);
[569]3307if ( _get_proctime() > GIET_DEBUG_FAT )
[587]3308_printf("\n[DEBUG FAT] _fat_write() : P[%d,%d,%d] enters for file <%s> "
3309        " / bytes = %x / seek = %x\n",
3310        x , y , p , inode->name , count , seek );
[258]3311#endif
3312
[587]3313    // chek if file size must be incremented
3314    // and allocate new clusters from FAT if required
3315    unsigned int old_size = inode->size;
3316    unsigned int new_size = seek + count;
3317    if ( new_size > old_size )
3318    {
3319        // update size in inode
3320        inode->size = new_size;
3321 
3322        // compute current and required numbers of clusters
3323        unsigned old_clusters = old_size >> 12;
3324        if ( old_size & 0xFFF ) old_clusters++;
3325
3326        unsigned new_clusters = new_size >> 12;
3327        if ( new_size & 0xFFF ) new_clusters++;
3328
3329        // allocate new clusters from FAT if required
3330        if ( new_clusters > old_clusters )
[258]3331        {
[587]3332
3333#if GIET_DEBUG_FAT
3334if ( _get_proctime() > GIET_DEBUG_FAT )
3335_printf("\n[DEBUG FAT] _fat_write() : P[%d,%d,%d] allocates new clusters for file <%s>"
3336        " / current = %d / required = %d\n",
3337        x , y , p , inode->name , old_clusters , new_clusters );
3338#endif
3339            // allocate missing clusters
3340            if ( _clusters_allocate( inode,
3341                                     old_clusters,
3342                                     new_clusters - old_clusters ) )
3343            {
3344                _spin_lock_release( &_fat.fat_lock );
3345                _printf("\n[FAT ERROR] in _fat_write() : no free clusters"
3346                        " for file <%s>\n", _fat.fd[fd_id].inode->name );
3347                return -5;
3348            }
[258]3349        }
3350         
[587]3351        // update parent directory entry (size an cluster index)
3352        if ( _update_dir_entry( inode ) )
3353        {
3354            _spin_lock_release( &_fat.fat_lock );
3355            _printf("\n[FAT ERROR] in _fat_write() : cannot update parent directory entry"
3356                    " for file <%s>\n", _fat.fd[fd_id].inode->name );
3357            return -6;
3358        }
3359           
3360
3361#if GIET_DEBUG_FAT
3362if ( _get_proctime() > GIET_DEBUG_FAT )
3363_printf("\n[DEBUG FAT] _fat_write() : P[%d,%d,%d] updates size for file <%s> / size = %x\n",
3364        x , y , p , inode->name , (new_size - old_size) );
3365#endif
3366
[258]3367    }
3368
[587]3369    // compute first_cluster_id and first_byte_to_move
3370    unsigned int first_cluster_id   = seek >> 12;
3371    unsigned int first_byte_to_move = seek & 0xFFF;   
[258]3372
[587]3373    // compute last_cluster and last_byte_to_move
3374    unsigned int last_cluster_id   = (seek + count - 1) >> 12;   
3375    unsigned int last_byte_to_move = (seek + count - 1) & 0xFFF;
3376
3377#if GIET_DEBUG_FAT
3378if ( _get_proctime() > GIET_DEBUG_FAT )
3379_printf("\n[DEBUG FAT] _fat_write() : P[%d,%d,%d] starts loop on clusters for file <%s>\n"
3380        "  first_cluster_id = %d / first_byte_to_move = %x"
3381        " / last_cluster_id = %d / last_byte_to_move = %x\n",
3382        x , y , p , inode->name ,
3383        first_cluster_id , first_byte_to_move , last_cluster_id , last_byte_to_move );
3384#endif
3385
3386    // loop on all clusters covering the requested transfer
3387    unsigned int cluster_id;
3388    unsigned int done = 0;
3389    for ( cluster_id = first_cluster_id ; cluster_id <= last_cluster_id ; cluster_id++ )
3390    {
3391        // get pointer on one 4K buffer in File-Cache
3392        unsigned char*     cbuf;
3393        fat_cache_desc_t*  pdesc;
3394        if ( _get_buffer_from_cache( inode,   
3395                                     cluster_id, 
3396                                     &pdesc ) )   
3397        {
3398            _spin_lock_release( &_fat.fat_lock );
3399            _printf("\n[FAT ERROR] in _fat_write() : cannot load file <%s>\n",
3400                    inode->name );
3401            return -7;
3402        }
3403       
3404        cbuf         = pdesc->buffer;
3405        pdesc->dirty = 1;
3406   
3407#if GIET_DEBUG_FAT
3408if ( _get_proctime() > GIET_DEBUG_FAT )
3409_printf("\n[DEBUG FAT] _fat_write() : P[%d,%d,%d] move cluster_id %d to Cache-file <%s>\n",
3410        x , y , p , cluster_id, inode->name );
3411#endif
3412
3413        // compute memcpy arguments
3414        unsigned char* source = (unsigned char*)buffer + done;
3415        unsigned char* dest;
3416        unsigned int   nbytes;
3417        if ( (cluster_id == first_cluster_id) && (cluster_id == last_cluster_id) )
3418        {
3419            dest   = cbuf + first_byte_to_move; 
3420            nbytes = last_byte_to_move - first_byte_to_move + 1;
3421        }
3422        else if ( cluster_id == first_cluster_id )
3423        {
3424            dest   = cbuf + first_byte_to_move; 
3425            nbytes = 4096 - first_byte_to_move;
3426        }
3427        else if ( cluster_id == last_cluster_id )
3428        {
3429            dest   = cbuf; 
3430            nbytes = last_byte_to_move + 1;
3431        }
3432        else
3433        {
3434            dest   = cbuf; 
3435            nbytes = 4096;
3436        }
3437
3438        //move date
3439        memcpy( dest , source , nbytes ); 
3440        done = done + nbytes;
3441
3442    } // end for clusters
3443
3444    // update seek
3445    _fat.fd[fd_id].seek += done;
3446
3447#if GIET_DEBUG_FAT
3448if ( _get_proctime() > GIET_DEBUG_FAT )
3449_printf("\n[DEBUG FAT] _fat_write() : P[%d,%d,%d] store file <%s> into Cache-File\n",
3450        x , y , p , inode->name );
3451#endif
3452
3453    // release lock
3454    _spin_lock_release( &_fat.fat_lock );
3455
3456    return done;
3457} // end _fat_write()
3458
3459
3460
3461/////////////////////////////////////////////////////////////////////////////////
3462// The following function implements the "giet_fat_lseek()" system call.
3463// It repositions the seek in the file descriptor "fd_id", according to
3464// the "seek" and "whence" arguments.
3465// It has the same semantic as the UNIX lseek() function.
3466// Accepted values for whence are SEEK_SET and SEEK_CUR.
3467/////////////////////////////////////////////////////////////////////////////////
3468// Returns new seek value (bytes) if success.
3469// Returns negative value if error:
3470//   -1  : "FAT not initialised"
3471//   -2  : "Illegal file descriptor"
3472//   -3  : "File not open"
3473//   -4  : "Illegal whence argument"
3474/////////////////////////////////////////////////////////////////////////////////
3475int _fat_lseek( unsigned int fd_id,
3476                unsigned int seek,
3477                unsigned int whence )
[258]3478{
[587]3479    // checking FAT initialised
3480    if( _fat.initialised != FAT_INITIALISED )
3481    {
3482        _printf("\n[FAT ERROR] in _fat_lseek() : FAT not initialised\n");
3483        return -1;
3484    }
[259]3485
[587]3486    // check fd_id overflow
3487    if ( fd_id >= GIET_OPEN_FILES_MAX )
3488    {
3489        _printf("\n[FAT ERROR] in _fat_lseek() : illegal file descriptor\n");
3490        return -2;
3491    }
[259]3492
[587]3493    // takes lock
3494    _spin_lock_acquire( &_fat.fat_lock );
[259]3495
[587]3496    // check file open
3497    if ( _fat.fd[fd_id].allocated == 0 )
3498    {
3499        _spin_lock_release( &_fat.fat_lock );
3500        _printf("\n[FAT ERROR] in _fat_lseek() : file not open\n");
3501        return -3;
3502    }
[259]3503
[587]3504    unsigned int  new_seek;
[291]3505
[587]3506    // compute new seek
3507    if      ( whence == SEEK_CUR ) new_seek = _fat.fd[fd_id].seek + seek;
3508    else if ( whence == SEEK_SET ) new_seek = seek;
3509    else
3510    {
3511        _spin_lock_release( &_fat.fat_lock );
3512        _printf("\n[FAT ERROR] in _fat_user_lseek() : illegal whence valuel\n");
3513        return -4;
3514    }
[291]3515
[587]3516    // update file descriptor offset
3517    _fat.fd[fd_id].seek = new_seek;
[291]3518
[259]3519#if GIET_DEBUG_FAT
[295]3520unsigned int procid  = _get_procid();
[429]3521unsigned int x       = procid >> (Y_WIDTH + P_WIDTH);
3522unsigned int y       = (procid >> P_WIDTH) & ((1<<Y_WIDTH)-1);
3523unsigned int p       = procid & ((1<<P_WIDTH)-1);
[569]3524if ( _get_proctime() > GIET_DEBUG_FAT )
[587]3525_printf("\n[DEBUG FAT] _fat_lseek() : P[%d,%d,%d] set seek = %x for file <%s>\n",
3526        x , y , p , new_seek , _fat.fd[fd_id].inode->name );
[259]3527#endif
3528
[587]3529    // release lock
3530    _spin_lock_release( &_fat.fat_lock );
3531
3532    return new_seek;
3533}  // end _fat_lseek()
3534
3535
3536
3537/////////////////////////////////////////////////////////////////////////////////
3538// The following function implements the giet_fat_remove() system call.
3539// It deletes the file/directory identified by the "pathname" argument from
3540// the file system, if the remove condition is fulfilled (directory empty,
3541// or file not referenced).
3542// All clusters allocated in the block device DATA region are released.
3543// The FAT region is updated on the block device.
3544// The Inode-Tree is updated.
3545// The associated File_Cache is released.
3546// The Fat_Cache is updated.
3547/////////////////////////////////////////////////////////////////////////////////
3548// Returns 0 if success.
3549// Returns negative value if error
3550//   -1  : "FAT not initialised"
3551//   -2  : "File/Directory not found"
3552//   -3  : "Name too long in path"
3553//   -4  : "Has the wrong type"
3554//   -5  : "File still open"
3555//   -6  : "Cannot scan directory"
3556//   -7  : "Directory not empty"
3557//   -8  : "Cannot remove file/dir from FS"
3558/////////////////////////////////////////////////////////////////////////////////
3559int _fat_remove( char*        pathname,
3560                 unsigned int should_be_dir )
3561{
3562    fat_inode_t*  inode;            // searched file inode pointer
3563
3564#if GIET_DEBUG_FAT
3565unsigned int procid  = _get_procid();
3566unsigned int x       = procid >> (Y_WIDTH + P_WIDTH);
3567unsigned int y       = (procid >> P_WIDTH) & ((1<<Y_WIDTH)-1);
3568unsigned int p       = procid & ((1<<P_WIDTH)-1);
3569if ( _get_proctime() > GIET_DEBUG_FAT )
3570_printf("\n[DEBUG FAT] _fat_remove() : P[%d,%d,%d] enters for path <%s>\n",
3571        x, y, p, pathname );
3572#endif
3573
3574    // checking FAT initialised
3575    if( _fat.initialised != FAT_INITIALISED )
3576    {
3577        _printf("\n[FAT ERROR] in _fat_remove() : FAT not initialised\n");
[259]3578        return -1;
3579    }
[587]3580
3581    // take the lock
3582    _spin_lock_acquire( &_fat.fat_lock );
3583
3584    // get searched file inode
3585    unsigned int code = _get_inode_from_path( pathname , &inode );
3586
3587#if GIET_DEBUG_FAT
3588if ( _get_proctime() > GIET_DEBUG_FAT )
3589_printf("\n[DEBUG FAT] _fat_remove() : P[%d,%d,%d] found inode %x for <%s> / code = %d\n",
3590        x , y , p , (unsigned int)inode , pathname , code );
3591#endif
3592
3593    if ( (code == 1) || (code == 2) )
[259]3594    {
[587]3595        _spin_lock_release( &_fat.fat_lock );
3596        _printf("\n[FAT ERROR] in _fat_remove() : file <%s> not found\n", 
3597                pathname );
3598        return -2;
[259]3599    }
[587]3600    else if ( code == 3 )
[259]3601    {
[587]3602        _spin_lock_release( &_fat.fat_lock );
3603        _printf("\n[FAT ERROR] in _fat_remove() : name too long in <%s>\n",
3604                pathname );
3605        return -3;
[259]3606    }
3607
[587]3608    // check inode type
3609    if ( (inode->is_dir != 0) && (should_be_dir == 0) ) 
[291]3610    {
[587]3611        _spin_lock_release( &_fat.fat_lock );
3612        _printf("\n[FAT ERROR] in _fat_remove() : <%s> is a directory\n",
3613                pathname );
3614        return -4;
3615    }
3616    if ( (inode->is_dir == 0) && (should_be_dir != 0) )
3617    {
3618        _spin_lock_release( &_fat.fat_lock );
3619        _printf("\n[FAT ERROR] in _fat_remove() : <%s> is not a directory\n", 
3620                pathname );
3621        return -4;
3622    }
3623
3624#if GIET_DEBUG_FAT
3625if ( _get_proctime() > GIET_DEBUG_FAT )
3626_printf("\n[DEBUG FAT] _fat_remove() : P[%d,%d,%d] checked inode type for <%s>\n",
3627        x , y , p , pathname );
3628#endif
3629   
3630    // check references count for a file
3631    if ( (inode->is_dir == 0) && (inode->count != 0) )
3632    {
3633        _spin_lock_release( &_fat.fat_lock );
3634        _printf("\n[FAT ERROR] in _fat_remove() : file <%s> still referenced\n",
3635                pathname );
3636        return -5;
3637    }
3638
3639    //  check empty for a directory
3640    if ( inode->is_dir )
3641    {
3642        unsigned int entries;
3643        if ( _get_nb_entries( inode , &entries ) )
[291]3644        {
[587]3645            _spin_lock_release( &_fat.fat_lock );
3646            _printf("\n[FAT ERROR] in _fat_remove() : cannot scan directory <%s>\n", 
3647                    pathname );
3648            return -6;
[291]3649        }
[587]3650        else if ( entries > 2 )
3651        {
3652            _spin_lock_release( &_fat.fat_lock );
3653            _printf("\n[FAT ERROR] in _fat_remove() : directory <%s> not empty\n", 
3654                    pathname );
3655            return -7;
3656        }
[291]3657    }
3658
[587]3659#if GIET_DEBUG_FAT
3660if ( _get_proctime() > GIET_DEBUG_FAT )
3661_printf("\n[DEBUG FAT] _fat_remove() : P[%d,%d,%d] checked remove condition OK for <%s>\n",
3662        x , y , p , pathname );
3663#endif
[259]3664   
[587]3665    // remove the file or directory from the file system
3666    if ( _remove_node_from_fs( inode ) )
3667    {
3668        _spin_lock_release( &_fat.fat_lock );
3669        _printf("\n[FAT ERROR] in _fat_remove() : cannot remove <%s> from FS\n",
3670                pathname );
3671        return -8;
3672    }
[259]3673
[587]3674    // release lock and return success
3675    _spin_lock_release( &_fat.fat_lock );
3676
[259]3677#if GIET_DEBUG_FAT
[569]3678if ( _get_proctime() > GIET_DEBUG_FAT )
[587]3679_printf("\n[DEBUG FAT] _fat_remove() : P[%d,%d,%d] removed  <%s> from FS\n",
3680        x, y, p, pathname );
[259]3681#endif
[587]3682   
3683    return 0;
3684       
3685}  // end _fat_remove()
[259]3686
[587]3687
3688
3689
3690
3691/////////////////////////////////////////////////////////////////////////////////
3692// This function implements the giet_fat_rename() system call.
3693// It moves an existing file or directory from one node (defined by "old_path"
3694// argument) to another node (defined by "new_path" argument) in the FS tree.
3695// The type (file/directory) and content are not modified.
3696// If the new_path file/dir exist, it is removed from the file system, but only 
3697// if the remove condition is respected (directory empty / file not referenced).
3698// The removed entry is only removed after the new entry is actually created.
3699/////////////////////////////////////////////////////////////////////////////////
3700// Returns 0 if success.
3701// Returns a negative value if error:
3702//  -1  : "FAT not initialised"
3703//  -2  : "old_path not found"
3704//  -3  : "new_path not found"
3705//  -4  : "cannot scan to_remove directory"
3706//  -5  : "to_remove directory not empty"
3707//  -6  : "to_remove file still referenced"
3708//  -7  : "cannot add new node to new_parent directory"
3709//  -8  : "cannot update new_parent directory on device"
3710//  -9  : "cannot remove old node from old_parent directory"
3711//  -10 : "cannot update old_parent directory on device"
3712//  -11 : "cannot remove to_remove node from FS"
3713/////////////////////////////////////////////////////////////////////////////////
3714int _fat_rename( char*  old_path,
3715                 char*  new_path )
3716{
3717    fat_inode_t*  inode;        // anonymous inode pointer
3718    fat_inode_t*  old;          // inode identified by old_path      => to be deleted
3719    fat_inode_t*  new;          // inode identified by new_path      => to be created
3720    fat_inode_t*  old_parent;   // parent inode  in old_path         => to be modified
3721    fat_inode_t*  new_parent;   // parent inode  in new_path         => to be modified
3722    fat_inode_t*  to_remove;    // previouly identified by new_path  => to be removed
3723    unsigned int  code;
3724
3725#if GIET_DEBUG_FAT
3726unsigned int procid  = _get_procid();
3727unsigned int x       = procid >> (Y_WIDTH + P_WIDTH);
3728unsigned int y       = (procid >> P_WIDTH) & ((1<<Y_WIDTH)-1);
3729unsigned int p       = procid & ((1<<P_WIDTH)-1);
3730if ( _get_proctime() > GIET_DEBUG_FAT )
3731_printf("\n[DEBUG FAT] _fat_rename() : P[%d,%d,%d] enters to move <%s> to <%s>\n",
3732        x , y , p , old_path , new_path );
3733#endif
3734
3735    // checking FAT initialised
3736    if( _fat.initialised != FAT_INITIALISED )
[259]3737    {
[587]3738        _printf("\n[FAT ERROR] in _fat_rename() : FAT not initialised\n");
3739        return -1;
[259]3740    }
3741
[587]3742    // take the lock
3743    _spin_lock_acquire( &_fat.fat_lock );
[259]3744
[587]3745    // get "old" and "old_parent" inode pointers
3746    if ( _get_inode_from_path( old_path , &inode ) )
3747    {
3748        _spin_lock_release( &_fat.fat_lock );
3749        _printf("\n[FAT ERROR] in _fat_rename() : <%s> not found\n", old_path );
3750        return -2;
3751    }
3752    else
3753    {
3754        old        = inode;
3755        old_parent = inode->parent;
3756    }
[259]3757
[587]3758    // get "to_removed" and "new_parent" inode pointers
3759    code = _get_inode_from_path( new_path , &inode );
3760
3761    if ( code == 0 )       // new_path inode already exist
[259]3762    {
[587]3763        to_remove        = inode;
3764        new_parent       = inode->parent;   
3765    }
3766    else if ( code == 1 )  // to_remove does not exist but parent exist
3767    {
3768        to_remove        = NULL;
3769        new_parent       = inode;
3770    }
3771    else                   // parent directory in new_path not found
3772    {
3773        _spin_lock_release( &_fat.fat_lock );
3774        _printf("\n[FAT ERROR] in _fat_rename() : <%s> not found\n", new_path );
3775        return -3;
3776    }
[259]3777
3778#if GIET_DEBUG_FAT
[569]3779if ( _get_proctime() > GIET_DEBUG_FAT )
[587]3780{
3781if ( to_remove )
3782_printf("\n[DEBUG FAT] _fat_rename() : old_parent = %s / old = %s / new_parent = %s "
3783        "/ to_remove = %s\n",
3784        old_parent->name , old->name , new_parent->name , to_remove->name );
3785else
3786_printf("\n[DEBUG FAT] _fat_rename() : old_parent = %s / old = %s / new_parent = %s "
3787        "/ no remove\n", 
3788        old_parent->name , old->name , new_parent->name );
3789}
[259]3790#endif
3791
[587]3792    // check remove condition for "to_remove" inode
3793    if ( to_remove )
3794    {
3795        if ( to_remove->is_dir )   // it's a directory
[259]3796        {
[587]3797            unsigned int entries;
3798            if ( _get_nb_entries( to_remove , &entries ) )
3799            {
3800                _spin_lock_release( &_fat.fat_lock );
3801                _printf("\n[FAT ERROR] in _fat_rename() : cannot scan directory <%s>\n", 
3802                        to_remove->name );
3803                return -4;
3804            }
3805            else if ( entries > 2 )
3806            {
3807                _spin_lock_release( &_fat.fat_lock );
3808                _printf("\n[FAT ERROR] in _fat_rename() : directory <%s> not empty\n", 
3809                        to_remove->name );
3810                return -5;
3811            }
[259]3812        }
[587]3813        else                       // it's a file
3814        {
3815            if ( to_remove->count ) 
3816            {
3817                _spin_lock_release( &_fat.fat_lock );
3818                _printf("\n[FAT ERROR] in _fat_rename() : file <%s> still referenced\n", 
3819                        to_remove->name );
3820                return -6;
3821            }
3822        }
[259]3823    }
[291]3824
[587]3825#if GIET_DEBUG_FAT
3826if ( _get_proctime() > GIET_DEBUG_FAT )
3827_printf("\n[FAT DEBUG] _fat_rename() : P[%d,%d,%d] checked remove condition OK\n",
3828        x , y , p );
3829#endif
3830
3831    // get new last name / error checking already done by _get_inode_from_path()
3832    char  new_name[32];
3833    _get_last_name( new_path , new_name );
3834
3835    // allocate "new" inode
3836    new = _allocate_one_inode( new_name,
3837                               old->is_dir,
3838                               old->cluster,
3839                               old->size,
3840                               0,              // count
3841                               0,              // dentry
3842                               0 );            // no cache_allocate
3843 
3844    // give the "old" File-Cache to the "new inode
3845    new->levels = old->levels;
3846    new->cache  = old->cache;
3847
3848    // add "new" to "new_parent" directory File-Cache
3849    if ( _add_dir_entry( new , new_parent ) )
[291]3850    {
[587]3851        _spin_lock_release( &_fat.fat_lock );
3852        _printf("\n[FAT ERROR] in _fat_rename() : cannot add <%s> into <%s>\n",
3853                new->name , new_parent->name );
3854        return -7;
[291]3855    }
3856
[587]3857    // add "new" to "new_parent" directory in Inode-Tree
3858    _add_inode_in_tree( new , new_parent );
3859   
3860    // updates "new_parent" directory on device
3861    if ( _update_device_from_cache( new_parent->levels,
3862                                    new_parent->cache,
3863                                    new_parent->name ) )
[291]3864    {
[587]3865        _spin_lock_release( &_fat.fat_lock );
3866        _printf("\n[FAT ERROR] in _fat_rename() : cannot update <%s> on device\n",
3867                    new_parent->name );
3868        return -8;
[291]3869    }
[258]3870
[587]3871    // remove "old" from "old_parent" File-Cache
3872    if ( _remove_dir_entry( old ) )
3873    {
3874        _spin_lock_release( &_fat.fat_lock );
3875        _printf("\n[FAT ERROR] in _fat_rename() : cannot remove <%s> from <%s>\n",
3876                old->name , old_parent->name );
3877        return -9;
3878    }
3879 
3880    // remove "old" inode from Inode-Tree
3881    _remove_inode_from_tree( old );
3882
3883    // updates "old_parent" directory on device
3884    if ( _update_device_from_cache( old_parent->levels,
3885                                    old_parent->cache,
3886                                    old_parent->name ) )
3887    {
3888        _spin_lock_release( &_fat.fat_lock );
3889        _printf("\n[FAT ERROR] in _fat_rename() : cannot update <%s> on device\n",
3890                    old_parent->name );
3891        return -10;
3892    }
3893
3894    // remove "to_remove" from File System (if required)
3895    if ( to_remove )
3896    {
3897        if ( _remove_node_from_fs( to_remove ) )
3898        {
3899            _spin_lock_release( &_fat.fat_lock );
3900            _printf("\n[FAT ERROR] in _fat_rename() : cannot remove <%s> from FS\n",
3901                    to_remove->name );
3902            return -11;
3903        }
3904    }
3905
3906    // release lock
3907    _spin_lock_release( &_fat.fat_lock );
3908
3909    return 0;
3910}  // end _fat_rename()
3911
3912
3913
3914
[258]3915/////////////////////////////////////////////////////////////////////////////////
[587]3916// The following function implements the giet_fat_mkdir() system call.
3917// It creates in file system the directory specified by the "pathname" argument.
3918// The Inode-Tree is updated.
3919// One cluster is allocated to the new directory.
3920// The associated File-Cache is created.
3921// The FAT region on block device is updated.
3922// The DATA region on block device is updated.
[260]3923/////////////////////////////////////////////////////////////////////////////////
[587]3924// Returns 0 if success.
3925// Returns a negative value if error:
3926//   -1  : "Fat not initialised"
3927//   -2  : "Path to parent not found"
3928//   -3  : "One name in path too long"
3929//   -4  : "Directory already exist"
3930//   -5  : "No free cluster"
3931//   -6  : "Cannot update parent directory"
3932//   -7  : "Cannot update parent DATA region"
3933//   -8  : "Cannot update FAT region"
3934//   -9  : "Cannot update FS-INFO"
3935//   -10 : "Cannot update directory DATA region"
[260]3936/////////////////////////////////////////////////////////////////////////////////
[587]3937int _fat_mkdir( char* pathname )
[260]3938{
[587]3939    fat_inode_t*         inode;            // anonymous inode pointer
3940    fat_inode_t*         child;            // searched directory inode pointer
3941    fat_inode_t*         parent;           // parent directory inode pointer
[260]3942
[587]3943#if GIET_DEBUG_FAT
3944unsigned int procid  = _get_procid();
3945unsigned int x       = procid >> (Y_WIDTH + P_WIDTH);
3946unsigned int y       = (procid >> P_WIDTH) & ((1<<Y_WIDTH)-1);
3947unsigned int p       = procid & ((1<<P_WIDTH)-1);
3948if ( _get_proctime() > GIET_DEBUG_FAT )
3949_printf("\n[DEBUG FAT] _fat_mkdir() : P[%d,%d,%d] enters for path <%s>\n",
3950        x, y, p, pathname );
3951#endif
3952
3953    // checking FAT initialised
3954    if( _fat.initialised != FAT_INITIALISED )
[260]3955    {
[587]3956        _printf("\n[FAT ERROR] in _fat_mkdir() : FAT not initialised\n");
3957        return -1;
3958    }
[260]3959
[587]3960    // takes the lock
3961    _spin_lock_acquire( &_fat.fat_lock );
3962   
3963    // get inode
3964    unsigned int code = _get_inode_from_path( pathname , &inode );
[260]3965
[587]3966    if ( code == 2 ) 
3967    {
3968        _spin_lock_release( &_fat.fat_lock );
3969        _printf("\n[FAT ERROR] in _fat_mkdir() : path to parent not found"
3970                " for directory <%s>\n", pathname );
3971        return -2;
[260]3972    }
[587]3973    else if ( code == 3 ) 
[260]3974    {
[587]3975        _spin_lock_release( &_fat.fat_lock );
3976        _printf("\n[FAT ERROR] in _fat_mkdir() : one name in path too long"
3977                " for directory  <%s>\n", pathname );
3978        return -3;
3979    }
3980    else if ( code == 0 )
3981    {
3982        _spin_lock_release( &_fat.fat_lock );
3983        _printf("\n[FAT ERROR] in _fat_mkdir() : directory <%s> already exist\n",
3984                pathname );
3985        return -4;
3986    }
3987    else if ( code == 1 )   // directory not found => create
3988    {
3989        parent = inode;
[260]3990
[587]3991#if GIET_DEBUG_FAT
3992if ( _get_proctime() > GIET_DEBUG_FAT )
3993_printf("\n[DEBUG FAT] _fat_mkdir() : P[%d,%d,%d] create new directory <%s>\n",
3994        x , y , p , pathname );
3995#endif
3996
3997        // get directory name / error check already done by _get_inode_from_path()
3998        char name[32];       
3999        _get_last_name( pathname , name );
4000
4001        // allocate one cluster from FAT for the new directory
4002        unsigned int cluster;
4003        if ( _allocate_one_cluster( &cluster ) )
4004        {
4005            _spin_lock_release( &_fat.fat_lock );
4006            _printf("\n[FAT ERROR] in _fat_mkdir() : no free cluster"
4007                    " for directory <%s>\n" , pathname );
4008            return -5;
4009        }
4010
4011        // allocate a new inode and an empty Cache-File
4012        child = _allocate_one_inode( name,
4013                                     1,           // it's a directory
4014                                     cluster, 
4015                                     0,           // size not defined
4016                                     0,           // count
4017                                     0,           // dentry set by _add_dir_entry()
4018                                     1 );         // cache_allocate
4019
4020        // introduce inode in Inode-Tree
4021        _add_inode_in_tree( child , parent );
4022 
4023        // allocate and initialise one 4 Kbytes buffer and associated descriptor
4024        _allocate_one_buffer( child,
4025                              0,            // cluster_id,
4026                              cluster );
4027
4028        _add_special_directories( child, 
4029                                  parent );
4030
4031        // add an entry in the parent directory Cache_file
4032        if ( _add_dir_entry( child , parent ) )
4033        { 
4034            _spin_lock_release( &_fat.fat_lock );
4035            _printf("\n[FAT ERROR] in _fat_mkdir() : cannot update parent directory"
4036                    " for directory <%s>\n" , pathname );
4037            return -6;
4038        } 
4039
4040        // update DATA region on block device for parent directory
4041        if ( _update_device_from_cache( parent->levels,
4042                                        parent->cache,
4043                                        parent->name ) )
4044        {
4045            _spin_lock_release( &_fat.fat_lock );
4046            _printf("\n[FAT ERROR] in _fat_mkdir() : cannot update DATA region "
4047                    " for parent of directory <%s>\n", pathname );
4048            return -7;
4049        }
4050
4051        // update FAT region on block device
4052        if ( _update_device_from_cache( _fat.fat_cache_levels,
4053                                        _fat.fat_cache_root,
4054                                        "FAT" ) )
4055        {
4056            _spin_lock_release( &_fat.fat_lock );
4057            _printf("\n[FAT ERROR] in _fat_mkdir() : cannot update FAT region"
4058                    " for directory <%s>\n", pathname );
4059            return -8;
4060        }
4061
4062        // update FS_INFO sector
4063        if ( _update_fs_info() )
4064        {
4065            _spin_lock_release( &_fat.fat_lock );
4066            _printf("\n[FAT ERROR] in _fat_mkdir() : cannot update FS-INFO"
4067                    " for directory <%s>\n", pathname );
4068            return -9;
4069        }
4070
4071        // update DATA region on block device for the new directory
4072        if ( _update_device_from_cache( child->levels,   
4073                                        child->cache,
4074                                        child->name ) )
4075        {
4076            _spin_lock_release( &_fat.fat_lock );
4077            _printf("\n[FAT ERROR] in _fat_mkdir() : cannot update DATA region"
4078                    " for directory <%s>\n", pathname );
4079            return -10;
4080        }
4081    }  // end create directory
4082
4083    return 0;
4084}  // end _fat_mkdir()
4085
4086
4087
4088
4089
[260]4090/////////////////////////////////////////////////////////////////////////////////
[587]4091// The following function implements the giet_fat_list() system call.
4092// It displays the content of a directory identified by the "pathname" argument.
4093// It returns an error code if the pathname is not a directory.
[258]4094/////////////////////////////////////////////////////////////////////////////////
[587]4095// Returns 0 if success.
4096// Returns a negative value if error:
4097//   -1  : "FAT not initialised
4098//   -2  : "Directory not found"
4099//   -3  : "Name in path too long
4100//   -4  : "Not a directory"
4101//   -5  : "Cannot access directory"
4102//   -6  : "Name too long truncated"
[258]4103/////////////////////////////////////////////////////////////////////////////////
[587]4104int _fat_list( char*  pathname )
[258]4105{
[587]4106    fat_inode_t*  inode;
4107
4108    // checking FAT initialised
4109    if( _fat.initialised != FAT_INITIALISED )
[258]4110    {
[587]4111        _printf("\n[FAT ERROR] in _fat_list() : FAT not initialised\n");
4112        return -1;
[258]4113    }
[587]4114
4115#if GIET_DEBUG_FAT
4116unsigned int procid  = _get_procid();
4117unsigned int x       = procid >> (Y_WIDTH + P_WIDTH);
4118unsigned int y       = (procid >> P_WIDTH) & ((1<<Y_WIDTH)-1);
4119unsigned int p       = procid & ((1<<P_WIDTH)-1);
4120if ( _get_proctime() > GIET_DEBUG_FAT )
4121_printf("\n[DEBUG FAT] _fat_list() : P[%d,%d,%d] enters for path <%s>\n",
4122        x, y, p, pathname );
4123#endif
4124
4125    // get inode
4126    unsigned int code = _get_inode_from_path( pathname , &inode );
4127
4128    if ( (code == 1) || (code == 2) ) 
[258]4129    {
[587]4130        _printf("\n[FAT ERROR] in _fat_list() : directory <%s> not found\n", pathname );
4131        return -2;
4132    }
4133    if ( code == 3 )
4134    {
4135        _printf("\n[FAT ERROR] in _fat_list() : name too long in path <%s>\n", pathname );
4136        return -3;
4137    }
[258]4138
[587]4139    // check found inode is a directory
4140    if ( inode->is_dir == 0 )
4141    {
4142        _printf("\n[FAT ERROR] in _fat_list() : <%s> is not a directory\n", pathname );
4143        return -4;
4144    }
[258]4145
[587]4146#if GIET_DEBUG_FAT
4147if ( _get_proctime() > GIET_DEBUG_FAT )
4148_printf("\n[DEBUG FAT] _fat_list() : P[%d,%d,%d] found inode for path <%s>\n",
4149        x, y, p, pathname );
4150#endif
[258]4151
[587]4152    // scan directory up to end of directory / two embedded loops :
4153    // - loop on the clusters allocated to the directory
4154    // - loop on the directory entries in each 4 Kbytes buffer
4155    unsigned char*     buffer; 
4156    fat_cache_desc_t*  pdesc;
4157    unsigned int       cluster_id = 0;     // cluster index in directory
4158    unsigned int       offset     = 0;     // position in scanned buffer
4159    unsigned int       lfn        = 0;     // number of lfn entries
4160    unsigned int       nb_entries = 0;     // number of directory entries
4161    unsigned int       done       = 0;     // end of directory found
4162    unsigned int       attr;               // ATTR field value
4163    unsigned int       ord;                // ORD field value
4164    char               lfn1[16];           // temporary buffer for string in LFN1
4165    char               lfn2[16];           // temporary buffer for string in LFN2
4166    char               lfn3[16];           // temporary buffer for string in LFN3
4167    char               name[36];           // directory entry full name
4168    unsigned int       cluster;            // directory entry cluster index
4169    unsigned int       size;               // directory entry size
4170    unsigned int       is_dir;             // directory entry is a directory
4171    unsigned int       is_vid;             // directory entry is volume_id
4172
4173    // TODO : define a method to transfer this information to user mode
4174    _printf("\n<%s>   cluster = %x / lba = %x\n", pathname ,
4175            inode->cluster , _cluster_to_lba( inode->cluster) );
4176
4177    while ( done == 0 )
4178    {
4179        // get one 4 Kytes buffer
4180        if ( _get_buffer_from_cache( inode,
4181                                     cluster_id,
4182                                     &pdesc ) ) 
4183        {
4184            _printf("\n[FAT ERROR] in _fat_list() : cannot access <%s>\n", pathname );
4185            return -5;
4186        }
4187        buffer = pdesc->buffer;
4188
4189        // scan this 4 Kbytes buffer
4190        while ( (offset < 4096)  && (done == 0) )
4191        {
4192            attr = _read_entry( DIR_ATTR , buffer + offset , 0 );   
4193            ord  = _read_entry( LDIR_ORD , buffer + offset , 0 );
4194
4195            if (ord == NO_MORE_ENTRY)                 // no more entry in directory => break
4196            {
4197                done = 1;
4198            }
4199            else if ( ord == FREE_ENTRY )             // free entry => skip
4200            {
4201                offset = offset + 32;
4202            }
4203            else if ( attr == ATTR_LONG_NAME_MASK )   // LFN entry => get partial names
4204            {
4205                unsigned int seq = ord & 0x3;
4206                lfn = (seq > lfn) ? seq : lfn;   
4207                if      ( seq == 1 ) _get_name_from_long( buffer + offset, lfn1 );
4208                else if ( seq == 2 ) _get_name_from_long( buffer + offset, lfn2 );
4209                else if ( seq == 3 ) _get_name_from_long( buffer + offset, lfn3 );
4210                offset = offset + 32;
4211            }
4212            else                                 // NORMAL entry
4213            {
4214                if      ( lfn == 0 )
4215                {
4216                    _get_name_from_short( buffer + offset , name );
4217                }
4218                else if ( lfn == 1 )
4219                {
4220                    _strcpy( name , lfn1 );
4221                }   
4222                else if ( lfn == 2 ) 
4223                {
4224                    _strcpy( name      , lfn1 );
4225                    _strcpy( name + 13 , lfn2 );
4226                }
4227                else if ( lfn == 3 ) 
4228                {
4229                    _strcpy( name      , lfn1 );
4230                    _strcpy( name + 13 , lfn2 );
4231                    _strcpy( name + 26 , lfn3 );
4232                }
4233                   
4234                is_dir  = ((attr & ATTR_DIRECTORY) == ATTR_DIRECTORY);
4235                is_vid  = ((attr & ATTR_VOLUME_ID) == ATTR_VOLUME_ID);
4236                size    = (_read_entry( DIR_FILE_SIZE   , buffer + offset , 1 )      ) ;
4237                cluster = (_read_entry( DIR_FST_CLUS_HI , buffer + offset , 1 ) << 16) |
4238                          (_read_entry( DIR_FST_CLUS_LO , buffer + offset , 1 )      ) ;
4239
4240                if ( is_vid == 0 )
4241                {
4242                    // TODO : define a method to transfer this information to user mode
4243                    if (is_dir) _printf("  DIR  | size = %X | cluster = %X | %s\n",
4244                                        size , cluster, name );
4245                    else        _printf("  FILE | size = %X | cluster = %X | %s\n",
4246                                        size , cluster, name );
4247                    nb_entries++;
4248                }
4249               
4250                offset = offset + 32;
4251                lfn    = 0;
4252            }
4253        }  // end loop on directory entries
4254
4255        if ( done == 0 )
4256        {
4257            cluster_id++;
4258            offset = 0;
4259        }
4260    }  // end loop on buffers
4261
4262    // TODO : define a method to transfer this information to user mode
4263    _printf("  total = %d entries\n", nb_entries );
4264
4265    return 0;
4266} // end _fat_list()
4267
4268
4269
4270
4271
4272///////////////////////////////////////////////////////////////////////////////
4273// This functiond load a file identified by the "pathname" argument into the
4274// memory buffer defined by the "buffer_vbase" and "buffer_size" arguments.
4275// It is intended to be called by the boot-loader, as it does not use the
4276// dynamically allocated FAT structures (Inode-Tree, Fat_Cache or File-Cache,
4277// File-Descriptor-Array).
4278// It uses only the 512 bytes buffer defined in the FAT descriptor.
4279///////////////////////////////////////////////////////////////////////////////
4280// Returns  0 if success.
4281// Returns negative value if error:
4282//  -1  : "FAT not initialised"
4283//  -2  : "File not found"
4284//  -3  : "Buffer too small"
4285//  -4  : "Cannot access block device"
4286//  -5  : "Cannot access FAT on block device"
4287///////////////////////////////////////////////////////////////////////////////
4288int _fat_load_no_cache( char*        pathname,
4289                        unsigned int buffer_vbase, 
4290                        unsigned int buffer_size ) 
[258]4291{
[587]4292    // checking FAT initialised
4293    if( _fat.initialised != FAT_INITIALISED )
4294    {
4295        _printf("\n[FAT ERROR] in _fat_load_no_cache() : FAT not initialised\n");
4296        return -1;
4297    }
[258]4298
[587]4299    unsigned int  file_size;
4300    unsigned int  cluster;
4301
4302#if GIET_DEBUG_FAT
4303unsigned int procid  = _get_procid();
4304unsigned int x       = procid >> (Y_WIDTH + P_WIDTH);
4305unsigned int y       = (procid >> P_WIDTH) & ((1<<Y_WIDTH)-1);
4306unsigned int p       = procid & ((1<<P_WIDTH)-1);
4307if ( _get_proctime() > GIET_DEBUG_FAT )
4308_printf("\n[DEBUG FAT] _fat_load_no_cache() : P[%d,%d,%d] enters for file <%s>\n",
4309        x , y , p , pathname );
4310#endif
4311
4312    // get file size, and cluster index in FAT
4313    if ( _file_info_no_cache( pathname,
4314                              &cluster,
4315                              &file_size ) )
4316    {
4317        _printf("\n[FAT ERROR] in _fat_load_no_cache() : file <%s> not found\n",
4318        pathname );
4319        return -2;
4320    }
4321
4322    // check buffer size
4323    if ( file_size > buffer_size )
4324    {
4325        _printf("\n[FAT ERROR] in _fat_load_no_cache() : buffer too small : "
4326                "file_size = %x / buffer_size = %x", file_size , buffer_size );
4327        return -3;
4328    }
4329
4330    // compute total number of clusters to read
4331    unsigned int nb_clusters = file_size >> 12;
4332    if ( file_size & 0xFFF ) nb_clusters++;
4333
4334    // initialise buffer address
4335    unsigned int dst = buffer_vbase;
4336
4337    // loop on the clusters containing the file
4338    while ( nb_clusters > 0 )
4339    {
4340        unsigned int lba = _cluster_to_lba( cluster );
4341
4342        if( _fat_ioc_access( 0,         // no descheduling
4343                             1,         // read
4344                             lba, 
4345                             dst, 
4346                             8 ) )      // 8 blocks
4347        {
4348            _printf("\n[FAT ERROR] in _fat_no _cache_read() : cannot load lba %x", lba );
4349            return -4;
4350        }
4351         
4352
4353        // compute next cluster index
4354        unsigned int next;
4355        if ( _next_cluster_no_cache( cluster , &next ) )
4356        {
4357            _printf("\n[FAT ERROR] in _fat_no _cache_read() : cannot get next cluster "
4358                    " for cluster = %x\n", cluster );
4359            return -5;
4360        }
4361       
4362        // update variables for next iteration
4363        nb_clusters = nb_clusters - 1;
4364        dst         = dst + 4096;
4365        cluster     = next;
4366    }
4367         
4368#if GIET_DEBUG_FAT
4369if ( _get_proctime() > GIET_DEBUG_FAT )
4370_printf("\n[DEBUG FAT] _fat_load_no_cache() : P[%d,%d,%d] loaded <%s> at vaddr = %x"
4371        " / size = %x\n", x , y , p , pathname , buffer_vbase , file_size );
4372#endif
4373
[258]4374    return 0;
[587]4375}  // end _fat_load_no_cache()
[258]4376
4377
[587]4378
[258]4379// Local Variables:
4380// tab-width: 4
4381// c-basic-offset: 4
4382// c-file-offsets:((innamespace . 0)(inline-open . 0))
4383// indent-tabs-mode: nil
4384// End:
4385// vim: filetype=c:expandtab:shiftwidth=4:tabstop=4:softtabstop=4
4386
Note: See TracBrowser for help on using the repository browser.