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

Last change on this file since 459 was 457, checked in by alain, 6 years ago

This version modifies the exec syscall and fixes a large number of small bugs.
The version number has been updated (0.1)

File size: 27.6 KB
RevLine 
[1]1/*
2 * fatfs.c - FATFS file system API implementation.
3 *
[238]4 * Author    Alain Greiner (2016,2017)
[1]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
[457]25#include <hal_kernel_types.h>
[1]26#include <hal_special.h>
27#include <printk.h>
[401]28#include <thread.h>
[1]29#include <kmem.h>
30#include <ppm.h>
31#include <vfs.h>
[238]32#include <string.h>
[1]33#include <rpc.h>
34#include <mapper.h>
[23]35#include <cluster.h>
[1]36#include <dev_ioc.h>
37#include <fatfs.h>
38
[50]39
[23]40//////////////////////////////////////////////////////////////////////////////////////////
41//          Extern  variables         
42//////////////////////////////////////////////////////////////////////////////////////////
[1]43
[50]44extern vfs_ctx_t          fs_context[FS_TYPES_NR];   // allocated in vfs.c file
[23]45
[50]46extern remote_barrier_t   global_barrier;            // allocated in kernel_init.c
[23]47 
[1]48//////////////////////////////////////////////////////////////////////////////////////////
[265]49//              FATFS specific and static functions
[1]50//////////////////////////////////////////////////////////////////////////////////////////
51
[188]52//////////////////////////////////////////////////////////////////////////////////////////
[238]53// These functions return the "offset" and "length" values of an
54// [offset,length] constant defined in the fatfs.h file.
55//////////////////////////////////////////////////////////////////////////////////////////
56
57static inline int get_length( int offset , int length ) { return length; }
58
59static inline int get_offset( int offset , int length ) { return offset; }
60
61
62//////////////////////////////////////////////////////////////////////////////////////////
[440]63// This static function returns the LBA of the first sector of a FAT cluster.
[188]64// This function can be called by any thread running in any cluster.
65//////////////////////////////////////////////////////////////////////////////////////////
66// @ ctx          :     pointer on FATFS context.
67// @ cluster  : cluster index in FATFS.
68// @ return the lba value.
69//////////////////////////////////////////////////////////////////////////////////////////
70static inline uint32_t fatfs_lba_from_cluster( fatfs_ctx_t * ctx,
71                                               uint32_t      cluster )
[1]72{
[23]73    return (ctx->cluster_begin_lba + ((cluster - 2) << 3));
[1]74}
75
[246]76//////////////////////////////////////////////////////////////////////////////////////////
[238]77// This function return an integer record value (one, two, or four bytes)
[23]78// from a memory buffer, taking into account endianness.
[238]79//////////////////////////////////////////////////////////////////////////////////////////
[23]80// @ offset        : first byte of record in buffer.
81// @ size          : record length in bytes (1/2/4).
82// @ buffer        : pointer on buffer base.
83// @ little endian : the most significant byte has the highest address when true.
84// @ return the integer value in a 32 bits word.
[238]85//////////////////////////////////////////////////////////////////////////////////////////
86static uint32_t fatfs_get_record( uint32_t    offset,
87                                  uint32_t    size,
88                                  uint8_t   * buffer,
89                                  uint32_t    little_endian )
[23]90{
91    uint32_t n;
92    uint32_t res  = 0;
[1]93
[23]94    if ( little_endian)
95    {
96        for( n = size ; n > 0 ; n-- ) res = (res<<8) | buffer[offset+n-1];
97    }
98    else
99    {
100        for( n = 0 ; n < size ; n++ ) res = (res<<8) | buffer[offset+n];
101    }
102    return res;
103
[238]104}  // end fatfs_get_record()
[23]105
[238]106//////////////////////////////////////////////////////////////////////////////////////////
107// This static function retun in the <name> buffer a short name stored in
108// a SFN FATFS directory entry.
109/////////////////////////i////////////////////////////////////////////////////////////////
110// @ buffer   : pointer on buffer containing the directory entry.
111// @ name     : [out] buffer allocated by the caller.
112//////////////////////////////////////////////////////////////////////////////////////////
113static void fatfs_get_name_from_short( uint8_t * buffer,
114                                       char    * name )
115{
116    uint32_t i;
117    uint32_t j = 0;
[23]118
[238]119    // get name
120    for ( i = 0; i < 8 && buffer[i] != ' '; i++ )
121    {
122        name[j] = to_lower( buffer[i] );
123        j++;
124    }
[23]125
[238]126    // get extension
127    for ( i = 8; i < 8 + 3 && buffer[i] != ' '; i++ )
128    {
129        // we entered the loop so there is an extension. add the dot
130        if ( i == 8 )
131        {
132            name[j] = '.';
133            j++;
134        }
135
136        name[j] = to_lower( buffer[i] );
137        j++;
138    }
139
140    name[j] = '\0';
141}
142
143//////////////////////////////////////////////////////////////////////////////////////////
144// This static function retun in the <name> buffer a partial name stored in
145// a LFN FATFS directory entry.
146/////////////////////////i////////////////////////////////////////////////////////////////
147// @ buffer   : pointer on buffer containing the directory entry.
148// @ name     : [out] buffer allocated by the caller.
149//////////////////////////////////////////////////////////////////////////////////////////
150static void fatfs_get_name_from_long( uint8_t * buffer,
151                                      char    * name )
152{
153    uint32_t   name_offset   = 0;
154    uint32_t   buffer_offset = get_length(LDIR_ORD);
155    uint32_t   l_name_1      = get_length(LDIR_NAME_1);
156    uint32_t   l_name_2      = get_length(LDIR_NAME_2);
157    uint32_t   l_name_3      = get_length(LDIR_NAME_3);
158    uint32_t   l_attr        = get_length(LDIR_ATTR);
159    uint32_t   l_type        = get_length(LDIR_TYPE);
160    uint32_t   l_chksum      = get_length(LDIR_CHKSUM);
161    uint32_t   l_rsvd        = get_length(LDIR_RSVD);
162
163    uint32_t   j             = 0;
164    uint32_t   eof           = 0;
165
166    while ( (buffer_offset != DIR_ENTRY_SIZE)  && (!eof) )
167    {
168        while (j != l_name_1 && !eof )
169        {
170            if ( (buffer[buffer_offset] == 0x00) || 
171                 (buffer[buffer_offset] == 0xFF) )
172            {
173                eof = 1;
174                continue;
175            }
176            name[name_offset] = buffer[buffer_offset];
177            buffer_offset += 2;
178            j += 2;
179            name_offset++;
180        }
181
182        buffer_offset += (l_attr + l_type + l_chksum);
183        j = 0;
184
185        while (j != l_name_2 && !eof )
186        {
187            if ( (buffer[buffer_offset] == 0x00) || 
188                 (buffer[buffer_offset] == 0xFF) )
189            {
190                eof = 1;
191                continue;
192            }
193            name[name_offset] = buffer[buffer_offset];
194            buffer_offset += 2;
195            j += 2;
196            name_offset++;
197        }
198
199        buffer_offset += l_rsvd;
200        j = 0;
201
202        while (j != l_name_3 && !eof )
203        {
204            if ( (buffer[buffer_offset] == 0x00) || 
205                 (buffer[buffer_offset] == 0xFF) )
206            {
207                eof = 1;
208                continue;
209            }
210            name[name_offset] = buffer[buffer_offset];
211            buffer_offset += 2;
212            j += 2;
213            name_offset++;
214        }
215    }
216    name[name_offset] = 0;
217
218} // end get_name_from_long()
219
[1]220
[238]221//////////////////////////////////////////////////////////////////////////////////////////
[265]222//              FATFS specific but extern functions
[238]223//////////////////////////////////////////////////////////////////////////////////////////
[1]224
[265]225//////////////////////////////////////////////////////////////////////////////////////////
226void fatfs_ctx_display()
227{
228    vfs_ctx_t   * vfs_ctx   = &fs_context[FS_TYPE_FATFS];
229    fatfs_ctx_t * fatfs_ctx = (fatfs_ctx_t *)vfs_ctx->extend;
230
231    printk("\n*** FAT context ***\n" 
232           "- fat_sectors      = %d\n"
233           "- sector size      = %d\n"
234           "- cluster size     = %d\n"
235           "- fat_first_lba    = %d\n"
236           "- data_first_lba   = %d\n"
237           "- root_dir_cluster = %d\n"
238           "- mapper_xp        = %l\n",
239           fatfs_ctx->fat_sectors_count,
240           fatfs_ctx->bytes_per_sector,
241           fatfs_ctx->sectors_per_cluster * fatfs_ctx->bytes_per_sector,
242           fatfs_ctx->fat_begin_lba,
243           fatfs_ctx->cluster_begin_lba,
244           fatfs_ctx->root_dir_cluster,
245           fatfs_ctx->fat_mapper_xp );
246}
247
[238]248/////////////////////////////////////////////
249error_t fatfs_get_cluster( mapper_t * mapper,
[265]250                           uint32_t   first_cluster_id,
[406]251                           uint32_t   searched_page_index,
[265]252                           uint32_t * searched_cluster_id )
[238]253{
254    page_t   * current_page_desc;      // pointer on current page descriptor
255    uint32_t * current_page_buffer;    // pointer on current page (array of uint32_t)
[406]256    uint32_t   current_page_index;     // index of current page in FAT
[238]257    uint32_t   current_page_offset;    // offset of slot in current page
258    uint32_t   page_count_in_file;     // index of page in file (index in linked list)
[406]259    uint32_t   next_cluster_id;        // content of current FAT slot
[1]260
[406]261    assert( (searched_page_index > 0) , __FUNCTION__ , 
262    "no FAT access required for first page\n");
[246]263
[438]264#if DEBUG_FATFS_GET_CLUSTER
[435]265uint32_t cycle = (uint32_t)hal_get_cycles();
[438]266if( DEBUG_FATFS_GET_CLUSTER < cycle )
[435]267printk("\n[DBG] %s : thread %x enter / first_cluster_id %d / searched_index / cycle %d\n",
268__FUNCTION__, CURRENT_THREAD, first_cluster_id, searched_page_index, cycle );
269#endif
[265]270
[406]271    // get number of FAT slots per page
[238]272    uint32_t slots_per_page = CONFIG_PPM_PAGE_SIZE >> 2;
[1]273
[238]274    // initialize loop variable
[265]275    current_page_index  = first_cluster_id / slots_per_page;
276    current_page_offset = first_cluster_id % slots_per_page;
[238]277    page_count_in_file  = 0;
[406]278    next_cluster_id     = 0xFFFFFFFF;
[238]279
280    // scan FAT (i.e. traverse FAT linked list)
[406]281    while( page_count_in_file < searched_page_index )
[238]282    {
283        // get pointer on current page descriptor
284        current_page_desc = mapper_get_page( mapper , current_page_index );
285
286        if( current_page_desc == NULL ) return EIO;
287
288        // get pointer on buffer for current page
[315]289        xptr_t base_xp = ppm_page2base( XPTR( local_cxy , current_page_desc ) );
290        current_page_buffer = (uint32_t *)GET_PTR( base_xp );
[238]291
292        // get FAT slot content
[406]293        next_cluster_id = current_page_buffer[current_page_offset];
[238]294
[438]295#if (DEBUG_FATFS_GET_CLUSTER & 1)
296if( DEBUG_FATFS_GET_CLUSTER < cycle )
[435]297printk("\n[DBG] %s : traverse FAT / current_page_index = %d\n"
[407]298"current_page_offset = %d / next_cluster_id = %d\n",
[435]299__FUNCTION__, current_page_index, current_page_offset , next_cluster_id );
300#endif
[406]301
[238]302        // update loop variables
[406]303        current_page_index  = next_cluster_id / slots_per_page;
304        current_page_offset = next_cluster_id % slots_per_page;
[238]305        page_count_in_file++;
306    }
[246]307
[406]308    if( next_cluster_id == 0xFFFFFFFF ) return EIO;
309   
[438]310#if DEBUG_FATFS_GET_CLUSTER
[435]311cycle = (uint32_t)hal_get_cycles();
[438]312if( DEBUG_FATFS_GET_CLUSTER < cycle )
[435]313printk("\n[DBG] %s : thread %x exit / searched_cluster_id = %d / cycle %d\n",
314__FUNCTION__, CURRENT_THREAD, next_cluster_id / cycle );
315#endif
[406]316
317    *searched_cluster_id = next_cluster_id;
[238]318    return 0;
319
320}  // end fatfs_get_cluster()
321
322
323
[1]324///////////////////////////////////////////////////////////////////////////////////////
[238]325// Generic API : the following functions are called by the kernel (VFS)
[188]326//               and must be defined by all supported file systems.
[1]327///////////////////////////////////////////////////////////////////////////////////////
328
[188]329///////////////////////////////
330fatfs_ctx_t * fatfs_ctx_alloc()
[1]331{
[23]332    kmem_req_t    req;
[188]333        req.type    = KMEM_FATFS_CTX;
334        req.size    = sizeof(fatfs_ctx_t);
335    req.flags   = AF_KERNEL | AF_ZERO;
[1]336
[188]337        return (fatfs_ctx_t *)kmem_alloc( &req );
338}
[23]339
[188]340//////////////////////////////////////////////
341void fatfs_ctx_init( fatfs_ctx_t * fatfs_ctx )
342{
343    error_t       error;
344    kmem_req_t    req;
345    uint8_t     * buffer;
[23]346
[438]347#if DEBUG_FATFS_INIT
[435]348uint32_t cycle = (uint32_t)hal_get_cycles();
[438]349if( DEBUG_FATFS_INIT < cycle )
[435]350printk("\n[DBG] %s : thread %x enter for fatfs_ctx = %x / cycle %d\n",
351__FUNCTION__ , CURRENT_THREAD , fatfs_ctx , cycle );
352#endif
[23]353
[246]354    assert( (fatfs_ctx != NULL) , __FUNCTION__ ,
[435]355    "cannot allocate memory for FATFS context\n" );
[23]356
[50]357    // allocate a 512 bytes buffer to store the boot record
358        req.type    = KMEM_512_BYTES;
359    req.flags   = AF_KERNEL | AF_ZERO;
360        buffer      = (uint8_t *)kmem_alloc( &req );
[188]361
[246]362    assert( (buffer != NULL) , __FUNCTION__ ,
[435]363    "cannot allocate memory for 512 bytes buffer\n" );
[50]364     
365    // load the boot record from device
366    // using a synchronous access to IOC device 
[23]367    error = dev_ioc_sync_read( buffer , 0 , 1 );
368
[435]369    assert( (error == 0) , __FUNCTION__ , 
370    "cannot access boot record\n" );
[279]371
[438]372#if (DEBUG_FATFS_INIT & 0x1)
373if( DEBUG_FATFS_INIT < cycle )
[406]374{
[50]375    uint32_t   line;
376    uint32_t   byte = 0;
[406]377    printk("\n***** %s : FAT boot record\n", __FUNCTION__ );
[50]378    for ( line = 0 ; line < 32 ; line++ )
379    {
380        printk(" %X | %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x |\n",
381               byte,
382               buffer[byte+ 0],buffer[byte+ 1],buffer[byte+ 2],buffer[byte+ 3],
383               buffer[byte+ 4],buffer[byte+ 5],buffer[byte+ 6],buffer[byte+ 7],
384               buffer[byte+ 8],buffer[byte+ 9],buffer[byte+10],buffer[byte+11],
385               buffer[byte+12],buffer[byte+13],buffer[byte+14],buffer[byte+15] );
386
387         byte += 16;
388    }
[406]389}
[50]390#endif
391
[23]392    // check sector size from boot record
[238]393    uint32_t sector_size = fatfs_get_record( BPB_BYTSPERSEC , buffer , 1 );
[50]394
[279]395    assert( (sector_size == 512) , __FUNCTION__ ,
396            "sector size must be 512 bytes\n" );
[23]397
398    // check cluster size from boot record
[238]399    uint32_t nb_sectors = fatfs_get_record( BPB_SECPERCLUS , buffer , 1 );
[50]400
[279]401    assert( (nb_sectors == 8) , __FUNCTION__ ,
[435]402    "cluster size must be 8 sectors\n" );
[23]403
404    // check number of FAT copies from boot record
[238]405    uint32_t nb_fats = fatfs_get_record( BPB_NUMFATS , buffer , 1 );
[50]406
[279]407    assert( (nb_fats == 1) , __FUNCTION__ ,
[435]408    "number of FAT copies must be 1\n" );
[23]409
410    // get & check number of sectors in FAT from boot record
[238]411    uint32_t fat_sectors = fatfs_get_record( BPB_FAT32_FATSZ32 , buffer , 1 );
[50]412
[279]413    assert( ((fat_sectors & 0xF) == 0) , __FUNCTION__ ,
[435]414    "FAT not multiple of 16 sectors\n");
[23]415
416    // get and check root cluster from boot record
[238]417    uint32_t root_cluster = fatfs_get_record( BPB_FAT32_ROOTCLUS , buffer , 1 );
[50]418
[279]419    assert( (root_cluster == 2) , __FUNCTION__ ,
[435]420    "root cluster index must be  2\n");
[23]421
422    // get FAT lba from boot record
[238]423    uint32_t fat_lba = fatfs_get_record( BPB_RSVDSECCNT , buffer , 1 );
[50]424
425    // release the 512 bytes buffer
426    req.type = KMEM_512_BYTES;
427    req.ptr  = buffer;
428    kmem_free( &req );
429
[23]430    // allocate a mapper for the FAT itself
[246]431    mapper_t * fat_mapper = mapper_create( FS_TYPE_FATFS );
[50]432
[435]433    assert( (fat_mapper != NULL) , __FUNCTION__ ,
434    "no memory for FAT mapper" );
[23]435
[246]436    // WARNING : the inode field MUST be NULL for the FAT mapper
437    fat_mapper->inode = NULL;
438
[23]439    // initialize the FATFS context
440    fatfs_ctx->fat_begin_lba         = fat_lba;
441    fatfs_ctx->fat_sectors_count     = fat_sectors; 
442    fatfs_ctx->bytes_per_sector      = sector_size;
[188]443    fatfs_ctx->sectors_per_cluster   = nb_sectors;
[23]444    fatfs_ctx->cluster_begin_lba     = fat_lba + fat_sectors;
445    fatfs_ctx->root_dir_cluster      = 2;
446    fatfs_ctx->last_allocated_sector = 0;    // TODO ???
447    fatfs_ctx->last_allocated_index  = 0;    // TODO ???
448    fatfs_ctx->fat_mapper_xp         = XPTR( local_cxy , fat_mapper );
449
[438]450#if DEBUG_FATFS_INIT
[435]451cycle = (uint32_t)hal_get_cycles();
[438]452if( DEBUG_FATFS_INIT < cycle )
[435]453printk("\n[DBG] %s : thread %x exit for fatfs_ctx = %x / cycle %d\n",
454__FUNCTION__ , CURRENT_THREAD , fatfs_ctx , cycle );
455#endif
[279]456
[23]457}  // end fatfs_ctx_init()
458
[188]459/////////////////////////////////////////////////
460void fatfs_ctx_destroy( fatfs_ctx_t * fatfs_ctx )
[23]461{
462    kmem_req_t    req;
[188]463    req.type = KMEM_FATFS_CTX;
[23]464    req.ptr  = fatfs_ctx;
465    kmem_free( &req );
466}
467
[246]468//////////////////////////////////////////////
469error_t fatfs_mapper_move_page( page_t * page,
470                                bool_t   to_mapper )
[1]471{
[401]472    error_t       error;
473    vfs_inode_t * inode;
474    mapper_t    * mapper;
475    uint32_t      index;       // page index in mapper
476    uint8_t     * buffer;      // page base address in mapper
477    uint32_t      count;       // number of sectors in a page
478    uint32_t      lba;         // block address on device
479    fatfs_ctx_t * fatfs_ctx;   // pointer on local FATFS context
[246]480
[406]481    // get pointer on mapper and page index from page descriptor
[401]482    mapper = page->mapper;
483    index  = page->index;
[1]484
[406]485    // get inode pointer from mapper
[401]486    inode = mapper->inode;
[1]487
[438]488#if DEBUG_FATFS_MOVE
[435]489uint32_t cycle = (uint32_t)hal_get_cycles();
[438]490if( DEBUG_FATFS_MOVE < cycle )
[435]491printk("\n[DBG] %s : thread %x enter / page %d / inode %x / mapper %x / cycle %d\n",
492__FUNCTION__ , CURRENT_THREAD , index , inode , mapper , cycle );
493#endif
[1]494
[406]495    // get page base address
[315]496    xptr_t base_xp = ppm_page2base( XPTR( local_cxy , page ) );
[401]497    buffer = (uint8_t *)GET_PTR( base_xp );
[246]498 
[401]499    // get number of sectors for one page (from FATFS context)
500    fatfs_ctx = (fatfs_ctx_t *)fs_context[FS_TYPE_FATFS].extend;
501    count = fatfs_ctx->sectors_per_cluster;
[1]502
[401]503    // test FAT/normal inode
504    if( inode == NULL )      // it is the FAT mapper
[246]505    {
506        // get lba from page index
[401]507        lba = fatfs_ctx->fat_begin_lba + (count * index);
[246]508 
[438]509#if (DEBUG_FATFS_MOVE & 0x1)
510if( DEBUG_FATFS_MOVE < cycle )
[435]511printk("\n[DBG] %s : access FAT on device / lba = %d\n", __FUNCTION__ , lba );
512#endif
[1]513
[246]514        // access device
515        if( to_mapper ) error = dev_ioc_sync_read ( buffer , lba , count );
516        else            error = dev_ioc_write( buffer , lba , count );     
[1]517
[246]518        if( error ) return EIO;
519    }
[401]520    else                     // it is a normal inode mapper
[1]521    {
[265]522        uint32_t  searched_cluster_id;
[1]523
[265]524        // get first_cluster_id from inode extension
525        uint32_t  first_cluster_id = (uint32_t)(intptr_t)inode->extend;
[246]526
[265]527        // compute cluster_id
528        if( index == 0 )            // no need to access FAT mapper
529        {
530            searched_cluster_id = first_cluster_id;
531        }
532        else                        // FAT mapper access required
533        {
534            // get cluster and local pointer on FAT mapper
535            xptr_t     fat_mapper_xp  = fatfs_ctx->fat_mapper_xp;
536            cxy_t      fat_mapper_cxy = GET_CXY( fat_mapper_xp );
537            mapper_t * fat_mapper_ptr = (mapper_t *)GET_PTR( fat_mapper_xp );
538
539            // access FAT mapper
540            if( fat_mapper_cxy == local_cxy )    // FAT mapper is local
541            {
[407]542
[438]543#if (DEBUG_FATFS_MOVE & 0x1)
544if( DEBUG_FATFS_MOVE < cycle )
[435]545print("\n[DBG] %s : access local FAT mapper\n"
[407]546"fat_mapper_cxy = %x / fat_mapper_ptr = %x / first_cluster_id = %d / index = %d\n",
[435]547__FUNCTION__ , fat_mapper_cxy , fat_mapper_ptr , first_cluster_id , index );
548#endif
[265]549                error = fatfs_get_cluster( fat_mapper_ptr,
550                                           first_cluster_id,
551                                           index,
552                                           &searched_cluster_id );
553            }
554            else                                 // FAT mapper is remote
555            {
[407]556
[438]557#if (DEBUG_FATFS_MOVE & 0x1)
558if( DEBUG_FATFS_MOVE < cycle )
[435]559printk("\n[DBG] %s : access remote FAT mapper\n"
[407]560"fat_mapper_cxy = %x / fat_mapper_ptr = %x / first_cluster_id = %d / index = %d\n",
[435]561__FUNCTION__ , fat_mapper_cxy , fat_mapper_ptr , first_cluster_id , index );
562#endif
[265]563                rpc_fatfs_get_cluster_client( fat_mapper_cxy,
564                                              fat_mapper_ptr,
565                                              first_cluster_id,
566                                              index,
567                                              &searched_cluster_id,
568                                              &error );
569            }
570
571            if( error )  return EIO;
572        }
573
[438]574#if (DEBUG_FATFS_MOVE & 0x1)
575if( DEBUG_FATFS_MOVE < cycle )
[435]576printk("\n[DBG] %s : access device for inode %x / cluster_id %d\n",
577__FUNCTION__ , inode , searched_cluster_id );
578#endif
[406]579
[265]580        // get lba from cluster_id
[401]581        lba = fatfs_lba_from_cluster( fatfs_ctx , searched_cluster_id );
[265]582
[246]583        // access device
584        if( to_mapper ) error = dev_ioc_sync_read ( buffer , lba , count );
585        else            error = dev_ioc_write( buffer , lba , count );     
586
587        if( error ) return EIO;
588    }
589
[438]590#if DEBUG_FATFS_MOVE
[435]591cycle = (uint32_t)hal_get_cycles();
[438]592if( DEBUG_FATFS_MOVE < cycle )
[435]593printk("\n[DBG] %s : thread %x exit / page %d / inode %x / mapper %x / cycle %d\n",
594__FUNCTION__ , CURRENT_THREAD , index , inode , mapper , cycle );
595#endif
[401]596
[438]597#if (DEBUG_FATFS_MOVE & 0x1)
598if( DEBUG_FATFS_MOVE < cycle )
[406]599{
600    uint32_t * tab = (uint32_t *)buffer;
601    uint32_t line , word;
602    printk("\n***** %s : First 64 words of loaded page\n", __FUNCTION__ );
603    for( line = 0 ; line < 8 ; line++ )
604    {
605        printk("%X : ", line );
606        for( word = 0 ; word < 8 ; word++ ) printk("%X ", tab[(line<<3) + word] );
607        printk("\n");
608    }
609}
610#endif
611
[1]612    return 0;
613
[246]614}  // end fatfs_mapper_move_page()
615
[265]616/////////////////////////////////////////////////////
[238]617error_t fatfs_inode_load( vfs_inode_t * parent_inode,
618                          char        * name,
619                          xptr_t        child_inode_xp )
[1]620{
[238]621    // Two embedded loops:
622    // - scan the parent mapper pages
623    // - scan the directory entries in each 4 Kbytes page
[1]624
[438]625#if DEBUG_FATFS_LOAD
[435]626uint32_t cycle = (uint32_t)hal_get_cycles();
[438]627if( DEBUG_FATFS_LOAD < cycle )
[435]628printk("\n[DBG] %s : thread %x enter for child <%s> in parent inode %x / cycle %d\n",
629__FUNCTION__ , CURRENT_THREAD , name , parent_inode , cycle );
630#endif
[1]631
[238]632    mapper_t * mapper = parent_inode->mapper;
633
634    assert( (mapper != NULL) , __FUNCTION__ , "parent mapper undefined\n");
635   
636    char       cname[CONFIG_VFS_MAX_NAME_LENGTH];  // name extracter from each directory entry
637
638    char       lfn1[16];         // buffer for one partial cname
639    char       lfn2[16];         // buffer for one partial cname
640    char       lfn3[16];         // buffer for one partial cname
641    page_t   * page;             // pointer on current page descriptor
642    uint8_t  * base;             // pointer on current page base
643    uint32_t   offset  = 0;      // byte offset in page
644    uint32_t   index   = 0;      // page index in mapper
645    uint32_t   attr;             // directory entry ATTR field
646    uint32_t   ord;              // directory entry ORD field
647    uint32_t   seq;              // sequence index
648    uint32_t   lfn     = 0;      // LFN entries number
649    uint32_t   size    = 0;      // searched file/dir size (bytes)
650    uint32_t   cluster = 0;      // searched file/dir cluster index
651    uint32_t   is_dir  = 0;      // searched file/dir type
652    uint32_t   dentry;           // directory entry index
653    int32_t    found   = 0;      // not found (0) / name found (1) / end of dir (-1)
654
655    // scan the parent directory mapper
656    while ( found == 0 )
657    {
658        // get one page
659        page = mapper_get_page( mapper , index );
660
661        assert( (page != NULL) , __FUNCTION__ , "bad parent mapper\n");
662
663        // get page base
[315]664        xptr_t base_xp = ppm_page2base( XPTR( local_cxy , page ) );
665        base = (uint8_t *)GET_PTR( base_xp );
[238]666
[438]667#if (DEBUG_FATFS_LOAD & 0x1)
668if( DEBUG_FATFS_LOAD < cycle )
[406]669{
[265]670    uint32_t * buf = (uint32_t *)base;
671    uint32_t line , word;
[406]672    printk("\n***** %s : First 16 dentries for parent inode %x\n",
673    __FUNCTION__ , parent_inode );
[265]674    for( line = 0 ; line < 16 ; line++ )
675    {
676        printk("%X : ", line );
677        for( word = 0 ; word < 8 ; word++ ) printk("%X ", buf[(line<<4) + word] );
678        printk("\n");
679    }
[406]680}
[265]681#endif
[238]682        // scan this page until end of directory, end of page, or name found
683        while( (offset < 4096) && (found == 0) )
684        {
685            attr = fatfs_get_record( DIR_ATTR , base + offset , 0 );   
686            ord  = fatfs_get_record( LDIR_ORD , base + offset , 0 );   
687
688            if (ord == NO_MORE_ENTRY)                 // no more entry => break
689            {
690                found = -1;
691            }
692            else if ( ord == FREE_ENTRY )             // free entry => skip
693            {
694                offset = offset + 32;
695            }
696            else if ( attr == ATTR_LONG_NAME_MASK )   // LFN entry => get partial cname
697            {
698                seq = ord & 0x3;
699                lfn = (seq > lfn) ? seq : lfn;   
700                if      ( seq == 1 ) fatfs_get_name_from_long( base + offset, lfn1 );
701                else if ( seq == 2 ) fatfs_get_name_from_long( base + offset, lfn2 );
702                else if ( seq == 3 ) fatfs_get_name_from_long( base + offset, lfn3 );
703                offset = offset + 32;
704            }
705            else                                 // NORMAL entry
706            {
707                // build the extracted name
708                if      ( lfn == 0 )
709                {
710                    fatfs_get_name_from_short( base + offset , cname );
711                }
712                else if ( lfn == 1 )
713                {
714                    strcpy( cname      , lfn1 );
715                }   
716                else if ( lfn == 2 ) 
717                {
718                    strcpy( cname      , lfn1 );
719                    strcpy( cname + 13 , lfn2 );
720                }
721                else if ( lfn == 3 ) 
722                {
723                    strcpy( cname      , lfn1 );
724                    strcpy( cname + 13 , lfn2 );
725                    strcpy( cname + 26 , lfn3 );
726                }
727
728                // get dentry arguments if extracted cname == searched name
729                if ( strcmp( name , cname ) == 0 )
730                {
731                    cluster = (fatfs_get_record( DIR_FST_CLUS_HI , base + offset , 1 ) << 16) |
732                              (fatfs_get_record( DIR_FST_CLUS_LO , base + offset , 1 )      ) ;
733                    dentry  = ((index<<12) + offset)>>5;
734                    is_dir  = ((attr & ATTR_DIRECTORY) == ATTR_DIRECTORY);
735                    size    = fatfs_get_record( DIR_FILE_SIZE , base + offset , 1 );
736                    found   = 1;
737                }
738                offset = offset + 32;
739                lfn    = 0;
740            }
741        }  // end loop on directory entries
742        index++;
743        offset = 0;
744    }  // end loop on pages
745
746    // analyse the result of scan
747
748    if ( found == -1 )  // found end of directory => failure
749    {
750
[438]751#if DEBUG_FATFS_LOAD
[435]752cycle = (uint32_t)hal_get_cycles();
[438]753if( DEBUG_FATFS_LOAD < cycle )
[435]754printk("\n[DBG] %s : thread %x exit / child <%s> not found / cycle %d\n",
755__FUNCTION__ , CURRENT_THREAD, name, cycle );
756#endif
[407]757
[238]758        return ENOENT;
759    }
760    else               // found searched child name
761    {
762        // get child inode cluster and local pointer
763        cxy_t         child_cxy = GET_CXY( child_inode_xp );
764        vfs_inode_t * child_ptr = (vfs_inode_t *)GET_PTR( child_inode_xp );
765
766        // update the child inode "type", "size", and "extend" fields
767        vfs_inode_type_t type = (is_dir) ? INODE_TYPE_DIR : INODE_TYPE_FILE;
768
769        hal_remote_sw( XPTR( child_cxy , &child_ptr->type   ) , type );
770        hal_remote_sw( XPTR( child_cxy , &child_ptr->size   ) , size );
771        hal_remote_sw( XPTR( child_cxy , &child_ptr->extend ) , cluster );
772
[438]773#if DEBUG_FATFS_LOAD
[435]774cycle = (uint32_t)hal_get_cycles();
[438]775if( DEBUG_FATFS_LOAD < cycle )
[435]776printk("\n[DBG] %s : thread %x exit / child <%s> loaded / cycle %d\n",
777__FUNCTION__ , CURRENT_THREAD, name, cycle );
778#endif
[246]779
[238]780        return 0;
781    }
782}  // end fatfs_inode_load()
Note: See TracBrowser for help on using the repository browser.