source: trunk/kernel/fs/fatfs.c @ 635

Last change on this file since 635 was 635, checked in by alain, 17 months ago

This version is a major evolution: The physical memory allocators,
defined in the kmem.c, ppm.c, and kcm.c files have been modified
to support remote accesses. The RPCs that were previously user
to allocate physical memory in a remote cluster have been removed.
This has been done to cure a dead-lock in case of concurrent page-faults.

This version 2.2 has been tested on a (4 clusters / 2 cores per cluster)
TSAR architecture, for both the "sort" and the "fft" applications.

File size: 106.2 KB
Line 
1/*
2 * fatfs.c - FATFS file system API implementation.
3 *
4 * Author    Alain Greiner (2016,2017,2018,2019)
5 *
6 * Copyright (c) UPMC Sorbonne Universites
7 *
8 * This file is part of ALMOS-MKH.
9 *
10 * ALMOS-MKH is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; version 2.0 of the License.
13 *
14 * ALMOS-MKH is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17 * General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with ALMOS-MKH; if not, write to the Free Software Foundation,
21 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22 */
23
24
25#include <hal_kernel_types.h>
26#include <hal_special.h>
27#include <printk.h>
28#include <thread.h>
29#include <kmem.h>
30#include <ppm.h>
31#include <vfs.h>
32#include <string.h>
33#include <rpc.h>
34#include <mapper.h>
35#include <cluster.h>
36#include <dev_ioc.h>
37#include <fatfs.h>
38
39#define LITTLE_ENDIAN  1
40
41//////////////////////////////////////////////////////////////////////////////////////////
42//          Extern  variables         
43//////////////////////////////////////////////////////////////////////////////////////////
44
45extern vfs_ctx_t     fs_context[FS_TYPES_NR];   // allocated in kernel_init.c file
46
47//////////////////////////////////////////////////////////////////////////////////////////
48//              FATFS specific static functions
49//////////////////////////////////////////////////////////////////////////////////////////
50
51//////////////////////////////////////////////////////////////////////////////////////////
52// These functions return the "offset" and "length" values of an
53// [offset,length] constant defined in the fatfs.h file.
54//////////////////////////////////////////////////////////////////////////////////////////
55
56static inline int get_length( int offset __attribute__((unused)), int length ) { return length; }
57
58static inline int get_offset( int offset, int length __attribute__((unused)) ) { return offset; }
59
60//////////////////////////////////////////////////////////////////////////////////////////
61// This static function returns the LBA of the first sector of a FAT cluster.
62// This function can be called by any thread running in any cluster.
63//////////////////////////////////////////////////////////////////////////////////////////
64// @ ctx          :     pointer on FATFS context.
65// @ cluster  : cluster index in FATFS.
66// @ return the lba value.
67//////////////////////////////////////////////////////////////////////////////////////////
68static inline uint32_t fatfs_lba_from_cluster( fatfs_ctx_t * ctx,
69                                               uint32_t      cluster )
70{
71    return (ctx->cluster_begin_lba + ((cluster - 2) << 3));
72}
73
74//////////////////////////////////////////////////////////////////////////////////////////
75// This function return an integer record value (one, two, or four bytes) from a local
76// array of bytes, taking into account the global LITTLE_ENDIAN parameter:
77// if LITTLE_ENDIAN is true, the most significant byte has the highest address.
78//////////////////////////////////////////////////////////////////////////////////////////
79// @ offset        : first byte in array.
80// @ nbytes        : record length in bytes (1/2/4).
81// @ buffer        : local pointer on byte array.
82// @ return the integer value in a 32 bits word.
83//////////////////////////////////////////////////////////////////////////////////////////
84static uint32_t fatfs_get_record( uint32_t    offset,
85                                  uint32_t    nbytes,
86                                  uint8_t   * buffer )
87{
88    uint32_t i;
89    uint32_t res = 0;
90
91    if ( LITTLE_ENDIAN )
92    {
93        for( i = nbytes ; i > 0 ; i-- ) res = (res<<8) | buffer[offset+i-1];
94    }
95    else 
96    {
97        for( i = 0 ; i < nbytes ; i++ ) res = (res<<8) | buffer[offset+i];
98    }
99    return res;
100
101}  // end fatfs_get_record()
102
103//////////////////////////////////////////////////////////////////////////////////////////
104// This function return an integer record value (one, two, or four bytes) from a remote
105// array of bytes, taking into account the global LITTLE_ENDIAN parameter:
106// if LITTLE_ENDIAN is true, the most significant byte has the highest address.
107//////////////////////////////////////////////////////////////////////////////////////////
108// @ offset        : first byte in array.
109// @ nbytes        : record length in bytes (1/2/4).
110// @ buffer_xp     : extended pointer on byte array.
111// @ return the integer value in a 32 bits word.
112//////////////////////////////////////////////////////////////////////////////////////////
113static uint32_t fatfs_get_remote_record( uint32_t   offset,
114                                         uint32_t   nbytes,
115                                         xptr_t     buffer_xp )
116{
117    uint32_t i;
118    uint32_t res = 0;
119
120    if ( LITTLE_ENDIAN )
121    {
122        for( i = nbytes ; i > 0 ; i-- )
123        {
124            res = (res<<8) | hal_remote_lb( buffer_xp+offset+i-1 );
125        }
126    }
127    else 
128    {
129        for( i = 0 ; i < nbytes ; i++ )
130        {
131            res = (res<<8) | hal_remote_lb( buffer_xp+offset+i );
132        }
133    }
134    return res;
135
136}  // end fatfs_get_remote_record()
137
138//////////////////////////////////////////////////////////////////////////////////////////
139// This function writes one, two, or four bytes from a 32 bits integer to a local
140// array of bytes, taking into account the global LITTLE_ENDIAN parameter:
141// if LITTLE_ENDIAN is true, the most significant byte has the highest address.
142//////////////////////////////////////////////////////////////////////////////////////////
143// @ offset        : first byte in array.
144// @ nbytes        : record length in bytes (1/2/4).
145// @ buffer        : local pointer on byte array.
146// @ value         : 32 bits integer value.
147//////////////////////////////////////////////////////////////////////////////////////////
148static void fatfs_set_record( uint32_t    offset,
149                              uint32_t    nbytes,
150                              uint8_t   * buffer,
151                              uint32_t    value )
152{
153    uint32_t i;
154
155    if ( LITTLE_ENDIAN )
156    {
157        for( i = nbytes ; i > 0 ; i-- ) buffer[offset+i-1] = (uint8_t)(value>>((i-1)<<3));
158    }
159    else
160    {
161        for( i = 0 ; i < nbytes ; i++ ) buffer[offset+i] = (uint8_t)(value>>((nbytes-1-i)<<3));
162    }
163
164}  // end fatfs_set_record()
165
166//////////////////////////////////////////////////////////////////////////////////////////
167// This function writes one, two, or four bytes from a 32 bits integer to a remote
168// array of bytes, taking into account the global LITTLE_ENDIAN parameter:
169// if LITTLE_ENDIAN is true, the most significant byte has the highest address.
170//////////////////////////////////////////////////////////////////////////////////////////
171// @ offset        : first byte in array.
172// @ nbytes        : record length in bytes (1/2/4).
173// @ buffer_xp     : extended pointer on byte array.
174// @ value         : 32 bits integer value.
175//////////////////////////////////////////////////////////////////////////////////////////
176static void fatfs_set_remote_record( uint32_t    offset,
177                                     uint32_t    nbytes,
178                                     xptr_t      buffer_xp,
179                                     uint32_t    value )
180{
181    uint32_t i;
182
183    if ( LITTLE_ENDIAN )
184    {
185        for( i = nbytes ; i > 0 ; i-- )
186        {
187            hal_remote_sb( (buffer_xp+offset+i-1) , (uint8_t)(value>>((i-1)<<3)) );
188        }
189    }
190    else
191    {
192        for( i = 0 ; i < nbytes ; i++ )
193        {
194            hal_remote_sb( (buffer_xp+offset+i) , (uint8_t)(value>>((nbytes-1-i)<<3)) );
195        }
196    }
197
198}  // end fatfs_set_record()
199
200//////////////////////////////////////////////////////////////////////////////////////////
201// This static function retun in the <name> buffer a short name stored in
202// a SFN FATFS directory entry.
203/////////////////////////i////////////////////////////////////////////////////////////////
204// @ buffer   : pointer on buffer containing the directory entry.
205// @ name     : [out] buffer allocated by the caller.
206//////////////////////////////////////////////////////////////////////////////////////////
207static void fatfs_get_name_from_short( uint8_t * buffer,
208                                       char    * name )
209{
210    uint32_t i;
211    uint32_t j = 0;
212
213    // get name
214    for ( i = 0; i < 8 && buffer[i] != ' '; i++ )
215    {
216        name[j] = to_lower( buffer[i] );
217        j++;
218    }
219
220    // get extension
221    for ( i = 8; i < 8 + 3 && buffer[i] != ' '; i++ )
222    {
223        // we entered the loop so there is an extension. add the dot
224        if ( i == 8 )
225        {
226            name[j] = '.';
227            j++;
228        }
229
230        name[j] = to_lower( buffer[i] );
231        j++;
232    }
233
234    name[j] = '\0';
235
236}  // fatfs_get_name_from_short()
237
238//////////////////////////////////////////////////////////////////////////////////////////
239// This static function retun in the <name> buffer a partial name stored in
240// a LFN FATFS directory entry.
241/////////////////////////i////////////////////////////////////////////////////////////////
242// @ buffer   : pointer on buffer containing the directory entry.
243// @ name     : [out] buffer allocated by the caller.
244//////////////////////////////////////////////////////////////////////////////////////////
245static void fatfs_get_name_from_long( uint8_t * buffer,
246                                      char    * name )
247{
248    uint32_t   name_offset   = 0;
249    uint32_t   buffer_offset = get_length(LDIR_ORD);
250    uint32_t   l_name_1      = get_length(LDIR_NAME_1);
251    uint32_t   l_name_2      = get_length(LDIR_NAME_2);
252    uint32_t   l_name_3      = get_length(LDIR_NAME_3);
253    uint32_t   l_attr        = get_length(LDIR_ATTR);
254    uint32_t   l_type        = get_length(LDIR_TYPE);
255    uint32_t   l_chksum      = get_length(LDIR_CHKSUM);
256    uint32_t   l_rsvd        = get_length(LDIR_RSVD);
257
258    uint32_t   j             = 0;
259    uint32_t   eof           = 0;
260
261    while ( (buffer_offset != DIR_ENTRY_SIZE)  && (!eof) )
262    {
263        while (j != l_name_1 && !eof )
264        {
265            if ( (buffer[buffer_offset] == 0x00) || 
266                 (buffer[buffer_offset] == 0xFF) )
267            {
268                eof = 1;
269                continue;
270            }
271            name[name_offset] = buffer[buffer_offset];
272            buffer_offset += 2;
273            j += 2;
274            name_offset++;
275        }
276
277        buffer_offset += (l_attr + l_type + l_chksum);
278        j = 0;
279
280        while (j != l_name_2 && !eof )
281        {
282            if ( (buffer[buffer_offset] == 0x00) || 
283                 (buffer[buffer_offset] == 0xFF) )
284            {
285                eof = 1;
286                continue;
287            }
288            name[name_offset] = buffer[buffer_offset];
289            buffer_offset += 2;
290            j += 2;
291            name_offset++;
292        }
293
294        buffer_offset += l_rsvd;
295        j = 0;
296
297        while (j != l_name_3 && !eof )
298        {
299            if ( (buffer[buffer_offset] == 0x00) || 
300                 (buffer[buffer_offset] == 0xFF) )
301            {
302                eof = 1;
303                continue;
304            }
305            name[name_offset] = buffer[buffer_offset];
306            buffer_offset += 2;
307            j += 2;
308            name_offset++;
309        }
310    }
311    name[name_offset] = 0;
312
313} // end fatfs_get_name_from_long()
314
315//////////////////////////////////////////////////////////////////////////////////////////
316// This static function analyse the <name> input argument, and returns in other
317// output arguments various informations required to store the name in FATFS directory.
318// The <name> length cannot be larger than 31 characters :
319// - Short name (less than 13 characters) require 1 LFN entry.
320// - Medium names (from 14 to 26 characters require 2 LFN entries.
321// - Large names (up to 31 characters) require 3 LFN entries.
322//////////////////////////////////////////////////////////////////////////////////////////
323// @ name     : [in]  complete directory entry name.
324// @ length   : [out] total number of characters in name.
325// @ nb_lfn   : [out] number of LFN entries required to store the name.
326// @ sfn      : [out] a legal SFN name extracted from name / upper case and 8-3 format.
327// @ checksum : [out] checksum to be stored in SFN.
328// @ returns 0 on success / returns 1 if the name length is larger than 31 characters.
329//////////////////////////////////////////////////////////////////////////////////////////
330static error_t fatfs_name_format( const char  * name,
331                                  uint32_t    * length,
332                                  uint32_t    * nb_lfn,
333                                  char        * sfn,
334                                  uint8_t     * checksum )
335{
336    // compute name length
337    uint32_t name_length = strlen( name );
338    *length = name_length;
339
340    uint32_t suffix_length = 0;
341    uint32_t prefix_length = 0;
342    uint32_t dot_found     = 0;
343    uint32_t i;
344
345    // compute prefix and suffix length
346    // only the last '.' is taken into account
347    for ( i=0 ; i<name_length ; i++ )
348    {
349        if (name[i] == '.' )
350        {
351            if ( dot_found ) 
352            {
353                prefix_length += suffix_length + 1;
354                suffix_length =  0;
355            }
356            else
357            {
358                dot_found = 1;
359            }
360        }
361        else
362        { 
363            if ( dot_found)  suffix_length++;
364            else             prefix_length++;
365        }
366    } 
367
368    // build SFN prefix (8bits)
369    if (prefix_length <= 8)
370    {
371        for( i=0 ; i<8 ; i++)
372        {
373            if ( i<prefix_length ) sfn[i] = to_upper( name[i] );
374            else                   sfn[i] = 0x20;
375        }
376    }
377    else
378    {
379        for( i=0 ; i<6 ; i++)
380        {
381            sfn[i] = to_upper( name[i] );
382        }
383        sfn[6] = 0x7E;
384        sfn[7] = 0x31;
385    }
386
387    // build SFN suffix (3 bits)
388    if ( suffix_length == 0 )
389    {
390        sfn[8]  = 0x20;
391        sfn[9]  = 0x20;
392        sfn[10] = 0x20;
393    }
394    else if ( suffix_length == 1 )
395    {
396        sfn[8]  = to_upper( name[name_length-1] );
397        sfn[9]  = 0x20;
398        sfn[10] = 0x20;
399    }
400    else if ( suffix_length == 2 )
401    {
402        sfn[8]  = to_upper( name[name_length-2] );
403        sfn[9]  = to_upper( name[name_length-1] );
404        sfn[10] = 0x20;
405    }
406    else
407    {
408        sfn[8]  = to_upper( name[name_length-suffix_length] );
409        sfn[9]  = to_upper( name[name_length-suffix_length+1] );
410        sfn[10] = to_upper( name[name_length-suffix_length+2] );
411    }
412
413    // compute 8 bits checksum
414    uint8_t sum = 0;
415    for ( i=0 ; i<11 ; i++ )
416    {
417        sum = (((sum & 0x01)<<7) | ((sum & 0xFE)>>1)) + sfn[i];
418    }
419    *checksum = sum;
420
421    // set nb_lfn and length values
422    if      ( name_length <= 13 )
423    {
424        *nb_lfn  = 1;
425        return 0;
426    }
427    else if ( name_length <= 26 )
428    {
429        *nb_lfn  = 2;
430        return 0;
431    }
432    else if ( name_length <= 31 )
433    {
434        *nb_lfn  = 3;
435        return 0;
436    }
437    else
438    {
439        return 1;
440    }
441}   // end fatfs_name_format() 
442
443//////////////////////////////////////////////////////////////////////////////////////////
444// This static function synchronously updates the FAT on IOC device.
445// It scan the FAT mapper to copy on IOC device all dirty pages in the interval
446// defined by the <page_min> & <page_max> arguments.
447// It can be called by a thread running in any cluster.
448// WARNING : We don't take the lock protecting the FAT mapper, because the FAT lock
449// (in FATFS context) must be taken by the calling function.
450//////////////////////////////////////////////////////////////////////////////////////////
451// @ fatfs_ctx_xp  : extended pointer on FATFS context in FAT cluster.
452// @ page_min      : first page to be checked.
453// @ page_max      : last page to be checked
454// @ return 0 if success, return -1 if the FS_INFO sector cannot be updated.
455//////////////////////////////////////////////////////////////////////////////////////////
456static error_t fatfs_update_ioc_fat( xptr_t   fatfs_ctx_xp,
457                                     uint32_t page_min,
458                                     uint32_t page_max )
459{
460
461#if DEBUG_FATFS_UPDATE_IOC
462uint32_t   cycle = (uint32_t)hal_get_cycles();
463thread_t * this  = CURRENT_THREAD;
464if( DEBUG_FATFS_UPDATE_IOC < cycle )
465printk("\n[%s] thread[%x,%x] enter / page_min %d / page_max %d / cycle %d\n",
466__FUNCTION__ , this->process->pid, this->trdid, page_min, page_max, cycle );
467#endif
468
469    error_t       error;
470    cxy_t         fat_cxy;         // FAT cluster identifier
471    fatfs_ctx_t * fatfs_ctx;       // local pointer on FATFS context in FAT cluster
472    xptr_t        fat_mapper_xp;   // extended pointer on FAT mapper
473    mapper_t    * fat_mapper_ptr;  // local pointer on FAT mapper
474    uint32_t      page_id;         // current page index in FAT mapper
475    xptr_t        rt_xp;           // extended pointer on FAT mapper radix tree
476    xptr_t        page_xp;         // extended pointer on current page in FAT mapper
477    page_t      * page_ptr;        // local pointer on current page
478    uint32_t      flags;           // current page flags
479
480    // get pointer and cluster on FATFS context in FAT cluster
481    fat_cxy   = GET_CXY( fatfs_ctx_xp );
482    fatfs_ctx = GET_PTR( fatfs_ctx_xp );
483 
484    // get FAT mapper pointers from FATFS context
485    fat_mapper_xp  = hal_remote_l64( XPTR( fat_cxy , &fatfs_ctx->fat_mapper_xp ) );
486    fat_mapper_ptr = GET_PTR( fat_mapper_xp );
487
488// check FAT cluster
489assert( (fat_cxy == GET_CXY( fat_mapper_xp )) , "unconsistent FAT cluster" );
490
491    // build extended pointer on FAT mapper radix tree
492    rt_xp   = XPTR( fat_cxy , &fat_mapper_ptr->rt );
493
494    // scan all pages in [min,max] interval
495    for( page_id = page_min ; page_id <= page_max ; page_id++ )
496    {
497        // get extended pointer on page descriptor from FAT mapper
498        page_xp = grdxt_remote_lookup( rt_xp , page_id );
499
500        // check only existing pages
501        if ( page_xp != XPTR_NULL )
502        {
503            page_ptr = GET_PTR( page_xp );
504            flags    = hal_remote_l32( XPTR( fat_cxy , &page_ptr->flags ) );
505
506            // copy only dirty pages
507            if ( flags & PG_DIRTY )
508            {
509
510#if (DEBUG_FATFS_UPDATE_IOC & 1)
511if( DEBUG_FATFS_UPDATE_IOC < cycle )
512printk("\n[%s] thread[%x,%x] copy page %d from FAT mapper to IOC device\n",
513__FUNCTION__, page_id );
514#endif
515                // move page from mapper to device
516                error = fatfs_move_page( page_xp , IOC_SYNC_WRITE );
517
518                if ( error )  return -1;
519
520                // reset page dirty flag
521                ppm_page_undo_dirty( page_xp );
522            }
523        }
524    }  // end loop on pages
525
526#if DEBUG_FATFS_UPDATE_IOC
527cycle = (uint32_t)hal_get_cycles();
528if( DEBUG_FATFS_UPDATE_IOC < cycle )
529printk("\n[%s] thread[%x,%x] exit / cycle %d\n",
530__FUNCTION__ , this->process->pid, this->trdid, cycle );
531#endif
532
533    return 0;
534
535}  // end fatfs_update_ioc_fat()
536
537//////////////////////////////////////////////////////////////////////////////////////////
538// This static function synchronously updates the FS_INFO sector on IOC device,
539// from values contained in the FATFS context in FAT cluster.
540// It uses and updates the FS_INFO buffer allocated in the FAT cluster.
541// It can be called by a thread running in any cluster.
542//////////////////////////////////////////////////////////////////////////////////////////
543// @ fatfs_ctx_xp  : extended pointer on FATFS context in FAT cluster.
544// @ return 0 if success, return -1 if the FS_INFO sector cannot be updated.
545//////////////////////////////////////////////////////////////////////////////////////////
546static error_t fatfs_update_ioc_fsinfo( xptr_t fatfs_ctx_xp )
547{
548    cxy_t         fat_cxy;             // FAT cluster identifier
549    fatfs_ctx_t * fatfs_ctx_ptr;       // local pointer on fatfs context in FAT cluster
550    uint32_t      free_clusters;       // current vale of "free_clusters" in fatfs context
551    uint32_t      free_cluster_hint;   // current vale of "free_cluster_hint" in fatfs context
552    uint8_t     * fs_info_buffer_ptr;  // local pointer on FS_INFO buffer in FAT cluster
553    xptr_t        fs_info_buffer_xp;   // extended pointer on FS_INFO buffer in FAT cluster
554    uint32_t      fs_info_lba;         // FS_INFO sector lba on IOC device
555
556    // get cluster and local pointer on FAT cluster context
557    fat_cxy       = GET_CXY( fatfs_ctx_xp ); 
558    fatfs_ctx_ptr = GET_PTR( fatfs_ctx_xp ); 
559
560    // force FATFS context update
561    hal_fence();
562
563    // get relevant info from fatfs context in FAT cluster
564    fs_info_lba        = hal_remote_l32( XPTR( fat_cxy , &fatfs_ctx_ptr->fs_info_lba ) );
565    free_clusters      = hal_remote_l32( XPTR( fat_cxy , &fatfs_ctx_ptr->free_clusters ) );
566    free_cluster_hint  = hal_remote_l32( XPTR( fat_cxy , &fatfs_ctx_ptr->free_cluster_hint ) );
567    fs_info_buffer_ptr = hal_remote_lpt( XPTR( fat_cxy , &fatfs_ctx_ptr->fs_info_buffer ) );
568
569    // build extended pointer on FS_INFO buffer in FAT cluster
570    fs_info_buffer_xp  = XPTR( fat_cxy , fs_info_buffer_ptr );
571   
572    // update the FS_INFO buffer in FAT cluster
573    fatfs_set_remote_record( FS_FREE_CLUSTERS     , fs_info_buffer_xp , free_clusters );
574    fatfs_set_remote_record( FS_FREE_CLUSTER_HINT , fs_info_buffer_xp , free_cluster_hint );
575   
576    // update the FS_INFO sector on IOC device
577    return dev_ioc_sync_write( fs_info_buffer_xp , fs_info_lba , 1 );
578 
579}  // end fatfs_update_ioc_fsinfo()
580
581//////////////////////////////////////////////////////////////////////////////////////////
582// This static function decrements the  "free_clusters" variable, and updates the
583// "free_cluster_hint" variable in the FATFS context in FAT cluster, identified
584// by the <fat_ctx_xp> argument, when a new <cluster> has been allocated from FAT.
585// It scan all slots in the FAT mapper seen as an array of 32 bits words, looking for the
586// first free slot larger than the <cluster> argument, to update "free_cluster_hint".
587// It synchronously updates the FS_INFO sector on the IOC device.
588// It can be called by a thead running in any cluster.
589// The lock protecting exclusive access to the FAT must be taken by the calling function.
590//////////////////////////////////////////////////////////////////////////////////////////
591// @ fatfs_ctx_xp  : extended pointer on FATFS context in FAT cluster.
592// @ cluster       : recently allocated cluster index in FAT.
593// @ return 0 if success, return -1 if the FS_INFO sector cannot be updated.
594//////////////////////////////////////////////////////////////////////////////////////////
595static error_t fatfs_free_clusters_decrement( xptr_t    fatfs_ctx_xp,
596                                              uint32_t  cluster )
597{
598    error_t       error;
599    cxy_t         fat_cxy;        // FAT cluster identifier
600    fatfs_ctx_t * fat_ctx_ptr;    // local pointer on fatfs context in FAT cluster
601    xptr_t        fat_mapper_xp;  // extended pointer on FAT mapper
602    xptr_t        hint_xp;        // extended pointer on "free_cluster_hint" shared variable
603    xptr_t        numb_xp;        // extended pointer on "free_clusters" shared variable
604    uint32_t      numb;           // "free_clusters" variable current value
605    uint32_t      hint;           // "free_cluster_hint" variable current value
606    uint32_t      page_id;        // page index in FAT mapper
607    uint32_t      slot_id;        // slot index in one page of FAT (1024 slots per page)
608    uint32_t      page_max;       // max number of pages in FAT mapper
609    xptr_t        page_xp;        // extended pointer on current page in FAT mapper
610    xptr_t        base_xp;        // extended pointer on current page base
611    xptr_t        slot_xp;        // extended pointer on current slot in FAT mapper
612
613#if DEBUG_FATFS_FREE_CLUSTERS
614uint32_t   cycle = (uint32_t)hal_get_cycles();
615thread_t * this  = CURRENT_THREAD;
616if( DEBUG_FATFS_FREE_CLUSTERS < cycle )
617printk("\n[%s] thread[%x,%x] enter for allocated cluster %x / cycle %d\n",
618__FUNCTION__, this->process->pid, this->trdid, cluster , cycle );
619#endif
620
621    // get FAT cluster an local pointer on fatfs context in FAT cluster
622    fat_cxy      = GET_CXY( fatfs_ctx_xp );
623    fat_ctx_ptr  = GET_PTR( fatfs_ctx_xp );
624   
625    // build extended pointers on free_clusters, and free_cluster_hint in fatfs context
626    hint_xp = XPTR( fat_cxy , &fat_ctx_ptr->free_cluster_hint );
627    numb_xp = XPTR( fat_cxy , &fat_ctx_ptr->free_clusters );
628
629    // update "free_clusters" value
630    numb = hal_remote_l32( numb_xp ) - 1;
631    hal_remote_s32( numb_xp , numb );
632
633    // get extended pointer on FAT mapper
634    fat_mapper_xp = hal_remote_l64( XPTR( fat_cxy , &fat_ctx_ptr->fat_mapper_xp ) );
635
636    // initialise variables to scan the FAT mapper
637    // and find the first free slot > cluster
638    page_id  = (cluster + 1) >> 10;
639    slot_id  = (cluster + 1) & 0x3FF;
640    page_max = hal_remote_l32( XPTR( fat_cxy, &fat_ctx_ptr->fat_sectors_count ) ) >> 3;
641
642    // scan FAT mapper / loop on pages
643    while ( page_id < page_max )           
644    {
645        // get current page from mapper
646        page_xp = mapper_remote_get_page( fat_mapper_xp , page_id );
647
648        if( page_xp == XPTR_NULL )
649        {
650            printk("\n[ERROR] in %s : cannot access FAT mapper\n", __FUNCTION__ );
651            return -1;
652        }
653
654        // get extended pointer on page
655        base_xp = ppm_page2base( page_xp );
656
657        // scan FAT mapper / loop on slots
658        while ( slot_id < 1024 )
659        {
660            // get extended pointer on current slot
661            slot_xp = base_xp + (slot_id << 2);
662
663            // test slot value
664            if ( hal_remote_l32( slot_xp ) == FREE_CLUSTER )
665            {
666                // update "free_cluster_hint" value
667                hint = (page_id << 10) + slot_id - 1;
668                hal_remote_s32( hint_xp , hint );
669
670                // update FS_INFO sector on IOC device
671                error = fatfs_update_ioc_fat( fatfs_ctx_xp,
672                                              page_id,
673                                              page_id );
674
675                if( error ) 
676                {
677                    printk("\n[ERROR] in %s : cannot update FS_INFO on IOC\n", __FUNCTION__ );
678                    return -1;
679                }
680
681#if DEBUG_FATFS_FREE_CLUSTERS
682cycle = (uint32_t)hal_get_cycles();
683if( DEBUG_FATFS_FREE_CLUSTERS < (uint32_t)hal_get_cycles() )
684printk("\n[%s] thread[%x,%x] exit / hint %x / free %x / cycle %d\n",
685__FUNCTION__, this->process->pid, this->trdid, 
686hal_remote_l32(hint_xp), hal_remote_l32(numb_xp), cycle );
687#endif
688                return 0;
689            }
690
691            // update slot_id
692            slot_id = 0;
693
694        }  // end loop on slots
695
696        // update page_id & slot_id variables
697        page_id++;
698        slot_id = 0;
699
700    }  // end loop on pages
701
702    // return error if no free cluster found
703    printk("\n[ERROR] in %s : No free cluster found\n", __FUNCTION__ );
704    return -1;
705   
706}  // end fatfs_free_clusters_decrement()
707
708//////////////////////////////////////////////////////////////////////////////////////////
709// This static function increments the "free_clusters" variable, and updates the
710// "free_cluster_hint" variables in the FATFS context in FAT cluster, identified
711// by the <fat_ctx_xp> argument, when a FATFS cluster is released.
712// If the released cluster index is smaller than the current (hint) value,
713// it set "free_cluster_hint" <= cluster.
714// It does NOT update the  FS_INFO sector on the IOC device.
715// It can be called by a thead running in any cluster.
716// The lock protecting exclusive access to the FAT must be taken by the calling function.
717//////////////////////////////////////////////////////////////////////////////////////////
718// @ fatfs_ctx_xp  : extended pointer on FATFS context in FAT cluster.
719// @ cluster       : recently released cluster index in FAT.
720// @ return 0 if success, return -1 if the FS_INFO sector cannot be updated.
721//////////////////////////////////////////////////////////////////////////////////////////
722static error_t fatfs_free_clusters_increment( xptr_t   fatfs_ctx_xp,
723                                              uint32_t cluster )
724{
725    error_t       error;
726    cxy_t         fat_cxy;      // FAT cluster identifier
727    fatfs_ctx_t * fat_ctx_ptr;  // local pointer on fatfs context in FAT cluster
728    xptr_t        hint_xp;      // extended pointer on "free_cluster_hint" shared variable
729    xptr_t        numb_xp;      // extended pointer on "free_clusters" shared variable
730    uint32_t      hint;         // "free_cluster_hint" variable current value
731    uint32_t      numb;         // "free_clusters" variable current value
732
733#if DEBUG_FATFS_FREE_CLUSTERS
734uint32_t   cycle = (uint32_t)hal_get_cycles();
735thread_t * this  = CURRENT_THREAD;
736if( DEBUG_FATFS_FREE_CLUSTERS < cycle )
737printk("\n[%s] thread[%x,%x] enter for released cluster %x / cycle %d\n",
738__FUNCTION__, this->process->pid, this->trdid, cluster , cycle );
739#endif
740
741    // get FAT cluster an local pointer on fatfs context in FAT cluster
742    fat_cxy      = GET_CXY( fatfs_ctx_xp );
743    fat_ctx_ptr  = GET_PTR( fatfs_ctx_xp );
744   
745    // build extended pointers on free_clusters, and free_cluster_hint
746    hint_xp = XPTR( fat_cxy , &fat_ctx_ptr->free_cluster_hint );
747    numb_xp = XPTR( fat_cxy , &fat_ctx_ptr->free_clusters );
748
749    // get current value of free_cluster_hint and free_clusters
750    hint = hal_remote_l32( hint_xp );
751    numb = hal_remote_l32( numb_xp );
752
753    // update "numb" and "hint" variables as required
754    numb++;
755    if ( (cluster - 1) < hint ) hint = cluster - 1;
756
757    // update free_clusters
758    hal_remote_s32( numb_xp , numb );
759    hal_remote_s32( hint_xp , hint );
760
761    // update FS_INFO sector on IOC device
762    error = fatfs_update_ioc_fsinfo( fatfs_ctx_xp );
763
764    if( error ) 
765    {
766        printk("\n[ERROR] in %s : cannot update FS_INFO on IOC\n", __FUNCTION__ );
767        return -1;
768    }
769
770#if DEBUG_FATFS_FREE_CLUSTERS
771cycle = (uint32_t)hal_get_cycles();
772if( DEBUG_FATFS_FREE_CLUSTERS < (uint32_t)hal_get_cycles() )
773printk("\n[%s] thread[%x,%x] exit / hint %x / free %x / cycle %d\n",
774__FUNCTION__, this->process->pid, this->trdid,
775hal_remote_l32( hint_xp ), hal_remote_l32( numb_xp ), cycle );
776#endif
777
778    return 0;
779
780}  // end fatfs_free_clusters_increment()
781
782//////////////////////////////////////////////////////////////////////////////////////////
783// This recursive function is called by the generic function fatfs_release_inode().
784// It release all FATFS clusters allocated to a given inode to the FAT mapper.
785// It can be called by a thread running in any cluster, as it use remote pointers
786// to access both the FAT mapper and the FATFS context in the FAT cluster, defined
787// by the <fat_mapper_xp> and <fatfs_ctx_xp> arguments.
788// The removal is done in reverse order of the linked list (from last cluster to first).
789// It returns in the <dirty_page_min> and <dirty_page_max> buffers the indexes of the
790// modified pages in the FAT mapper.
791// It updates the FAT mapper and the free_cluster info in the FATFS context, but does NOT
792// update the FAT and the FS_INFO on IOC device.
793//////////////////////////////////////////////////////////////////////////////////////////
794// @ fat_mapper_xp  : [in]  extended pointer on FAT mapper.
795// @ fatfs_ctx_xp   : [in]  extended pointer on FATFS context in FAT cluster.
796// @ cluster        : [in]  index of cluster to be released from FAT mapper.
797// @ dirty_page_min : [out] pointer on buffer for min dirty page index.
798// @ dirty_page_max : [out] pointer on buffer for max dirty page index.
799// @ return 0 if success / return -1 if error.
800//////////////////////////////////////////////////////////////////////////////////////////
801static error_t fatfs_recursive_release( xptr_t      fat_mapper_xp,
802                                        xptr_t      fatfs_ctx_xp,
803                                        uint32_t    cluster,
804                                        uint32_t  * dirty_page_min,
805                                        uint32_t  * dirty_page_max )
806{
807    uint32_t next;       // next cluster index
808    uint32_t page_id;    // page index in FAT mapper
809    uint32_t word_id;    // word index in page
810
811    // get page index and word index from cluster
812    page_id = cluster >> 10;
813    word_id = cluster & 0x3FF;
814
815    // get next cluster index from FAT mapper
816    if ( mapper_remote_get_32( fat_mapper_xp,
817                               page_id,
818                               word_id,
819                               &next ) ) return -1;
820
821#if (DEBUG_FATFS_RELEASE_INODE & 1)
822thread_t * this = CURRENT_THREAD;
823if ( DEBUG_FATFS_RELEASE_INODE < (uint32_t)hal_get_cycles() )
824printk("\n[%s] thread[%x,%x] access FAT for cluster %x / next %x\n",
825__FUNCTION__, this->process->pid, this->trdid, cluster, next );
826#endif
827
828    if ( next < END_OF_CHAIN_CLUSTER_MIN )  // non terminal case
829    {
830        // call fatfs_recursive_release() on next cluster
831        if ( fatfs_recursive_release( fat_mapper_xp,
832                                      fatfs_ctx_xp,
833                                      next,
834                                      dirty_page_min,
835                                      dirty_page_max ) ) return -1;
836    }       
837
838    // update FAT mapper
839    if ( mapper_remote_set_32( fat_mapper_xp,
840                               page_id, 
841                               word_id,
842                               FREE_CLUSTER ) ) return -1;
843
844    // update dirty_page_min / dirty_page_max buffers
845    if( page_id < *dirty_page_min ) *dirty_page_min = page_id;
846    if( page_id > *dirty_page_max ) *dirty_page_max = page_id;
847
848    // Update free_cluster info in FATFS context
849    return fatfs_free_clusters_increment( fatfs_ctx_xp , cluster );
850
851}  // end fatfs_recursive_release()
852
853
854//////////////////////////////////////////////////////////////////////////////////////////
855//              FATFS specific extern functions
856//////////////////////////////////////////////////////////////////////////////////////////
857
858///////////////////////////////////
859void fatfs_display_ctx( cxy_t cxy )
860{
861    // get pointer on local FATFS context
862    vfs_ctx_t   * vfs_ctx = &fs_context[FS_TYPE_FATFS];
863        fatfs_ctx_t * ctx     = hal_remote_lpt( XPTR( cxy , &vfs_ctx->extend ) );
864
865    uint32_t fat_sectors       = hal_remote_l32( XPTR( cxy , &ctx->fat_sectors_count ) );
866    uint32_t sector_size       = hal_remote_l32( XPTR( cxy , &ctx->bytes_per_sector ) );
867    uint32_t sec_per_clus      = hal_remote_l32( XPTR( cxy , &ctx->sectors_per_cluster ) );
868    uint32_t fat_lba           = hal_remote_l32( XPTR( cxy , &ctx->fat_begin_lba ) );
869    uint32_t data_lba          = hal_remote_l32( XPTR( cxy , &ctx->cluster_begin_lba ) );
870    uint32_t fsinfo_lba        = hal_remote_l32( XPTR( cxy , &ctx->fs_info_lba ) );
871    uint32_t root_dir_clus     = hal_remote_l32( XPTR( cxy , &ctx->root_dir_cluster ) );
872    uint32_t free_clusters     = hal_remote_l32( XPTR( cxy , &ctx->free_clusters ) );
873    uint32_t free_cluster_hint = hal_remote_l32( XPTR( cxy , &ctx->free_cluster_hint ) );
874    xptr_t   mapper_xp         = hal_remote_l64( XPTR( cxy , &ctx->fat_mapper_xp ) );
875    void   * fs_info_buffer    = hal_remote_lpt( XPTR( cxy , &ctx->fs_info_buffer ) );
876
877    printk("\n*** FAT context in cluster %x\n" 
878           "- fat_sectors       = %d\n"
879           "- sector size       = %d\n"
880           "- cluster size      = %d\n"
881           "- fat_lba           = %x\n"
882           "- data_lba          = %x\n"
883           "- fsinfo_lba        = %x\n"
884           "- root_dir_cluster  = %x\n"
885           "- free_clusters     = %x\n"
886           "- free_cluster_hint = %x\n"
887           "- fat_mapper_ptr    = %x\n"
888           "- fs_info_buffer    = %x\n",
889           cxy,
890           fat_sectors,
891           sector_size,
892           sector_size * sec_per_clus,
893           fat_lba,
894           data_lba,
895           fsinfo_lba,
896           root_dir_clus,
897           free_clusters,
898           free_cluster_hint,
899           GET_PTR( mapper_xp ),
900           fs_info_buffer );
901
902}  // end fatfs_ctx_display()
903
904//////////////////////////////////////////
905void fatfs_display_fat( uint32_t  page_id,
906                        uint32_t  nentries )
907{
908    uint32_t line;
909    uint32_t maxline;
910
911    // compute number of lines to display
912    maxline = nentries >> 3;
913    if( nentries & 0x7 ) maxline++;
914
915    // get pointer on local FATFS context
916    vfs_ctx_t   * vfs_ctx       = &fs_context[FS_TYPE_FATFS];
917    fatfs_ctx_t * loc_fatfs_ctx = (fatfs_ctx_t *)vfs_ctx->extend;
918
919    // get extended pointer on FAT mapper
920    xptr_t fat_mapper_xp  = loc_fatfs_ctx->fat_mapper_xp;
921
922    // get FAT cluster identifier
923    cxy_t  fat_cxy = GET_CXY( fat_mapper_xp );
924
925    // get pointer on FATFS context in FAT cluster
926    fatfs_ctx_t * fat_fatfs_ctx = hal_remote_lpt( XPTR( fat_cxy , &vfs_ctx->extend ) );
927 
928    // get current value of hint and free_clusters
929    uint32_t hint = hal_remote_l32( XPTR( fat_cxy , &fat_fatfs_ctx->free_cluster_hint ) );
930    uint32_t free = hal_remote_l32( XPTR( fat_cxy , &fat_fatfs_ctx->free_clusters ) );
931 
932    // get extended pointer on requested page in FAT mapper
933    xptr_t     page_xp  = mapper_remote_get_page( fat_mapper_xp , page_id );
934
935    // get extended pointer on requested page base
936    xptr_t     base_xp  = ppm_page2base( page_xp );
937    void     * base     = GET_PTR( base_xp );
938
939    printk("\n***** FAT mapper / cxy %x / page_id %d / base %x / free_clusters %x / hint %x\n",
940    fat_cxy, page_id, base, free, hint );
941
942    for( line = 0 ; line < maxline ; line++ )
943    {
944        printk("%x : %X | %X | %X | %X | %X | %X | %X | %X\n", (line<<3),
945        hal_remote_l32( base_xp + ((line<<5)      ) ),
946        hal_remote_l32( base_xp + ((line<<5) + 4  ) ),
947        hal_remote_l32( base_xp + ((line<<5) + 8  ) ),
948        hal_remote_l32( base_xp + ((line<<5) + 12 ) ),
949        hal_remote_l32( base_xp + ((line<<5) + 16 ) ),
950        hal_remote_l32( base_xp + ((line<<5) + 20 ) ),
951        hal_remote_l32( base_xp + ((line<<5) + 24 ) ),
952        hal_remote_l32( base_xp + ((line<<5) + 28 ) ) );
953    }
954
955}  // end fatfs_display_fat()
956
957///////////////////////////////////////////////////////
958error_t fatfs_get_cluster( uint32_t   first_cluster_id,
959                           uint32_t   searched_page_index,
960                           uint32_t * searched_cluster_id )
961{
962    xptr_t     current_page_xp;        // pointer on current page descriptor
963    uint32_t * buffer;                 // pointer on current page (array of uint32_t)
964    uint32_t   current_page_index;     // index of current page in FAT
965    uint32_t   current_slot_index;     // index of slot in current page
966    uint32_t   page_count_in_file;     // index of page in file (index in linked list)
967    uint32_t   next_cluster_id;        // content of current FAT slot
968    xptr_t     lock_xp;                // extended pointer on FAT lock
969
970assert( (searched_page_index > 0) ,
971"no FAT access required for first page\n");
972
973#if DEBUG_FATFS_GET_CLUSTER
974uint32_t   cycle = (uint32_t)hal_get_cycles();
975thread_t * this  = CURRENT_THREAD;
976if( DEBUG_FATFS_GET_CLUSTER < cycle )
977printk("\n[%s] thread[%x,%x] enter / first_cluster_id %d / searched_index %d / cycle %d\n",
978__FUNCTION__, this->process->pid, this->trdid, first_cluster_id, searched_page_index, cycle );
979#endif
980
981    // get local pointer on VFS context (same in all clusters)
982    vfs_ctx_t * vfs_ctx = &fs_context[FS_TYPE_FATFS];
983
984    // get local pointer on local FATFS context
985    fatfs_ctx_t * loc_fatfs_ctx = vfs_ctx->extend;
986
987    // get extended pointer and cluster on FAT mapper
988    xptr_t fat_mapper_xp  = loc_fatfs_ctx->fat_mapper_xp;
989    cxy_t  fat_cxy        = GET_CXY( fat_mapper_xp );
990
991    // get local pointer on FATFS context in FAT cluster
992    fatfs_ctx_t * fat_fatfs_ctx = hal_remote_lpt( XPTR( fat_cxy , &vfs_ctx->extend ) );
993
994    // build extended pointer on FAT lock in FAT cluster
995    lock_xp = XPTR( fat_cxy , &fat_fatfs_ctx->lock );
996
997    // take FAT lock in read mode
998    remote_rwlock_rd_acquire( lock_xp );
999
1000    // initialize loop variable (1024 slots per page)
1001    current_page_index  = first_cluster_id >> 10;
1002    current_slot_index  = first_cluster_id & 0x3FF;
1003    page_count_in_file  = 0;
1004    next_cluster_id     = 0xFFFFFFFF;
1005
1006    // scan FAT mapper (i.e. traverse FAT linked list)
1007    while( page_count_in_file < searched_page_index )
1008    {
1009        // get pointer on current page descriptor in FAT mapper
1010        current_page_xp = mapper_remote_get_page( fat_mapper_xp , current_page_index );
1011
1012        if( current_page_xp == XPTR_NULL )
1013        {
1014            printk("\n[ERROR] in %s : cannot get next page from FAT mapper\n", __FUNCTION__);
1015            remote_rwlock_rd_release( lock_xp );
1016            return -1;
1017        }
1018
1019        // get pointer on buffer for current page
1020        xptr_t base_xp = ppm_page2base( current_page_xp );
1021        buffer = (uint32_t *)GET_PTR( base_xp );
1022
1023        // get FAT slot content
1024        next_cluster_id = hal_remote_l32( XPTR( fat_cxy, &buffer[current_slot_index] ) );
1025
1026#if (DEBUG_FATFS_GET_CLUSTER & 1)
1027if( DEBUG_FATFS_GET_CLUSTER < cycle )
1028printk("\n[%s] traverse FAT / current_page_index = %d\n"
1029"current_slot_index = %d / next_cluster_id = %d\n",
1030__FUNCTION__, current_page_index, current_slot_index , next_cluster_id );
1031#endif
1032        // update loop variables
1033        current_page_index = next_cluster_id >> 10;
1034        current_slot_index = next_cluster_id & 0x3FF;
1035        page_count_in_file++;
1036    }
1037
1038    if( next_cluster_id == 0xFFFFFFFF )
1039    {
1040        printk("\n[ERROR] in %s : searched_cluster_id not found in FAT\n", __FUNCTION__ );
1041        remote_rwlock_rd_release( lock_xp );
1042        return -1;
1043    }
1044   
1045    // release FAT lock
1046    remote_rwlock_rd_release( lock_xp );
1047
1048#if DEBUG_FATFS_GET_CLUSTER
1049cycle = (uint32_t)hal_get_cycles();
1050if( DEBUG_FATFS_GET_CLUSTER < cycle )
1051printk("\n[%s] thread[%x,%x] exit / searched_cluster_id = %d / cycle %d\n",
1052__FUNCTION__, this->process->pid, this->trdid, next_cluster_id / cycle );
1053#endif
1054
1055    *searched_cluster_id = next_cluster_id;
1056    return 0;
1057
1058}  // end fatfs_get_cluster()
1059
1060
1061
1062///////////////////////////////////////////////////////////////////////////////////////
1063// Generic API : the following functions are called by the kernel VFS
1064//               and must be defined by all supported file systems.
1065///////////////////////////////////////////////////////////////////////////////////////
1066
1067/////////////////////////////////////
1068fatfs_ctx_t * fatfs_ctx_alloc( void )
1069{
1070    kmem_req_t    req;
1071        req.type    = KMEM_KCM;
1072        req.order   = bits_log2( sizeof(fatfs_ctx_t) );
1073    req.flags   = AF_KERNEL | AF_ZERO;
1074
1075        return kmem_alloc( &req );
1076}
1077
1078//////////////////////////////////////////////
1079void fatfs_ctx_init( fatfs_ctx_t * fatfs_ctx )
1080{
1081    error_t       error;
1082    kmem_req_t    req;
1083    uint8_t     * buffer;
1084    xptr_t        buffer_xp;
1085
1086#if DEBUG_FATFS_CTX_INIT
1087uint32_t   cycle = (uint32_t)hal_get_cycles();
1088thread_t * this  = CURRENT_THREAD;
1089if( DEBUG_FATFS_CTX_INIT < cycle )
1090printk("\n[%s] thread[%x,%x] enter for fatfs_ctx = %x / cycle %d\n",
1091__FUNCTION__ , this->process->pid, this->trdid, fatfs_ctx , cycle );
1092#endif
1093
1094// check argument
1095assert( (fatfs_ctx != NULL) , "pointer on FATFS context is NULL" );
1096
1097// check only cluster 0 does FATFS initialization
1098assert( (local_cxy == 0) , "only cluster 0 can initialize FATFS");
1099
1100    // allocate a permanent 512 bytes buffer to store
1101    // - temporarily the BOOT sector
1102    // - permanently the FS_INFO sector
1103        req.type    = KMEM_KCM;
1104    req.order   = 9;                    // 512 bytes
1105    req.flags   = AF_KERNEL | AF_ZERO;
1106        buffer      = kmem_alloc( &req );
1107
1108    if( buffer == NULL ) 
1109    {
1110        printk("\n[PANIC] in %s : cannot allocate buffer\n", __FUNCTION__ );
1111        hal_core_sleep();
1112    }
1113     
1114    buffer_xp   = XPTR( local_cxy , buffer );
1115
1116    // load the BOOT record from device
1117    error = dev_ioc_sync_read( buffer_xp , 0 , 1 );
1118
1119    if ( error )
1120    {
1121        printk("\n[PANIC] in %s : cannot access boot record\n", __FUNCTION__ );
1122        hal_core_sleep();
1123    }
1124
1125#if (DEBUG_FATFS_CTX_INIT & 0x1)
1126if( DEBUG_FATFS_CTX_INIT < cycle )
1127putb( "boot record", buffer , 256 );
1128#endif
1129
1130    // get sector size from boot record
1131    uint32_t sector_size = fatfs_get_record( BPB_BYTSPERSEC , buffer );
1132    if ( sector_size != 512 )
1133    {
1134        printk("\n[PANIC] in %s : sector size must be 512 bytes\n", __FUNCTION__ );
1135        hal_core_sleep();
1136    }
1137
1138    // get cluster size from boot record
1139    uint32_t nb_sectors = fatfs_get_record( BPB_SECPERCLUS , buffer );
1140    if ( nb_sectors != 8 )
1141    {
1142        printk("\n[PANIC] in %s : cluster size must be 8 sectors\n", __FUNCTION__ );
1143        hal_core_sleep();
1144    }
1145
1146    // get number of FAT copies from boot record
1147    uint32_t nb_fats = fatfs_get_record( BPB_NUMFATS , buffer );
1148    if ( nb_fats != 1 )
1149    {
1150        printk("\n[PANIC] in %s : number of FAT copies must be 1\n", __FUNCTION__ );
1151        hal_core_sleep();
1152    }
1153
1154    // get number of sectors in FAT from boot record
1155    uint32_t fat_sectors = fatfs_get_record( BPB_FAT32_FATSZ32 , buffer );
1156    if ( (fat_sectors & 0xF) != 0 )
1157    {
1158        printk("\n[PANIC] in %s : FAT size not multiple of 16 sectors\n", __FUNCTION__ );
1159        hal_core_sleep();
1160    }
1161
1162    // get root cluster from boot record
1163    uint32_t root_cluster = fatfs_get_record( BPB_FAT32_ROOTCLUS , buffer );
1164    if ( root_cluster != 2 ) 
1165    {
1166        printk("\n[PANIC] in %s : root cluster index must be 2\n", __FUNCTION__ );
1167        hal_core_sleep();
1168    }
1169
1170    // get FAT lba from boot record
1171    uint32_t fat_lba = fatfs_get_record( BPB_RSVDSECCNT , buffer );
1172
1173    // get FS_INFO sector lba from boot record
1174    uint32_t fs_info_lba = fatfs_get_record( BPB_FAT32_FSINFO , buffer );
1175
1176    // load the FS_INFO record from device
1177    error = dev_ioc_sync_read( buffer_xp , fs_info_lba , 1 );
1178
1179    if ( error )
1180    {
1181        printk("\n[PANIC] in %s : cannot access FS_INFO record\n", __FUNCTION__ );
1182        hal_core_sleep();
1183    }
1184
1185    // get free_clusters number from FS_INFO record
1186    uint32_t free_clusters = fatfs_get_record( FS_FREE_CLUSTERS , buffer );
1187    if ( free_clusters >= fat_sectors << 7 )
1188    {
1189        printk("\n[PANIC] in %s : unconsistent free_clusters\n", __FUNCTION__ );
1190        hal_core_sleep();
1191    }
1192
1193    // get free_cluster_hint from FS_INFO record
1194    uint32_t free_cluster_hint = fatfs_get_record( FS_FREE_CLUSTER_HINT , buffer );
1195
1196    if ( free_cluster_hint >= fat_sectors << 7 )
1197    {
1198        printk("\n[PANIC] in %s : unconsistent free_cluster_hint\n", __FUNCTION__ );
1199        hal_core_sleep();
1200    }
1201
1202    // allocate a mapper for the FAT itself
1203    mapper_t * fat_mapper = mapper_create( FS_TYPE_FATFS );
1204    if ( fat_mapper == NULL )
1205    {
1206        printk("\n[PANIC] in %s : no memory for FAT mapper\n", __FUNCTION__ );
1207        hal_core_sleep();
1208    }
1209
1210    // the inode field is NULL for the FAT mapper
1211    fat_mapper->inode = NULL;
1212
1213    // initialize the FATFS context
1214    fatfs_ctx->fat_begin_lba         = fat_lba;
1215    fatfs_ctx->fat_sectors_count     = fat_sectors; 
1216    fatfs_ctx->bytes_per_sector      = sector_size;
1217    fatfs_ctx->sectors_per_cluster   = nb_sectors;
1218    fatfs_ctx->cluster_begin_lba     = fat_lba + fat_sectors;
1219    fatfs_ctx->root_dir_cluster      = 2;
1220    fatfs_ctx->fat_mapper_xp         = XPTR( local_cxy , fat_mapper );
1221    fatfs_ctx->fs_info_lba           = fs_info_lba;
1222    fatfs_ctx->free_clusters         = free_clusters;
1223    fatfs_ctx->free_cluster_hint     = free_cluster_hint;
1224    fatfs_ctx->fs_info_buffer        = buffer;
1225
1226    remote_rwlock_init( XPTR( local_cxy , &fatfs_ctx->lock ) , LOCK_FATFS_FAT );
1227
1228#if (DEBUG_FATFS_CTX_INIT & 0x1)
1229if( DEBUG_FATFS_CTX_INIT < cycle )
1230fatfs_ctx_display( fatfs_ctx );
1231#endif
1232
1233#if DEBUG_FATFS_CTX_INIT
1234cycle = (uint32_t)hal_get_cycles();
1235if( DEBUG_FATFS_CTX_INIT < cycle )
1236printk("\n[%s]  thread[%x,%x] exit for fatfs_ctx = %x / cycle %d\n",
1237__FUNCTION__, this->process->pid, this->trdid, fatfs_ctx, cycle );
1238#endif
1239
1240}  // end fatfs_ctx_init()
1241
1242/////////////////////////////////////////////////
1243void fatfs_ctx_destroy( fatfs_ctx_t * fatfs_ctx )
1244{
1245    kmem_req_t    req;
1246    req.type = KMEM_KCM;
1247    req.ptr  = fatfs_ctx;
1248    kmem_free( &req );
1249}
1250
1251///////////////////////////////////////////////
1252error_t fatfs_add_dentry( vfs_inode_t  * inode,
1253                          vfs_dentry_t * dentry )
1254{
1255    error_t       error;
1256    uint32_t      length;        // dentry name length
1257    uint32_t      nb_lfn;        // number or required LFN
1258    char          sfn[11];       // buffer for SFN name
1259    uint8_t       checksum;      // name checksum
1260    mapper_t    * mapper;        // loal pointer on parent inode mapper
1261    xptr_t        mapper_xp;     // extended pointer on parent inode mapper
1262    xptr_t        child_xp;      // extended pointer on child inode
1263    cxy_t         child_cxy;     // child inode cluster
1264    vfs_inode_t * child_ptr;     // child inode local pointer
1265    uint32_t      size;          // child inode size
1266    uint32_t      type;          // child inode type
1267    uint32_t      cluster;       // child inode cluster index
1268
1269#if DEBUG_FATFS_ADD_DENTRY
1270char       dir_name[CONFIG_VFS_MAX_NAME_LENGTH];
1271uint32_t   cycle = (uint32_t)hal_get_cycles();
1272thread_t * this  = CURRENT_THREAD;
1273vfs_inode_get_name( XPTR( local_cxy , inode ) , dir_name );
1274if( DEBUG_FATFS_ADD_DENTRY < cycle )
1275printk("\n[%s]  thread[%x,%x] enter / parent <%s> / child <%s> / cycle %d\n",
1276__FUNCTION__, this->process->pid, this->trdid, dir_name, dentry->name, cycle );
1277#endif
1278
1279// check arguments
1280assert( (inode != NULL) , "inode pointer is NULL\n" );
1281assert( (dentry != NULL) , "dentry pointer is NULL\n" );
1282assert( (inode->mapper != NULL ) , "mapper pointer is NULL\n" );
1283 
1284    // get pointers on directory mapper
1285    mapper    = inode->mapper;
1286    mapper_xp = XPTR( local_cxy , mapper );
1287
1288    // get extended pointers on remote child inode
1289    child_xp  = dentry->child_xp;
1290    child_cxy = GET_CXY( child_xp );
1291    child_ptr = GET_PTR( child_xp );
1292
1293    // get relevant infos from child inode
1294    type    =                     hal_remote_l32( XPTR( child_cxy , &child_ptr->type ) );
1295    size    =                     hal_remote_l32( XPTR( child_cxy , &child_ptr->size ) );
1296    cluster = (uint32_t)(intptr_t)hal_remote_lpt( XPTR( child_cxy , &child_ptr->extend ) );
1297
1298    // analyse dentry name
1299    error = fatfs_name_format( dentry->name,
1300                               &length,
1301                               &nb_lfn,
1302                               sfn,
1303                               &checksum );
1304    if ( error )
1305    {
1306        printk("\n[ERROR] in %s : dentry name > 31 bytes\n", __FUNCTION__ );
1307        return -1;
1308    }
1309                               
1310    // Search end of directory with two embedded loops:
1311    // - scan the pages in the mapper
1312    // - scan the entries in each page to find NO_MORE_ENTRY
1313
1314    xptr_t     page_xp;                 // extended pointer on page descriptor
1315    xptr_t     base_xp;                 // extended pointer on page base
1316    uint8_t  * base;                    // local pointer on page base (array of bytes)
1317    uint32_t   page_id = 0;             // page index in mapper
1318    uint32_t   offset  = 0;             // position in page
1319    uint32_t   found   = 0;             // NO_MORE_ENTRY found
1320
1321    // loop on pages in mapper
1322    while ( found == 0 )
1323    {
1324        // get extended pointer on page descriptor in mapper
1325        page_xp  = mapper_remote_get_page( mapper_xp , page_id );
1326
1327        if ( page_xp == XPTR_NULL )
1328        {
1329            printk("\n[ERROR] in %s : cannot extend directory mapper\n", __FUNCTION__ );
1330            return -1;
1331        }
1332       
1333        // get pointer on page base
1334        base_xp = ppm_page2base( page_xp );
1335        base = GET_PTR( base_xp );
1336
1337        // loop on directory entries in this page
1338        while ( (offset < 4096) && (found == 0) )
1339        {
1340            if ( fatfs_get_record( LDIR_ORD, (base + offset) ) == NO_MORE_ENTRY )
1341            {
1342                found = 1;
1343            } 
1344            else
1345            {
1346                offset = offset + 32;
1347            }
1348        }  // end loop on entries
1349
1350        if ( found == 0 )
1351        {
1352            page_id++;
1353            offset = 0;
1354        }
1355    }  // end loop on pages
1356
1357    // Modify the directory mapper: depending on the name length,
1358    // the new child requires to write (3, 4, or 5) directory entries.
1359    // To actually register the new child, we use a 5 steps FSM
1360    // (one state per entry to be written), that is traversed as:
1361    // LFN3 -> LFN2 -> LFN1 -> NORMAL -> NOMORE
1362    // At most two pages are modified:
1363    // - the page containing the NO_MORE_ENTRY is always modified
1364    // - the following page can be modified if the name spread on to pages.
1365
1366    char * name = dentry->name;
1367
1368    uint32_t step;          // FSM state
1369
1370    if      ( nb_lfn == 1 ) step = 3;
1371    else if ( nb_lfn == 2 ) step = 4;
1372    else if ( nb_lfn == 3 ) step = 5;
1373   
1374    uint8_t  * entry;       // pointer on directory entry to be written
1375    uint32_t   i;           // byte index in one 32 bytes directory
1376    uint32_t   c;           // character index in name
1377
1378    while ( step )   
1379    {
1380        // when the new child is split on two pages,
1381        // we need to access a new page in mapper
1382        if ( offset >= 4096 )
1383        {
1384            // copy the modified page to IOC device
1385            fatfs_move_page( page_xp , IOC_SYNC_WRITE );   
1386
1387            // get the next page in FAT mapper
1388            page_xp  = mapper_remote_get_page( mapper_xp , page_id + 1 );
1389
1390            if ( page_xp == XPTR_NULL )
1391            {
1392                printk("\n[ERROR] in %s : cannot extend directory mapper\n", __FUNCTION__ );
1393                return -1;
1394            }
1395       
1396            // get pointer on page base
1397            base_xp = ppm_page2base( page_xp );
1398            base = GET_PTR( base_xp );
1399           
1400            // update offset
1401            offset = 0;
1402        }
1403
1404        // compute directory entry address
1405        entry = base + offset;
1406
1407#if (DEBUG_FATFS_ADD_DENTRY & 1)
1408cycle = (uint32_t)hal_get_cycles();
1409if( DEBUG_FATFS_ADD_DENTRY < cycle )
1410printk("\n[%s] FSM step = %d / offset = %x / nb_lfn = %d / cycle %d\n",
1411__FUNCTION__, step, offset, nb_lfn, cycle );
1412#endif
1413
1414        // write 32 bytes (one directory entry) per iteration
1415        switch ( step )
1416        {
1417            case 5:   // write LFN3 entry
1418            {
1419                c = 26;
1420                // scan the 32 bytes in dir_entry
1421                for ( i = 0 ; i < 32 ; i++ )
1422                {
1423                    if (i == 0)
1424                    {
1425                        if ( nb_lfn == 3) entry[i] = 0x43;
1426                        else              entry[i] = 0x03;
1427                    }
1428                    else if ( ( ((i >= 1 ) && (i<=10) && ((i&1)==1))   ||
1429                                ((i >= 14) && (i<=25) && ((i&1)==0))   ||
1430                                ((i >= 28) && (i<=31) && ((i&1)==0)) ) &&
1431                              ( c < length ) )
1432                    {
1433                                          entry[i] = name[c];
1434                                          c++;
1435                    }
1436                    else if (i == 11)     entry[i] = 0x0F;
1437                    else if (i == 13)     entry[i] = checksum;
1438                    else                  entry[i] = 0x00;
1439                }
1440                step--;
1441                break;
1442            }
1443            case 4:   // write LFN2 entry 
1444            {
1445                c = 13;
1446                // scan the 32 bytes in dir_entry
1447                for ( i = 0 ; i < 32 ; i++ )
1448                {
1449                    if (i == 0)
1450                    {
1451                        if ( nb_lfn == 2) entry[i] = 0x42;
1452                        else              entry[i] = 0x02;
1453                    }
1454                    else if ( ( ((i >= 1 ) && (i<=10) && ((i&1)==1))   ||
1455                                ((i >= 14) && (i<=25) && ((i&1)==0))   ||
1456                                ((i >= 28) && (i<=31) && ((i&1)==0)) ) &&
1457                              ( c < length ) )
1458                    {
1459                                          entry[i] = name[c];
1460                                          c++;
1461                    }
1462                    else if (i == 11)     entry[i] = 0x0F;
1463                    else if (i == 13)     entry[i] = checksum;
1464                    else                  entry[i] = 0x00;
1465                }
1466                step--;
1467                break;
1468            }
1469            case 3:   // Write LFN1 entry   
1470            {
1471                c = 0;
1472                // scan the 32 bytes in dir_entry
1473                for ( i = 0 ; i < 32 ; i++ )
1474                {
1475                    if (i == 0)
1476                    {
1477                        if ( nb_lfn == 1) entry[i] = 0x41;
1478                        else              entry[i] = 0x01;
1479                    }
1480                    else if ( ( ((i >= 1 ) && (i<=10) && ((i&1)==1))   ||
1481                                ((i >= 14) && (i<=25) && ((i&1)==0))   ||
1482                                ((i >= 28) && (i<=31) && ((i&1)==0)) ) &&
1483                              ( c < length ) )
1484                    {
1485                                          entry[i] = name[c];
1486                                          c++;
1487                    }
1488                    else if (i == 11)     entry[i] = 0x0F;
1489                    else if (i == 13)     entry[i] = checksum;
1490                    else                  entry[i] = 0x00;
1491                }
1492                step--;
1493                break;
1494            }
1495            case 2:   // write NORMAL entry     
1496            {
1497                // scan the 32 bytes in dir_entry
1498                for ( i = 0 ; i < 32 ; i++ )
1499                {
1500                    if      ( i < 11 )                              // 8.3 SFN
1501                    {
1502                                          entry[i] = sfn[i];
1503                    }
1504                    else if (i == 11)                               // ATTR
1505                    {
1506                        if (type == INODE_TYPE_DIR)  entry[i] = 0x10;
1507                        else                         entry[i] = 0x20;
1508                    }
1509                    else if (i == 20)     entry[i] = cluster>>16;   // cluster.B2
1510                    else if (i == 21)     entry[i] = cluster>>24;   // cluster.B3
1511                    else if (i == 26)     entry[i] = cluster>>0;    // cluster.B0
1512                    else if (i == 27)     entry[i] = cluster>>8;    // cluster.B1
1513                    else if (i == 28)     entry[i] = size>>0;       // size.B0
1514                    else if (i == 29)     entry[i] = size>>8;       // size.B1
1515                    else if (i == 30)     entry[i] = size>>16;      // size.B2
1516                    else if (i == 31)     entry[i] = size>>24;      // size.B3
1517                    else                  entry[i] = 0x00;
1518                }
1519
1520                // update the "extend" field in dentry descriptor
1521                dentry->extend = (void*)(intptr_t)(((page_id<<12) + offset)>>5);
1522
1523                step--;
1524                break;
1525            }
1526            case 1:   // write NOMORE entry 
1527            {
1528                entry [0] = 0x00;
1529                step--;
1530                break;
1531            }
1532        } // end switch step
1533
1534        offset += 32;
1535
1536    } // exit while     
1537
1538#if (DEBUG_FATFS_ADD_DENTRY & 1)
1539cycle = (uint32_t)hal_get_cycles();
1540if( DEBUG_FATFS_ADD_DENTRY < cycle )
1541printk("\n[%s]  thread[%x,%x] before IOC access / cycle %d\n",
1542__FUNCTION__, this->process->pid, this->trdid, cycle );
1543#endif
1544
1545    // copy the modified page to the IOC device
1546    fatfs_move_page( page_xp , IOC_SYNC_WRITE );   
1547
1548#if DEBUG_FATFS_ADD_DENTRY
1549cycle = (uint32_t)hal_get_cycles();
1550if( DEBUG_FATFS_ADD_DENTRY < cycle )
1551printk("\n[%s]  thread[%x,%x] exit / parent <%s> / child <%s> / cycle %d\n",
1552__FUNCTION__, this->process->pid, this->trdid, dir_name, dentry->name, cycle );
1553#endif
1554
1555    return 0;
1556
1557}  // end fatfs_add_dentry()
1558
1559//////////////////////////////////////////////////
1560error_t fatfs_remove_dentry( vfs_inode_t  * inode,
1561                             vfs_dentry_t * dentry )
1562{
1563    xptr_t     mapper_xp;  // extended pointer on mapper
1564    mapper_t * mapper;     // local pointer on mapper
1565    xptr_t     page_xp;    // extended pointer on mapper page descriptor
1566    xptr_t     base_xp;    // extended pointer on mapper page base
1567    uint8_t  * base;       // local pointer on mapper page base
1568
1569#if DEBUG_FATFS_REMOVE_DENTRY
1570char       dir_name[CONFIG_VFS_MAX_NAME_LENGTH];
1571uint32_t   cycle = (uint32_t)hal_get_cycles();
1572thread_t * this  = CURRENT_THREAD;
1573vfs_inode_get_name( XPTR( local_cxy , inode ) , dir_name );
1574if( DEBUG_FATFS_REMOVE_DENTRY < cycle )
1575printk("\n[%s] thread[%x,%x] enter / parent <%s> / child <%s> / cycle %d\n",
1576__FUNCTION__, this->process->pid, this->trdid, dir_name, dentry->name, cycle );
1577#endif
1578
1579// check arguments
1580assert( (inode != NULL) , "inode pointer is NULL\n" );
1581assert( (dentry != NULL) , "dentry pointer is NULL\n" );
1582assert( (inode->type == INODE_TYPE_DIR) , "inode is not a directory\n" );
1583assert( (inode->mapper != NULL ) , "mapper pointer is NULL\n" );
1584
1585    // get pointers on directory mapper
1586    mapper    = inode->mapper;
1587    mapper_xp = XPTR( local_cxy , mapper );
1588
1589    // compute number of LFN entries
1590    uint32_t nb_lfn;
1591    uint32_t name_length = strlen( dentry->name );
1592
1593    if      ( name_length <= 13 ) nb_lfn  = 1;
1594    else if ( name_length <= 26 ) nb_lfn  = 2;
1595    else                          nb_lfn  = 3;
1596
1597    // we must invalidate (2, 3 or 4) 32 bytes entries:
1598    // the NORMAL entry (registered in dentry->extend) and all preceding LFN entries
1599    // At most two pages are modified:
1600    // - the page containing the NORMAL entry is always modified.
1601    // - the preceding page is modified when the name spread on two pages.
1602
1603    // get 32 bytes directory entry index from dentry->extend
1604    uint32_t  dentry_id  = (uint32_t)(intptr_t)dentry->extend; 
1605
1606    // get page index and offset in parent directory mapper
1607    uint32_t  page_id    = dentry_id >> 7;
1608    uint32_t  offset     = (dentry_id & 0x7F)<<5;
1609
1610#if DEBUG_FATFS_REMOVE_DENTRY & 1
1611if( DEBUG_FATFS_REMOVE_DENTRY < cycle )
1612printk("\n[%s] dentry_id %x / page_id %x / offset %x\n",
1613__FUNCTION__, dentry_id, page_id, offset );
1614#endif
1615
1616    // get extended pointer on page descriptor from parent directory mapper
1617    page_xp  = mapper_remote_get_page( mapper_xp , page_id );
1618
1619    if ( page_xp == XPTR_NULL )
1620    {
1621        printk("\n[ERROR] in %s : cannot extend directory mapper\n", __FUNCTION__ );
1622        return -1;
1623    }
1624       
1625    // get pointers on page base
1626    base_xp = ppm_page2base( page_xp );
1627    base    = GET_PTR( base_xp );
1628
1629    // invalidate NORMAL entry in directory cache
1630    base[offset] = 0xE5;
1631
1632    // invalidate LFN entries
1633    while ( nb_lfn )
1634    {
1635        if (offset == 0)  // we must load page (page_id - 1)
1636        {
1637
1638// check page_id
1639assert( (page_id > 0), "page_id and offset cannot be both 0\n" );
1640
1641            // copy the modified page to the IOC device
1642            fatfs_move_page( page_xp , IOC_SYNC_WRITE );   
1643
1644            // get extended pointer on page descriptor from parent directory mapper
1645            page_xp  = mapper_remote_get_page( mapper_xp , page_id );
1646
1647            if ( page_xp == XPTR_NULL )
1648            {
1649                printk("\n[ERROR] in %s : cannot access directory mapper\n", __FUNCTION__ );
1650                return -1;
1651            }
1652       
1653            // get pointers on page base
1654            base_xp = ppm_page2base( page_xp );
1655            base    = GET_PTR( base_xp );
1656
1657            // update offset
1658            offset = 4096;
1659        }
1660
1661        offset = offset - 32;
1662
1663// check for LFN entry
1664assert( (fatfs_get_record( DIR_ATTR, base + offset ) == ATTR_LONG_NAME_MASK ),
1665"this directory entry must be a LFN\n");
1666
1667        // invalidate LFN entry
1668        base[offset] = 0xE5;
1669
1670        nb_lfn--;
1671    }     
1672
1673    // copy the modified page to the IOC device
1674    fatfs_move_page( page_xp , IOC_SYNC_WRITE );   
1675   
1676
1677#if DEBUG_FATFS_REMOVE_DENTRY
1678cycle = (uint32_t)hal_get_cycles();
1679if( DEBUG_FATFS_REMOVE_DENTRY < cycle )
1680printk("\n[%s] thread[%x,%x] exit / parent %s / child %s / cycle %d\n",
1681__FUNCTION__, this->process->pid, this->trdid, dir_name, dentry->name, cycle );
1682#endif
1683
1684    return 0;
1685
1686}  // end fatfs_remove_dentry
1687
1688
1689//////////////////////////////////////////////////////////////////////////////////////////////
1690// This static function scan the pages of a mapper containing a FAT32 directory, identified
1691// by the <mapper> argument, to find the directory entry identified by the <name> argument,
1692// and return a pointer on the directory entry, described as and array of 32 bytes, and the
1693// incex of this entry in the FAT32 mapper, seen as an array of 32 bytes entries.
1694// It is called by the fatfs_new_dentry() and fatfs_update_dentry() functions.
1695// It must be called by a thread running in the cluster containing the mapper.
1696//////////////////////////////////////////////////////////////////////////////////////////////
1697// @ mapper    : [in]  local pointer on directory mapper.
1698// @ name      : [in]  searched directory entry name.
1699// @ entry     : [out] buffer for the pointer on the 32 bytes directory entry (when found).
1700// @ index     : [out] buffer for the directory entry index in mapper.
1701// @ return 0 if found / return 1 if not found / return -1 if mapper access error.
1702//////////////////////////////////////////////////////////////////////////////////////////////
1703error_t fatfs_scan_directory( mapper_t *  mapper,
1704                              char     *  name,
1705                              uint8_t  ** entry,
1706                              uint32_t *  index )
1707{
1708    // Two embedded loops to scan the directory mapper:
1709    // - scan the parent directory mapper pages
1710    // - scan the directory entries in each 4 Kbytes page
1711
1712// check parent_inode and child_inode
1713assert( (mapper != NULL) , "mapper pointer is NULL\n" );
1714assert( (name   != NULL ), "child name is undefined\n" );
1715assert( (entry  != NULL ), "entry buffer undefined\n" );
1716
1717#if DEBUG_FATFS_SCAN_DIRECTORY
1718char       parent_name[CONFIG_VFS_MAX_NAME_LENGTH];
1719uint32_t   cycle = (uint32_t)hal_get_cycles();
1720thread_t * this  = CURRENT_THREAD;
1721vfs_inode_get_name( XPTR( local_cxy , mapper->inode ) , parent_name );
1722if( DEBUG_FATFS_SCAN_DIRECTORY < cycle )
1723printk("\n[%s]  thread[%x,%x] enter to search child <%s> in parent <%s> / cycle %d\n",
1724__FUNCTION__, this->process->pid, this->trdid, name , parent_name , cycle );
1725#endif
1726
1727    char       cname[CONFIG_VFS_MAX_NAME_LENGTH];  // name extracted from each directory entry
1728
1729    char       lfn1[16];         // buffer for one partial cname
1730    char       lfn2[16];         // buffer for one partial cname
1731    char       lfn3[16];         // buffer for one partial cname
1732    xptr_t     mapper_xp;        // extended pointer on mapper descriptor
1733    xptr_t     page_xp;          // extended pointer on page descriptor
1734    xptr_t     base_xp;          // extended pointer on page base
1735    uint8_t  * base;             // local pointer on page base
1736    uint8_t    attr;             // directory entry ATTR field
1737    uint8_t    ord;              // directory entry ORD field
1738    uint32_t   seq;              // sequence index
1739    uint32_t   lfn       = 0;    // LFN entries number
1740    int32_t    found     = 0;    // not yet = 0 / success = 1 / not found = 2 / error = -1
1741    uint32_t   page_id   = 0;    // page index in mapper
1742    uint32_t   offset    = 0;    // byte offset in page
1743
1744    mapper_xp = XPTR( local_cxy , mapper );
1745
1746    // scan the mapper pages
1747    while ( found == 0 )
1748    {
1749        // get one page
1750        page_xp = mapper_remote_get_page( mapper_xp , page_id );
1751
1752        if( page_xp == XPTR_NULL)
1753        {
1754            found = -1;
1755        }
1756
1757        // get page base
1758        base_xp = ppm_page2base( page_xp );
1759        base    = (uint8_t *)GET_PTR( base_xp );
1760
1761#if (DEBUG_FATFS_SCAN_DIRECTORY & 0x1)
1762if( DEBUG_FATFS_SCAN_DIRECTORY < cycle )
1763mapper_display_page( mapper_xp , page_id , 256 );
1764#endif
1765        // scan this page until end of directory, end of page, or name found
1766        while( (offset < 4096) && (found == 0) )
1767        {
1768            attr = fatfs_get_record( DIR_ATTR , base + offset );   
1769            ord  = fatfs_get_record( LDIR_ORD , base + offset );   
1770
1771            if (ord == NO_MORE_ENTRY)                 // no more entry => break
1772            {
1773                found = 2;
1774            }
1775            else if ( ord == FREE_ENTRY )             // free entry => skip
1776            {
1777                offset = offset + 32;
1778            }
1779            else if ( attr == 0x28 )                  // volune_id => skip
1780            {
1781                offset = offset + 32;
1782            }
1783            else if ( attr == ATTR_LONG_NAME_MASK )   // LFN entry => get partial cname
1784            {
1785                seq = ord & 0x3;
1786                lfn = (seq > lfn) ? seq : lfn;   
1787                if      ( seq == 1 ) fatfs_get_name_from_long( base + offset, lfn1 );
1788                else if ( seq == 2 ) fatfs_get_name_from_long( base + offset, lfn2 );
1789                else if ( seq == 3 ) fatfs_get_name_from_long( base + offset, lfn3 );
1790                offset = offset + 32;
1791            }
1792            else                                 // NORMAL entry
1793            {
1794                // build the extracted name
1795                if      ( lfn == 0 )
1796                {
1797                    fatfs_get_name_from_short( base + offset , cname );
1798                }
1799                else if ( lfn == 1 )
1800                {
1801                    strcpy( cname      , lfn1 );
1802                }   
1803                else if ( lfn == 2 ) 
1804                {
1805                    strcpy( cname      , lfn1 );
1806                    strcpy( cname + 13 , lfn2 );
1807                }
1808                else if ( lfn == 3 ) 
1809                {
1810                    strcpy( cname      , lfn1 );
1811                    strcpy( cname + 13 , lfn2 );
1812                    strcpy( cname + 26 , lfn3 );
1813                }
1814
1815                // get dentry arguments if extracted cname == searched name
1816                if ( strcmp( name , cname ) == 0 )
1817                {
1818                    *entry = base + offset;
1819                    *index = ((page_id<<12) + offset)>>5; 
1820                    found     = 1;
1821                }
1822                offset = offset + 32;
1823                lfn    = 0;
1824            }
1825        }  // end loop on directory entries in page
1826
1827        page_id++;
1828        offset = 0;
1829
1830    }  // end loop on pages
1831
1832    if( found == 1 )
1833    {
1834
1835#if DEBUG_FATFS_SCAN_DIRECTORY
1836cycle = (uint32_t)hal_get_cycles();
1837if( DEBUG_FATFS_SCAN_DIRECTORY < cycle )
1838printk("\n[%s]  thread[%x,%x] exit / found child <%s> in <%s>\n",
1839__FUNCTION__, this->process->pid, this->trdid, name, parent_name );
1840#endif
1841        return 0;
1842    }
1843    else if( found == 2 )
1844    {
1845
1846#if DEBUG_FATFS_SCAN_DIRECTORY
1847cycle = (uint32_t)hal_get_cycles();
1848if( DEBUG_FATFS_SCAN_DIRECTORY < cycle )
1849printk("\n[%s]  thread[%x,%x] exit / child <%s> in <%s> not found\n",
1850__FUNCTION__, this->process->pid, this->trdid, name, parent_name );
1851#endif
1852        return 1;
1853    }
1854    else
1855    {
1856        printk("\n[ERROR] in %s : cannot get page %d from mapper\n",
1857        __FUNCTION__, page_id );
1858
1859        return -1;
1860    }
1861}  // end fatfs_scan_directory()
1862
1863
1864
1865/////////////////////////////////////////////////////
1866error_t fatfs_new_dentry( vfs_inode_t * parent_inode,
1867                          char        * name,
1868                          xptr_t        child_inode_xp )
1869{
1870    uint8_t      * entry;            // pointer on FAT32 directory entry (array of 32 bytes)
1871    uint32_t       index;            // index of FAT32 directory entry in mapper
1872    mapper_t     * mapper;           // pointer on directory mapper
1873    uint32_t       cluster;          // directory entry cluster
1874    uint32_t       size;             // directory entry size
1875    bool_t         is_dir;           // directory entry type (file/dir)
1876    xptr_t         root_xp;          // extended pointer on root of parent dentries
1877    xptr_t         iter_xp;          // iterator for this list
1878    cxy_t          child_inode_cxy;  // child inode cluster 
1879    vfs_inode_t  * child_inode_ptr;  // child inode local pointer
1880    xptr_t         dentry_xp;        // extended pointer on searched dentry descriptor
1881    cxy_t          dentry_cxy;       // cluster identifier of dentry (must be local_cxy)
1882    vfs_dentry_t * dentry_ptr;       // local pointer
1883    error_t        error;
1884
1885    char           dir_name[CONFIG_VFS_MAX_NAME_LENGTH];
1886
1887// check arguments
1888assert( (parent_inode   != NULL)       , "parent_inode is NULL\n" );
1889assert( (name           != NULL)       , "name is NULL\n" );
1890assert( (child_inode_xp != XPTR_NULL ) , "child_inode is NULL\n" );
1891
1892    // get child inode cluster and local pointer
1893    child_inode_cxy = GET_CXY( child_inode_xp );
1894    child_inode_ptr = GET_PTR( child_inode_xp );
1895
1896    // build extended pointer on root of list of parent dentries
1897    root_xp = XPTR( child_inode_cxy , &child_inode_ptr->parents );
1898
1899// check child inode has at least one parent
1900assert( (xlist_is_empty( root_xp ) == false ), "child inode must have one parent\n");
1901
1902#if DEBUG_FATFS_GET_DENTRY
1903uint32_t   cycle = (uint32_t)hal_get_cycles();
1904thread_t * this  = CURRENT_THREAD;
1905vfs_inode_get_name( XPTR( local_cxy , parent_inode ) , dir_name );
1906if( DEBUG_FATFS_GET_DENTRY < cycle )
1907printk("\n[%s]  thread[%x,%x] enter for child <%s> in parent <%s> / cycle %d\n",
1908__FUNCTION__, this->process->pid, this->trdid, name , dir_name , cycle );
1909#endif
1910
1911    // get local pointer on parent mapper
1912    mapper = parent_inode->mapper;
1913
1914    // get pointer and index in mapper for searched directory entry
1915    error  = fatfs_scan_directory( mapper, name , &entry , &index );
1916
1917    // return non fatal error if not found
1918    if( error ) return -1;
1919
1920    // get relevant infos from FAT32 directory entry
1921    cluster = (fatfs_get_record( DIR_FST_CLUS_HI , entry ) << 16) |
1922              (fatfs_get_record( DIR_FST_CLUS_LO , entry )      ) ;
1923    is_dir  = (fatfs_get_record( DIR_ATTR        , entry ) & ATTR_DIRECTORY);
1924    size    =  fatfs_get_record( DIR_FILE_SIZE   , entry );
1925
1926    // scan list of parent dentries to search the parent_inode
1927    bool_t found = false;
1928    XLIST_FOREACH( root_xp , iter_xp )
1929    {
1930        // get pointers on dentry
1931        dentry_xp  = XLIST_ELEMENT( iter_xp , vfs_dentry_t , parents );
1932        dentry_cxy = GET_CXY( dentry_xp );
1933        dentry_ptr = GET_PTR( dentry_xp );
1934
1935        // get local pointer on current parent directory inode
1936        vfs_inode_t * current = hal_remote_lpt( XPTR( dentry_cxy , &dentry_ptr->parent ) );
1937
1938        // check if current parent is the searched parent
1939        if( XPTR( dentry_cxy , current ) == XPTR( local_cxy , parent_inode ) )
1940        {
1941            found = true;
1942            break;
1943        }
1944    }
1945
1946    if( found == false )
1947    { 
1948        vfs_inode_get_name( XPTR( local_cxy , parent_inode ) , dir_name );
1949        printk("\n[ERROR] in %s : cannot find <%s> directory in list of parents for <%s>\n",
1950        __FUNCTION__, dir_name, name );
1951        return -1;
1952    }
1953
1954    // update the child inode "type", "size", and "extend" fields
1955    vfs_inode_type_t type = (is_dir) ? INODE_TYPE_DIR : INODE_TYPE_FILE;
1956
1957    hal_remote_s32( XPTR( child_inode_cxy , &child_inode_ptr->type   ) , type );
1958    hal_remote_s32( XPTR( child_inode_cxy , &child_inode_ptr->size   ) , size );
1959    hal_remote_s32( XPTR( child_inode_cxy , &child_inode_ptr->extend ) , cluster );
1960
1961    // update the dentry "extend" field
1962    dentry_ptr->extend = (void *)(intptr_t)index;
1963
1964#if DEBUG_FATFS_GET_DENTRY
1965cycle = (uint32_t)hal_get_cycles();
1966if( DEBUG_FATFS_GET_DENTRY < cycle )
1967printk("\n[%s]  thread[%x,%x] exit / intialised inode & dentry for <%s> in <%s> / cycle %d\n",
1968__FUNCTION__, this->process->pid, this->trdid, name, dir_name, cycle );
1969#endif
1970
1971    return 0;
1972
1973}  // end fatfs_new_dentry()
1974
1975//////////////////////////////////////////////////
1976error_t fatfs_update_dentry( vfs_inode_t  * inode,
1977                             vfs_dentry_t * dentry,
1978                             uint32_t       size )
1979{
1980    uint8_t  * entry;    // pointer on FAT32 directory entry (array of 32 bytes)
1981    uint32_t   index;    // index of FAT32 directory entry in mapper
1982    mapper_t * mapper;   // pointer on directory mapper
1983    error_t    error;
1984
1985    char       dir_name[CONFIG_VFS_MAX_NAME_LENGTH];
1986
1987// check arguments
1988assert( (inode  != NULL) , "inode is NULL\n" );
1989assert( (dentry != NULL) , "dentry is NULL\n" );
1990assert( (size   != 0   ) , "size is 0\n" );
1991
1992#if DEBUG_FATFS_UPDATE_DENTRY
1993uint32_t   cycle = (uint32_t)hal_get_cycles();
1994thread_t * this  = CURRENT_THREAD;
1995vfs_inode_get_name( XPTR( local_cxy , inode ) , dir_name );
1996if( DEBUG_FATFS_UPDATE_DENTRY < cycle )
1997printk("\n[%s]  thread[%x,%x] enter for <%s/%s> / size %d / cycle %d\n",
1998__FUNCTION__, this->process->pid, this->trdid, dir_name, dentry->name, size, cycle );
1999#endif
2000
2001    // get local pointer on mapper
2002    mapper = inode->mapper;
2003
2004    // get pointer and index in mapper for searched directory entry
2005    error  = fatfs_scan_directory( mapper, dentry->name , &entry , &index );
2006
2007    if( error )
2008    { 
2009        vfs_inode_get_name( XPTR( local_cxy , inode ) , dir_name );
2010        printk("\n[ERROR] in %s : cannot find <%s> in parent mapper <%s>\n",
2011        __FUNCTION__, dentry->name, dir_name );
2012        return -1;
2013    }
2014
2015    // set size in FAT32 directory entry
2016    fatfs_set_record( DIR_FILE_SIZE , entry , size );
2017
2018    // get local pointer on modified page base
2019    void * base = (void *)((intptr_t)entry & (~CONFIG_PPM_PAGE_MASK)); 
2020
2021    // get extended pointer on modified page descriptor
2022    xptr_t page_xp = ppm_base2page( XPTR( local_cxy , base ) );
2023
2024    // synchronously update the modified page on device
2025    error = fatfs_move_page( page_xp , IOC_SYNC_WRITE );
2026
2027    if( error )
2028    { 
2029        vfs_inode_get_name( XPTR( local_cxy , inode ) , dir_name );
2030        printk("\n[ERROR] in %s : cannot update parent directory <%s> on device\n",
2031        __FUNCTION__, dir_name );
2032        return -1;
2033    }
2034
2035#if DEBUG_FATFS_UPDATE_DENTRY
2036cycle = (uint32_t)hal_get_cycles();
2037if( DEBUG_FATFS_UPDATE_DENTRY < cycle )
2038printk("\n[%s]  thread[%x,%x] exit / updated size for <%s/%s> / cycle %d\n",
2039__FUNCTION__, this->process->pid, this->trdid, dir_name, dentry->name, cycle );
2040#endif
2041
2042    return 0;
2043
2044}  // end fatfs_update_dentry()
2045
2046///////////////////////////////////////////////////////
2047error_t fatfs_get_user_dir( struct vfs_inode_s * inode,
2048                            struct dirent      * array, 
2049                            uint32_t             max_dirent,
2050                            uint32_t             min_dentry,
2051                            bool_t               detailed,
2052                            uint32_t           * entries,
2053                            bool_t             * done )
2054{
2055    // Two embedded loops to scan the directory mapper:
2056    // - scan the parent directory mapper pages starting always from page 0
2057    // - scan the 32 bytes NORMAL/LFN directory entries in each page
2058    // Only valid dentries are copied : dentry_id >= min_dentry && dirent_id < dirent_max
2059
2060#if DEBUG_FATFS_GET_USER_DIR
2061char       inode_name[CONFIG_VFS_MAX_NAME_LENGTH];
2062uint32_t   cycle = (uint32_t)hal_get_cycles();
2063thread_t * this  = CURRENT_THREAD;
2064vfs_inode_get_name( XPTR( local_cxy , inode ) , inode_name );
2065if( DEBUG_FATFS_GET_USER_DIR < cycle )
2066printk("\n[%s]  thread[%x,%x] enter for inode <%s> / cycle %d\n",
2067__FUNCTION__, this->process->pid, this->trdid, inode_name , cycle );
2068#endif
2069
2070    mapper_t * mapper    = inode->mapper;
2071    xptr_t     mapper_xp = XPTR( local_cxy , mapper );
2072
2073// check mapper pointer
2074assert( (mapper != NULL) , "mapper is NULL\n");
2075   
2076// TODO handle the detailed flag
2077assert( (detailed == false), "detailed argument not supported/n");
2078
2079    char       cname[CONFIG_VFS_MAX_NAME_LENGTH];  // name extracted from each dentry
2080
2081    char       lfn1[16];           // buffer for one partial cname
2082    char       lfn2[16];           // buffer for one partial cname
2083    char       lfn3[16];           // buffer for one partial cname
2084    xptr_t     page_xp;            // extended pointer on page descriptor
2085    xptr_t     base_xp;            // extended pointer on page base
2086    uint8_t  * base;               // local pointer on page base
2087    uint8_t    attr;               // directory entry ATTR field
2088    uint8_t    ord;                // directory entry ORD field
2089    uint32_t   seq;                // sequence index
2090    uint32_t   lfn       = 0;      // LFN entries number
2091    uint32_t   offset    = 0;      // byte offset in page
2092    uint32_t   page_id   = 0;      // page index in mapper
2093    uint32_t   dentry_id = 0;      // valid (i.e. copied) dentry index in mapper
2094    uint32_t   dirent_id = 0;      // slot index in dirent array to initialize
2095    bool_t     end       = false;  // true if end of directory found
2096
2097    // loop on mapper pages
2098    while ( (end == false) && (dirent_id < max_dirent) )
2099    {
2100        // get one page from mapper
2101        page_xp = mapper_remote_get_page( mapper_xp , page_id );
2102
2103        if( page_xp == XPTR_NULL) return -1;
2104
2105        // get page base
2106        base_xp = ppm_page2base( page_xp );
2107        base    = (uint8_t *)GET_PTR( base_xp );
2108
2109#if (DEBUG_FATFS_GET_USER_DIR & 0x1)
2110if( DEBUG_FATFS_GET_USER_DIR < cycle )
2111mapper_display_page( mapper_xp , page_id , 256 );
2112#endif
2113        // loop on NORMAL/LFN (32 bytes) directory entries in this page
2114        while( (end == false) && (offset < 4096) )
2115        {
2116            // compute condition to copy one dentry to dirent array
2117            bool_t valid = (dentry_id >= min_dentry) && (dirent_id <  max_dirent );
2118
2119            attr = fatfs_get_record( DIR_ATTR , base + offset );   
2120            ord  = fatfs_get_record( LDIR_ORD , base + offset );   
2121
2122            if (ord == NO_MORE_ENTRY)                 // no more entry => break
2123            {
2124                end = true;
2125            }
2126            else if ( ord == FREE_ENTRY )             // free entry => skip
2127            {
2128                offset = offset + 32;
2129            }
2130            else if ( attr == 0x28 )                  // volune_id => skip
2131            {
2132                offset = offset + 32;
2133            }
2134            else if ( attr == ATTR_LONG_NAME_MASK )   // LFN entry
2135            {
2136                if( valid )
2137                {
2138                    // get partial cname
2139                    seq = ord & 0x3;
2140                    lfn = (seq > lfn) ? seq : lfn;   
2141                    if      ( seq == 1 ) fatfs_get_name_from_long( base + offset, lfn1 );
2142                    else if ( seq == 2 ) fatfs_get_name_from_long( base + offset, lfn2 );
2143                    else if ( seq == 3 ) fatfs_get_name_from_long( base + offset, lfn3 );
2144                }
2145                offset = offset + 32;
2146            }
2147            else                                     // NORMAL entry
2148            {
2149                // increment dentry_id
2150                dentry_id++;
2151
2152                if( valid )
2153                {
2154                    // build the complete cname
2155                    if      ( lfn == 0 )
2156                    {
2157                        fatfs_get_name_from_short( base + offset , cname );
2158                    }
2159                    else if ( lfn == 1 )
2160                    {
2161                        strcpy( cname      , lfn1 );
2162                    }   
2163                    else if ( lfn == 2 ) 
2164                    {
2165                        strcpy( cname      , lfn1 );
2166                        strcpy( cname + 13 , lfn2 );
2167                    }
2168                    else if ( lfn == 3 ) 
2169                    {
2170                        strcpy( cname      , lfn1 );
2171                        strcpy( cname + 13 , lfn2 );
2172                        strcpy( cname + 26 , lfn3 );
2173                    }
2174                   
2175                    // copy cname into dirent array
2176                    strcpy( array[dirent_id].d_name , cname ); 
2177
2178                    // increment dirent_id
2179                    dirent_id++;
2180                }
2181                offset = offset + 32;
2182                lfn    = 0;
2183            }
2184        }  // end loop on directory entries in page
2185
2186        page_id++;
2187        offset = 0;
2188
2189    }  // end loop on pages
2190
2191    // return result of scan
2192    *done    = end;
2193    *entries = dirent_id;
2194
2195#if DEBUG_FATFS_GET_USER_DIR
2196cycle = (uint32_t)hal_get_cycles();
2197if( DEBUG_FATFS_GET_USER_DIR < cycle )
2198printk("\n[%s]  thread[%x,%x] exit for inode <%s> / %d entries / cycle %d\n",
2199__FUNCTION__, this->process->pid, this->trdid, inode_name, dirent_id, cycle );
2200#endif
2201
2202    return 0;
2203
2204}  // end fatfs_get_user_dir()
2205
2206///////////////////////////////////////////////
2207error_t fatfs_sync_inode( vfs_inode_t * inode )
2208{
2209
2210// check inode pointer and cluster index
2211assert( (inode != NULL)                  , "inode pointer undefined\n" );
2212assert( (inode->mapper != NULL )         , "mapper pointer undefined\n" );
2213assert( (inode->type == INODE_TYPE_FILE) , "inode must be a file\n" );     
2214
2215#if DEBUG_FATFS_SYNC_INODE
2216char       name[CONFIG_VFS_MAX_NAME_LENGTH];
2217uint32_t   cycle = (uint32_t)hal_get_cycles();
2218thread_t * this  = CURRENT_THREAD;
2219vfs_inode_get_name( XPTR( local_cxy , inode ) , name );
2220if( DEBUG_FATFS_SYNC_INODE < cycle )
2221printk("\n[%s] thread[%x,%x] enter for <%s> / cycle %d\n",
2222__FUNCTION__ , this->process->pid, this->trdid, name, cycle );
2223#endif
2224
2225    error_t    error;
2226    mapper_t * mapper;
2227    page_t   * page;
2228    uint32_t   page_id;
2229
2230    // get mapper from inode
2231    mapper = inode->mapper;
2232
2233    // compute max number of pages in mapper from file size
2234    uint32_t size  = inode->size;
2235    uint32_t pages = size >> CONFIG_PPM_PAGE_SHIFT;
2236    if( size & CONFIG_PPM_PAGE_MASK ) pages++; 
2237         
2238    // get pointer on mapper radix tree
2239    grdxt_t * rt = &mapper->rt;
2240
2241    // scan all pages
2242    for( page_id = 0 ; page_id < pages ; page_id++ )
2243    {
2244        // get page descriptor from mapper
2245        page = grdxt_lookup( rt , page_id );
2246
2247        // check all existing pages
2248        if ( page != NULL )
2249        {
2250            if ( page->flags & PG_DIRTY )
2251            {
2252
2253#if (DEBUG_FATFS_SYNC_INODE & 1)
2254if( DEBUG_FATFS_SYNC_INODE < cycle )
2255printk("\n[%s] thread[%x,%x] synchronizes page %d from <%s> mapper to IOC device\n",
2256__FUNCTION__, page_id, name );
2257#endif
2258                // build extended pointer on page descriptor
2259                xptr_t page_xp = XPTR( local_cxy , page );
2260
2261                // move page from mapper to device
2262                error = fatfs_move_page( page_xp , IOC_WRITE );
2263
2264                if ( error )  return -1;
2265
2266                // reset page dirty flag
2267                ppm_page_undo_dirty( page_xp );
2268            }
2269        }
2270    }  // end loop on pages
2271
2272#if DEBUG_FATFS_SYNC_INODE
2273cycle = (uint32_t)hal_get_cycles();
2274if( DEBUG_FATFS_SYNC_INODE < cycle )
2275printk("\n[%s] thread[%x,%x] exit for <%s> / cycle %d\n",
2276__FUNCTION__ , this->process->pid, this->trdid, name, cycle );
2277#endif
2278
2279    return 0;
2280
2281}  // end fatfs_sync_inode()
2282
2283
2284
2285
2286
2287
2288//////////////////////////////
2289error_t fatfs_sync_fat( void )
2290{
2291
2292#if DEBUG_FATFS_SYNC_FAT
2293uint32_t   cycle = (uint32_t)hal_get_cycles();
2294thread_t * this  = CURRENT_THREAD;
2295if( DEBUG_FATFS_SYNC_FAT < cycle )
2296printk("\n[%s] thread[%x,%x] enter / cycle %d\n",
2297__FUNCTION__ , this->process->pid, this->trdid, cycle );
2298#endif
2299
2300    uint32_t   page_id;
2301    error_t    error;
2302
2303    // get FAT mapper pointers an cluster
2304    fatfs_ctx_t * fatfs_ctx  = fs_context[FS_TYPE_FATFS].extend;
2305    xptr_t        mapper_xp  = fatfs_ctx->fat_mapper_xp;
2306    cxy_t         mapper_cxy = GET_CXY( mapper_xp );
2307    mapper_t    * mapper_ptr = GET_PTR( mapper_xp );
2308
2309    // compute max number of 4 Kbytes pages in FAT mapper
2310    // TODO : this could be improved (see fatfs.h) [AG]
2311    uint32_t   pages = fatfs_ctx->fat_sectors_count >> 3;
2312         
2313    // get pointers on remote FAT mapper radix tree
2314    grdxt_t  * rt_ptr = &mapper_ptr->rt;
2315    xptr_t     rt_xp  = XPTR( mapper_cxy , rt_ptr );
2316
2317    // scan all pages
2318    for( page_id = 0 ; page_id < pages ; page_id++ )
2319    {
2320        // get extended pointer on page descriptor from FAT mapper
2321        xptr_t page_xp = grdxt_remote_lookup( rt_xp , page_id );
2322
2323        // check all existing pages
2324        if ( page_xp != XPTR_NULL )
2325        {
2326            page_t * page_ptr = GET_PTR( page_xp );
2327            uint32_t flags    = hal_remote_l32( XPTR( mapper_cxy , &page_ptr->flags ) );
2328
2329            if ( flags & PG_DIRTY )
2330            {
2331
2332#if (DEBUG_FATFS_SYNC_FAT & 1)
2333if( DEBUG_FATFS_SYNC_FAT < cycle )
2334printk("\n[%s] thread[%x,%x] synchronizes page %d from FAT mapper to IOC device\n",
2335__FUNCTION__, page_id );
2336#endif
2337                // move page from mapper to device
2338                error = fatfs_move_page( page_xp , IOC_SYNC_WRITE );
2339
2340                if ( error )  return -1;
2341
2342                // reset page dirty flag
2343                ppm_page_undo_dirty( page_xp );
2344            }
2345        }
2346    }  // end loop on pages
2347
2348#if DEBUG_FATFS_SYNC_FAT
2349cycle = (uint32_t)hal_get_cycles();
2350if( DEBUG_FATFS_SYNC_FAT < cycle )
2351printk("\n[%s] thread[%x,%x] exit / cycle %d\n",
2352__FUNCTION__ , this->process->pid, this->trdid, cycle );
2353#endif
2354
2355    return 0;
2356
2357}  // end fatfs_sync_fat()
2358
2359////////////////////////////////////
2360error_t fatfs_sync_free_info( void )
2361{
2362    error_t       error;
2363    fatfs_ctx_t * fatfs_ctx_ptr;              // local pointer on fatfs context in cluster 0
2364    uint32_t      ctx_free_clusters;          // number of free clusters from fatfs context
2365    uint32_t      ctx_free_cluster_hint;      // free cluster hint from fatfs context
2366    uint32_t      ioc_free_clusters;          // number of free clusters from fatfs context
2367    uint32_t      ioc_free_cluster_hint;      // free cluster hint from fatfs context
2368    uint32_t      fs_info_lba;                // lba of FS_INFO sector on IOC device
2369    uint8_t     * fs_info_buffer;             // local pointer on FS_INFO buffer in cluster 0
2370    xptr_t        fs_info_buffer_xp;          // extended pointer on FS_INFO buffer in cluster 0
2371    uint8_t       tmp_buf[512];               // 512 bytes temporary buffer
2372    xptr_t        tmp_buf_xp;                 // extended pointer on temporary buffer
2373
2374#if DEBUG_FATFS_SYNC_FSINFO
2375uint32_t   cycle = (uint32_t)hal_get_cycles();
2376thread_t * this  = CURRENT_THREAD;
2377if( DEBUG_FATFS_SYNC_FSINFO < cycle )
2378printk("\n[%s] thread[%x,%x] enter / cycle %d\n",
2379__FUNCTION__ , this->process->pid, this->trdid, cycle );
2380#endif
2381
2382    // get pointer on fatfs context in cluster 0
2383    fatfs_ctx_ptr = hal_remote_lpt( XPTR( 0 , &fs_context[FS_TYPE_FATFS].extend ) );
2384
2385    // get "free_clusters" and "free_cluster_hint" from fatfs context in cluster 0
2386    ctx_free_clusters     = hal_remote_l32( XPTR( 0 , &fatfs_ctx_ptr->free_clusters ) );
2387    ctx_free_cluster_hint = hal_remote_l32( XPTR( 0 , &fatfs_ctx_ptr->free_cluster_hint ) );
2388
2389    // get fs_info_lba
2390    fs_info_lba = hal_remote_l32( XPTR( 0 , &fatfs_ctx_ptr->fs_info_lba ) );
2391
2392    // build extended pointer on temporary buffer
2393    tmp_buf_xp = XPTR( local_cxy , tmp_buf );
2394
2395    // copy FS_INFO sector from IOC to local buffer
2396    error = dev_ioc_sync_read( tmp_buf_xp , fs_info_lba , 1 );
2397
2398    if ( error )
2399    {
2400        printk("\n[ERROR] in %s : cannot access FS_INFO on IOC device\n", __FUNCTION__ );
2401        return -1;
2402    }
2403
2404    // get current values of "free_clusters" and "free_cluster_hint" from FS_INFO on IOC
2405    ioc_free_clusters     = fatfs_get_remote_record( FS_FREE_CLUSTERS     , tmp_buf_xp );
2406    ioc_free_cluster_hint = fatfs_get_remote_record( FS_FREE_CLUSTER_HINT , tmp_buf_xp );
2407
2408#if DEBUG_FATFS_SYNC_FSINFO
2409if( DEBUG_FATFS_SYNC_FSINFO < cycle )
2410printk("\n[%s] thread[%x,%x] / ctx_free %x / ioc_free %x / ctx_hint %x / ioc_hint %x\n",
2411__FUNCTION__ , this->process->pid, this->trdid, 
2412ctx_free_clusters, ioc_free_clusters, ctx_free_cluster_hint, ioc_free_cluster_hint );
2413#endif
2414
2415    // check values
2416    if( (ioc_free_clusters     != ctx_free_clusters) || 
2417        (ioc_free_cluster_hint != ctx_free_cluster_hint) )
2418    {
2419        printk("\n[WARNING] in %s : unconsistent free clusters info\n"
2420        " ioc_free %x / ctx_free %x / ioc_hint %x / ctx_hint %x\n",
2421        __FUNCTION__, ioc_free_clusters, ctx_free_clusters,
2422        ioc_free_cluster_hint, ctx_free_cluster_hint );
2423
2424        // get pointers on FS_INFO buffer in cluster 0
2425        fs_info_buffer    = hal_remote_lpt( XPTR( 0 , &fatfs_ctx_ptr->fs_info_buffer ) );
2426        fs_info_buffer_xp = XPTR( 0 , fs_info_buffer );
2427
2428        // update FS_INFO buffer in cluster 0
2429        fatfs_set_remote_record(FS_FREE_CLUSTERS    ,fs_info_buffer_xp,ctx_free_clusters );
2430        fatfs_set_remote_record(FS_FREE_CLUSTER_HINT,fs_info_buffer_xp,ctx_free_cluster_hint);
2431
2432        // update the FS_INFO sector on IOC device
2433        error = dev_ioc_sync_write( fs_info_buffer_xp , fs_info_lba , 1 );
2434
2435        if ( error )
2436        {
2437            printk("\n[ERROR] in %s : cannot update FS_INFO on IOC device\n", __FUNCTION__ );
2438            return -1;
2439        }
2440    }
2441
2442#if DEBUG_FATFS_SYNC_FSINFO
2443cycle = (uint32_t)hal_get_cycles();
2444if( DEBUG_FATFS_SYNC_FSINFO < cycle )
2445printk("\n[%s] thread[%x,%x] exit / cycle %d\n",
2446__FUNCTION__ , this->process->pid, this->trdid, cycle );
2447#endif
2448
2449    return 0;
2450
2451}  // end fatfs_sync_free_info()
2452
2453//////////////////////////////////////////////////////////
2454error_t fatfs_cluster_alloc( uint32_t * searched_cluster )
2455{
2456    error_t       error;
2457    uint32_t      page_id;        // page index in FAT mapper
2458    uint32_t      slot_id;        // slot index in page (1024 slots per page)
2459    uint32_t      cluster;        // first free cluster index in FAT
2460    uint32_t      free_clusters;  // total number of free clusters
2461    vfs_ctx_t   * vfs_ctx;        // local pointer on VFS context (same in all clusters)
2462    fatfs_ctx_t * loc_fatfs_ctx;  // local pointer on local FATFS context
2463    fatfs_ctx_t * fat_fatfs_ctx;  // local pointer on FATFS context in FAT cluster
2464    xptr_t        fat_mapper_xp;  // extended pointer on FAT mapper
2465    cxy_t         fat_cxy;        // Fat mapper cluster identifier
2466    xptr_t        page_xp;        // extended pointer on current page descriptor in mapper
2467    xptr_t        slot_xp;        // extended pointer on FAT slot defined by hint
2468    xptr_t        lock_xp;        // extended pointer on lock protecting free clusters info
2469    xptr_t        hint_xp;        // extended pointer on free_cluster_hint in FAT cluster
2470    xptr_t        free_xp;        // extended pointer on free_clusters_number in FAT cluster
2471
2472#if DEBUG_FATFS_CLUSTER_ALLOC
2473uint32_t   cycle = (uint32_t)hal_get_cycles();
2474thread_t * this  = CURRENT_THREAD;
2475if( DEBUG_FATFS_CLUSTER_ALLOC < cycle )
2476printk("\n[%s] thread[%x,%x] enter / cycle = %d\n",
2477__FUNCTION__, this->process->pid, this->trdid, cycle );
2478#endif
2479
2480    // get local pointer on VFS context (same in all clusters)
2481    vfs_ctx = &fs_context[FS_TYPE_FATFS];
2482
2483    // get local pointer on local FATFS context
2484    loc_fatfs_ctx = vfs_ctx->extend;
2485
2486    // get extended pointer on FAT mapper
2487    fat_mapper_xp  = loc_fatfs_ctx->fat_mapper_xp;
2488
2489    // get FAT cluster
2490    fat_cxy = GET_CXY( fat_mapper_xp );
2491   
2492    // get local pointer on FATFS context in FAT cluster
2493    fat_fatfs_ctx = hal_remote_lpt( XPTR( fat_cxy , &vfs_ctx->extend ) );
2494
2495    // build relevant extended pointers on free clusters info in mapper cluster
2496    lock_xp = XPTR( fat_cxy , &fat_fatfs_ctx->lock );
2497    hint_xp = XPTR( fat_cxy , &fat_fatfs_ctx->free_cluster_hint );
2498    free_xp = XPTR( fat_cxy , &fat_fatfs_ctx->free_clusters );
2499
2500    // take the FAT lock in write mode
2501    remote_rwlock_wr_acquire( lock_xp );
2502
2503    // get hint and free_clusters values from FATFS context in FAT cluster
2504    cluster       = hal_remote_l32( hint_xp ) + 1;
2505    free_clusters = hal_remote_l32( free_xp );
2506       
2507#if (DEBUG_FATFS_CLUSTER_ALLOC & 1)
2508if( DEBUG_FATFS_CLUSTER_ALLOC < cycle )
2509printk("\n[%s] thread[%x,%x] get free info : hint %x / free_clusters %x\n",
2510__FUNCTION__, this->process->pid, this->trdid, (cluster - 1), free_clusters );
2511#endif
2512
2513    // check "free_clusters"
2514    if ( free_clusters == 0 )
2515    {
2516        printk("\n[ERROR] in %s : no more free FATFS clusters\n", __FUNCTION__ );
2517        remote_rwlock_wr_release( lock_xp );
2518        return -1;
2519    }
2520    else if ( free_clusters < CONFIG_VFS_FREE_CLUSTERS_MIN )
2521    {
2522        printk("\n[WARNING] in %s : only %n free FATFS clusters\n", 
2523        __FUNCTION__, CONFIG_VFS_FREE_CLUSTERS_MIN );
2524    }
2525
2526    // get page index & slot index for selected cluster
2527    page_id  = cluster >> 10;
2528    slot_id  = cluster & 0x3FF;
2529
2530    // get relevant page descriptor from FAT mapper
2531    page_xp = mapper_remote_get_page( fat_mapper_xp , page_id );
2532
2533    if( page_xp == XPTR_NULL )
2534    {
2535        printk("\n[ERROR] in %s : cannot acces FAT mapper\n", __FUNCTION__ );
2536        remote_rwlock_wr_release( lock_xp );
2537        return -1;
2538    }
2539
2540    // build extended pointer on selected cluster slot in FAT mapper
2541    slot_xp = ppm_page2base( page_xp ) + (slot_id << 2);
2542         
2543    // check selected cluster actually free
2544    if( hal_remote_l32( slot_xp ) != FREE_CLUSTER )
2545    { 
2546        printk("\n[ERROR] in %s : selected cluster %x not free\n", __FUNCTION__, cluster );
2547        remote_rwlock_wr_release( lock_xp );
2548        return -1;
2549    }
2550
2551    // update free cluster info in FATFS context and in FS_INFO sector
2552    error = fatfs_free_clusters_decrement( XPTR( fat_cxy , fat_fatfs_ctx ) , cluster );
2553
2554    if( error )
2555    { 
2556        printk("\n[ERROR] in %s : cannot update free cluster info\n", __FUNCTION__ );
2557        remote_rwlock_wr_release( lock_xp );
2558        return -1;
2559    }
2560
2561    // update FAT mapper
2562    hal_remote_s32( slot_xp , END_OF_CHAIN_CLUSTER_MAX );
2563
2564    // we don't mark the FAT mapper page as dirty,
2565    // because we synchronously update FAT on IOC device
2566    error = fatfs_move_page( page_xp , IOC_SYNC_WRITE );
2567
2568    if( error )
2569    { 
2570        printk("\n[ERROR] in %s : cannot update FAT on IOC device\n", __FUNCTION__ );
2571        remote_rwlock_wr_release( lock_xp );
2572        return -1;
2573    }
2574
2575    // release FAT lock
2576    remote_rwlock_wr_release( lock_xp );
2577
2578#if DEBUG_FATFS_CLUSTER_ALLOC
2579cycle = (uint32_t)hal_get_cycles();
2580if( DEBUG_FATFS_CLUSTER_ALLOC < cycle )
2581printk("\n[%s] thread[%x,%x] exit / allocated cluster %x in FAT / cycle %d\n",
2582__FUNCTION__, this->process->pid, this->trdid, cluster, cycle );
2583#endif
2584
2585    *searched_cluster = cluster;
2586    return 0;
2587
2588}  // end fat_cluster_alloc()
2589
2590//////////////////////////////////////////////
2591error_t fatfs_release_inode( xptr_t inode_xp )
2592{
2593    vfs_ctx_t   * vfs_ctx;        // local pointer on VFS context (same in all clusters).
2594    fatfs_ctx_t * loc_fatfs_ctx;  // local pointer on local FATFS context
2595    cxy_t         fat_cxy;        // FAT cluster identifier
2596    xptr_t        fatfs_ctx_xp;   // extended pointer on FATFS context in FAT cluster
2597    fatfs_ctx_t * fatfs_ctx_ptr;  // local pointer on FATFS context in FAT cluster
2598    xptr_t        fat_mapper_xp;  // extended pointer on FAT mapper
2599    xptr_t        lock_xp;        // extended pointer on lock protecting FAT.
2600    xptr_t        first_xp;       // extended pointer on inode extension
2601    uint32_t      first_cluster;  // first cluster index for released inode
2602    vfs_inode_t * inode_ptr;      // local pointer on target inode
2603    cxy_t         inode_cxy;      // target inode cluster identifier
2604    error_t       error;
2605
2606// check inode pointer
2607assert( (inode_xp != XPTR_NULL) , "inode pointer is NULL\n" );
2608
2609    // get inode cluster and local pointer
2610    inode_ptr     = GET_PTR( inode_xp );
2611    inode_cxy     = GET_CXY( inode_xp );
2612
2613    // get first_cluster from inode extension
2614    first_xp      = XPTR( inode_cxy , &inode_ptr->extend );
2615    first_cluster = (uint32_t)(intptr_t)hal_remote_lpt( first_xp );
2616
2617// check first cluster index
2618assert( (first_cluster != 0) , "inode extend is NULL\n" );
2619
2620#if DEBUG_FATFS_RELEASE_INODE
2621char       name[CONFIG_VFS_MAX_NAME_LENGTH];
2622uint32_t   cycle = (uint32_t)hal_get_cycles();
2623thread_t * this  = CURRENT_THREAD;
2624vfs_inode_get_name( inode_xp , name );
2625if( DEBUG_FATFS_RELEASE_INODE < cycle )
2626printk("\n[%s] thread[%x,%x] enter for <%s> / first_cluster %x / cycle %d\n",
2627__FUNCTION__ , this->process->pid, this->trdid, name, first_cluster, cycle );
2628#endif
2629
2630    // get local pointer on VFS context (same in all clusters)
2631    vfs_ctx = &fs_context[FS_TYPE_FATFS];
2632
2633    // get local pointer on local FATFS context
2634    loc_fatfs_ctx = vfs_ctx->extend;
2635
2636    // get FAT mapper cluster
2637    fat_mapper_xp  = loc_fatfs_ctx->fat_mapper_xp;
2638    fat_cxy        = GET_CXY( fat_mapper_xp );
2639   
2640    // get pointers on FATFS context in FAT cluster
2641    fatfs_ctx_ptr  = hal_remote_lpt( XPTR( fat_cxy , &vfs_ctx->extend ) );
2642    fatfs_ctx_xp   = XPTR( fat_cxy , fatfs_ctx_ptr );
2643
2644    // get extended pointer on FAT lock in FAT cluster
2645    lock_xp = XPTR( fat_cxy , &fatfs_ctx_ptr->lock );
2646
2647    // take FAT lock in write mode
2648    remote_rwlock_wr_acquire( lock_xp );
2649
2650#if (DEBUG_FATFS_RELEASE_INODE & 0x11 == 0x11)
2651mapper_display_page( fat_mapper_xp , 0 , 4096 );
2652#endif
2653
2654    // call the recursive function to release all clusters from FAT mapper
2655    uint32_t dirty_page_min = 0xFFFFFFFF;
2656    uint32_t dirty_page_max = 0;
2657
2658    if ( fatfs_recursive_release( fat_mapper_xp,
2659                                  fatfs_ctx_xp,
2660                                  first_cluster,
2661                                  &dirty_page_min,
2662                                  &dirty_page_max ) )
2663    {
2664        printk("\n[ERROR] in %s : cannot update FAT mapper\n", __FUNCTION__ );
2665        remote_rwlock_wr_release( lock_xp );
2666        return -1;
2667    }
2668
2669#if (DEBUG_FATFS_RELEASE_INODE & 1)
2670if( DEBUG_FATFS_RELEASE_INODE < cycle )
2671printk("\n[%s] inode <%s> removed from FAT mapper\n", __FUNCTION__, name );
2672#endif
2673
2674#if (DEBUG_FATFS_RELEASE_INODE & 0x11 == 0x11)
2675mapper_display_page( fat_mapper_xp , 0 , 4096 );
2676#endif
2677
2678    // update FAT on IOC device (from FAT mapper)
2679    error = fatfs_update_ioc_fat( fatfs_ctx_xp,
2680                                  dirty_page_min,
2681                                  dirty_page_max );
2682
2683    if( error )
2684    {
2685        printk("\n[ERROR] in %s : cannot update FAT on IOC device\n", __FUNCTION__ );
2686        remote_rwlock_wr_release( lock_xp );
2687        return -1;
2688    }
2689
2690#if (DEBUG_FATFS_RELEASE_INODE & 1)
2691if( DEBUG_FATFS_RELEASE_INODE < cycle )
2692printk("\n[%s] inode <%s> removed from FAT on IOC device\n", __FUNCTION__, name );
2693#endif
2694
2695    // update FS-INFO on IOC device (from FATFS context)
2696    error = fatfs_update_ioc_fsinfo( fatfs_ctx_xp );
2697
2698    if( error )
2699    {
2700        printk("\n[ERROR] in %s: cannot update FSINFO on IOC device\n", __FUNCTION__ );
2701        remote_rwlock_wr_release( lock_xp );
2702        return -1;
2703    }
2704
2705#if (DEBUG_FATFS_RELEASE_INODE & 1)
2706if( DEBUG_FATFS_RELEASE_INODE < cycle )
2707printk("\n[%s] updated FS_INFO on IOC device for >%s>\n", __FUNCTION__, name );
2708#endif
2709
2710    // release FAT lock
2711    remote_rwlock_wr_release( lock_xp );
2712
2713#if DEBUG_FATFS_RELEASE_INODE
2714cycle = (uint32_t)hal_get_cycles();
2715if( DEBUG_FATFS_RELEASE_INODE < cycle )
2716printk("\n[%s] thread[%x,%x] removed <%s> inode from FATFS / cycle %d\n",
2717__FUNCTION__ , this->process->pid, this->trdid, name, cycle );
2718#endif
2719
2720    return 0;
2721
2722}  // end fatfs_release_inode()
2723
2724////////////////////////////////////////////
2725error_t fatfs_move_page( xptr_t     page_xp,
2726                         cmd_type_t cmd_type )
2727{
2728    error_t       error;
2729    vfs_inode_t * inode_ptr;
2730    mapper_t    * mapper_ptr;     
2731    uint32_t      page_id;     // page index in mapper
2732
2733#if DEBUG_FATFS_MOVE_PAGE
2734uint32_t   cycle = (uint32_t)hal_get_cycles();
2735thread_t * this  = CURRENT_THREAD;
2736char       name[CONFIG_VFS_MAX_NAME_LENGTH];
2737#endif
2738
2739    // get page cluster an local pointer
2740    cxy_t    page_cxy = GET_CXY( page_xp );
2741    page_t * page_ptr = GET_PTR( page_xp );
2742
2743    // get mapper pointer and page index from page descriptor
2744    mapper_ptr = hal_remote_lpt( XPTR( page_cxy , &page_ptr->mapper ) );
2745    page_id    = hal_remote_l32( XPTR( page_cxy , &page_ptr->index ) );
2746
2747    // get pointer on local FATFS context
2748    fatfs_ctx_t * fatfs_ctx = fs_context[FS_TYPE_FATFS].extend;
2749
2750    // get page base address
2751    xptr_t    buffer_xp  = ppm_page2base( page_xp );
2752    uint8_t * buffer_ptr = (uint8_t *)GET_PTR( buffer_xp );
2753 
2754    // get inode pointer from mapper
2755    inode_ptr  = hal_remote_lpt( XPTR( page_cxy , &mapper_ptr->inode ) );
2756
2757#if DEBUG_FATFS_MOVE_PAGE
2758if( DEBUG_FATFS_MOVE_PAGE < cycle )
2759printk("\n[%s] thread[%x,%x] enters : %s / cxy %x / mapper %x / inode %x / page %x\n",
2760__FUNCTION__, this->process->pid, this->trdid,
2761dev_ioc_cmd_str( cmd_type ), page_cxy, mapper_ptr, inode_ptr, buffer_ptr );
2762#endif
2763
2764    //////////////////////////////  FAT mapper
2765    if( inode_ptr == NULL )
2766    {
2767        // get lba from FATFS context and page_id
2768        uint32_t      lba = fatfs_ctx->fat_begin_lba + (page_id << 3);
2769 
2770        // access device
2771        if     (cmd_type == IOC_SYNC_READ ) error = dev_ioc_sync_read ( buffer_xp  , lba , 8 );
2772        else if(cmd_type == IOC_SYNC_WRITE) error = dev_ioc_sync_write( buffer_xp  , lba , 8 );
2773        else if(cmd_type == IOC_READ      ) error = dev_ioc_read      ( buffer_ptr , lba , 8 );
2774        else if(cmd_type == IOC_WRITE     ) error = dev_ioc_write     ( buffer_ptr , lba , 8 );
2775        else                                error = -1;
2776
2777        if( error )
2778        {
2779            printk("\n[ERROR] in %s : cannot access device\n", __FUNCTION__ );
2780            return -1;
2781        }
2782
2783#if DEBUG_FATFS_MOVE_PAGE
2784if( DEBUG_FATFS_MOVE_PAGE < cycle )
2785{
2786    if ( (cmd_type == IOC_READ) || (cmd_type == IOC_SYNC_READ) )
2787        printk("\n[%s] thread[%x,%x] load FAT mapper page %d from IOC / cycle %d\n",
2788        __FUNCTION__, this->process->pid, this->trdid, page_id, cycle );
2789    else
2790        printk("\n[%s] thread[%x,%x] sync FAT mapper page %d to IOC / cycle %d\n",
2791        __FUNCTION__, this->process->pid, this->trdid, page_id, cycle );
2792}
2793#endif
2794
2795    }
2796    /////////////////////////  inode mapper
2797    else                       
2798    {
2799
2800#if DEBUG_FATFS_MOVE_PAGE
2801vfs_inode_get_name( XPTR( page_cxy , inode_ptr ) , name );
2802#endif
2803
2804        uint32_t  searched_cluster;
2805        uint32_t  first_cluster;
2806
2807        // get first_cluster from inode extension
2808        void * extend = hal_remote_lpt( XPTR( page_cxy , &inode_ptr->extend ) );
2809        first_cluster = (uint32_t)(intptr_t)extend;
2810
2811        // compute searched_cluster
2812        if( page_id == 0 )            // no need to access FAT mapper
2813        {
2814            // searched cluster is first cluster
2815            searched_cluster = first_cluster;
2816        }
2817        else                        // FAT mapper access required
2818        {
2819            // access FAT mapper to get searched cluster
2820            error = fatfs_get_cluster( first_cluster,
2821                                       page_id,
2822                                       &searched_cluster );
2823            if( error )
2824            {
2825                printk("\n[ERROR] in %s : cannot access FAT mapper\n", __FUNCTION__ );
2826                return -1;
2827            }
2828        }
2829
2830        // get lba for searched_cluster
2831        uint32_t lba = fatfs_lba_from_cluster( fatfs_ctx , searched_cluster );
2832
2833        // access device
2834        if     (cmd_type == IOC_SYNC_READ ) error = dev_ioc_sync_read ( buffer_xp  , lba , 8 );
2835        else if(cmd_type == IOC_SYNC_WRITE) error = dev_ioc_sync_write( buffer_xp  , lba , 8 );
2836        else if(cmd_type == IOC_READ      ) error = dev_ioc_read      ( buffer_ptr , lba , 8 );
2837        else if(cmd_type == IOC_WRITE     ) error = dev_ioc_write     ( buffer_ptr , lba , 8 );
2838        else                                error = -1;
2839
2840        if( error )
2841        {
2842            printk("\n[ERROR] in %s : cannot access device\n", __FUNCTION__ );
2843            return -1;
2844        }
2845
2846#if DEBUG_FATFS_MOVE_PAGE
2847if( DEBUG_FATFS_MOVE_PAGE < cycle )
2848{
2849    if ( (cmd_type == IOC_READ) || (cmd_type == IOC_SYNC_READ) )
2850    printk("\n[%s] thread[%x,%x] load page %d of <%s> / cluster_id %x / cycle %d\n",
2851    __FUNCTION__, this->process->pid, this->trdid, page_id, name, searched_cluster, cycle );
2852    else
2853    printk("\n[%s] thread[%x,%x] sync page %d of <%s> / cluster_id %x / cycle %d\n",
2854    __FUNCTION__, this->process->pid, this->trdid, page_id, name, searched_cluster, cycle );
2855}
2856#endif
2857
2858    }
2859
2860    return 0;
2861
2862}  // end fatfs_move_page()
2863
2864
Note: See TracBrowser for help on using the repository browser.