source: trunk/kernel/vfs/fatfs.c @ 238

Last change on this file since 238 was 238, checked in by alain, 5 years ago

Fixing bugs in vfs_lookup()

File size: 24.6 KB
Line 
1/*
2 * fatfs.c - FATFS file system API implementation.
3 *
4 * Author    Alain Greiner (2016,2017)
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_types.h>
26#include <hal_special.h>
27#include <printk.h>
28#include <kmem.h>
29#include <ppm.h>
30#include <vfs.h>
31#include <string.h>
32#include <rpc.h>
33#include <mapper.h>
34#include <cluster.h>
35#include <dev_ioc.h>
36#include <fatfs.h>
37
38
39//////////////////////////////////////////////////////////////////////////////////////////
40//          Extern  variables         
41//////////////////////////////////////////////////////////////////////////////////////////
42
43extern vfs_ctx_t          fs_context[FS_TYPES_NR];   // allocated in vfs.c file
44
45extern remote_barrier_t   global_barrier;            // allocated in kernel_init.c
46 
47//////////////////////////////////////////////////////////////////////////////////////////
48//              FATFS private and 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 , int length ) { return length; }
57
58static inline int get_offset( int offset , int length ) { return offset; }
59
60
61//////////////////////////////////////////////////////////////////////////////////////////
62// This function returns the LBA of the first sector of a FAT cluster.
63// This function can be called by any thread running in any cluster.
64//////////////////////////////////////////////////////////////////////////////////////////
65// @ ctx          :     pointer on FATFS context.
66// @ cluster  : cluster index in FATFS.
67// @ return the lba value.
68//////////////////////////////////////////////////////////////////////////////////////////
69static inline uint32_t fatfs_lba_from_cluster( fatfs_ctx_t * ctx,
70                                               uint32_t      cluster )
71{
72    return (ctx->cluster_begin_lba + ((cluster - 2) << 3));
73}
74
75
76//////////////////////////////////////////////////////////////////////////////////////////
77// This function return an integer record value (one, two, or four bytes)
78// from a memory buffer, taking into account endianness.
79//////////////////////////////////////////////////////////////////////////////////////////
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.
85//////////////////////////////////////////////////////////////////////////////////////////
86static uint32_t fatfs_get_record( uint32_t    offset,
87                                  uint32_t    size,
88                                  uint8_t   * buffer,
89                                  uint32_t    little_endian )
90{
91    uint32_t n;
92    uint32_t res  = 0;
93
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
104}  // end fatfs_get_record()
105
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;
118
119    // get name
120    for ( i = 0; i < 8 && buffer[i] != ' '; i++ )
121    {
122        name[j] = to_lower( buffer[i] );
123        j++;
124    }
125
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
220//////////////////////////////////////////////////////////////////////////////////////////
221// This function returns the FATFS cluster index of a page identified by its page
222// index in the file, using the FAT mapper. It scans the FAT mapper, starting from the
223// FATFS cluster index allocated to the first page of the file, until it reaches the
224// searched page. The FAT mapper is automatically updated in case of miss.
225// This function can be called by any thread running in any cluster, as it uses the
226// RPC_FATFS_GET_CLUSTER to access the remote FAT mapper if required.
227// We use a RPC to scan the FAT because the RPC_FIFO will avoid contention
228// in the cluster containing the FAT mapper, and the RPC latency is not critical
229// compared to the device access latency.
230//////////////////////////////////////////////////////////////////////////////////////////
231// @ ctx               : pointer on local FATFS context.
232// @ first_cluster : first cluster allocated to a file in FATFS.
233// @ page_index    : index of searched page in file (one page occupies one cluster).
234// @ cluster_index : [out] pointer on buffer for FATFS cluster index.
235// @ return 0 if success / return EIO if a FAT cluster miss cannot be solved.
236//////////////////////////////////////////////////////////////////////////////////////////
237static error_t fatfs_cluster_from_index( fatfs_ctx_t * ctx,
238                                         uint32_t      first_cluster,
239                                         uint32_t      page_index,
240                                         uint32_t    * cluster_index )
241{
242    uint32_t searched_cluster;   // searched FATFS cluster index
243    error_t  error;
244
245    // get extended pointer on FAT mapper
246    xptr_t fat_mapper_xp = ctx->fat_mapper_xp;
247
248    // get cluster cxy and local pointer on FAT mapper
249    cxy_t      fat_mapper_cxy = GET_CXY( fat_mapper_xp );
250    mapper_t * fat_mapper_ptr = (mapper_t *)GET_PTR( fat_mapper_xp );
251
252    if( fat_mapper_cxy == local_cxy )    // FAT mapper is local
253    {
254        error = fatfs_get_cluster( fat_mapper_ptr,
255                                   first_cluster,
256                                   page_index,
257                                   &searched_cluster );
258    }
259    else                                 // FAT mapper is remote
260    {
261        rpc_fatfs_get_cluster_client( fat_mapper_cxy,
262                                      fat_mapper_ptr,
263                                      first_cluster,
264                                      page_index,
265                                      &searched_cluster,
266                                      &error );
267    }
268   
269    if( error )
270    {
271        printk("\n[ERROR] in %s : cannot access FAT\n", __FUNCTION__ );
272        return error;
273    }
274
275    // return success
276    *cluster_index = searched_cluster;
277    return 0;
278
279}  // end fatfs_cluster_from_index()
280
281//////////////////////////////////////////////////////////////////////////////////////////
282//              FATFS specific but public functions (used by RPC_FATFS_GET_CLUSTER)
283//////////////////////////////////////////////////////////////////////////////////////////
284
285/////////////////////////////////////////////
286error_t fatfs_get_cluster( mapper_t * mapper,
287                           uint32_t   first_cluster,
288                           uint32_t   searched_page,
289                           uint32_t * cluster )
290{
291    page_t   * current_page_desc;      // pointer on current page descriptor
292    uint32_t * current_page_buffer;    // pointer on current page (array of uint32_t)
293    uint32_t   current_page_index;     // index of current page in mapper
294    uint32_t   current_page_offset;    // offset of slot in current page
295    uint32_t   page_count_in_file;     // index of page in file (index in linked list)
296    uint32_t   current_cluster;        // content of current FAT slot
297
298    // compute number of FAT slots per PPM page
299    uint32_t slots_per_page = CONFIG_PPM_PAGE_SIZE >> 2;
300
301    // initialize loop variable
302    current_page_index  = first_cluster / slots_per_page;
303    current_page_offset = first_cluster % slots_per_page;
304    page_count_in_file  = 0;
305
306    // scan FAT (i.e. traverse FAT linked list)
307    while( page_count_in_file <= searched_page )
308    {
309        // get pointer on current page descriptor
310        current_page_desc = mapper_get_page( mapper , current_page_index );
311
312        if( current_page_desc == NULL ) return EIO;
313
314        // get pointer on buffer for current page
315        current_page_buffer = (uint32_t *)ppm_page2vaddr( current_page_desc );
316
317        // get FAT slot content
318        current_cluster = current_page_buffer[current_page_offset];
319
320        // update loop variables
321        current_page_index  = current_cluster / slots_per_page;
322        current_page_offset = current_cluster % slots_per_page;
323        page_count_in_file++;
324    }
325   
326    // return success
327    *cluster = current_cluster;
328    return 0;
329
330}  // end fatfs_get_cluster()
331
332
333
334///////////////////////////////////////////////////////////////////////////////////////
335// Generic API : the following functions are called by the kernel (VFS)
336//               and must be defined by all supported file systems.
337///////////////////////////////////////////////////////////////////////////////////////
338
339///////////////////////////////
340fatfs_ctx_t * fatfs_ctx_alloc()
341{
342    kmem_req_t    req;
343        req.type    = KMEM_FATFS_CTX;
344        req.size    = sizeof(fatfs_ctx_t);
345    req.flags   = AF_KERNEL | AF_ZERO;
346
347        return (fatfs_ctx_t *)kmem_alloc( &req );
348}
349
350//////////////////////////////////////////////
351void fatfs_ctx_init( fatfs_ctx_t * fatfs_ctx )
352{
353    error_t       error;
354    kmem_req_t    req;
355    uint8_t     * buffer;
356
357    fatfs_dmsg("\n[INFO] %s : enters at cycle %d\n", 
358               __FUNCTION__ , hal_get_cycles() );
359
360    // allocate memory for FATFS context
361        req.type    = KMEM_FATFS_CTX;
362        req.size    = sizeof(fatfs_ctx_t);
363    req.flags   = AF_KERNEL | AF_ZERO;
364
365        fatfs_ctx = (fatfs_ctx_t *)kmem_alloc( &req );
366
367    nolock_assert( (fatfs_ctx != NULL) , __FUNCTION__ ,
368                   "cannot allocate memory for FATFS context\n" );
369
370    // allocate a 512 bytes buffer to store the boot record
371        req.type    = KMEM_512_BYTES;
372    req.flags   = AF_KERNEL | AF_ZERO;
373        buffer      = (uint8_t *)kmem_alloc( &req );
374
375    nolock_assert( (buffer != NULL) , __FUNCTION__ ,
376                   "cannot allocate memory for 512 bytes buffer\n" );
377     
378    // load the boot record from device
379    // using a synchronous access to IOC device 
380    error = dev_ioc_sync_read( buffer , 0 , 1 );
381
382    nolock_assert( (error == 0) , __FUNCTION__ ,
383                   "cannot access boot record\n" );
384
385#if CONFIG_FATFS_DEBUG
386    uint32_t   line;
387    uint32_t   byte = 0;
388    printk("\n*** boot record at cycle %d ***\n", hal_get_cycles() );
389    for ( line = 0 ; line < 32 ; line++ )
390    {
391        printk(" %X | %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x |\n",
392               byte,
393               buffer[byte+ 0],buffer[byte+ 1],buffer[byte+ 2],buffer[byte+ 3],
394               buffer[byte+ 4],buffer[byte+ 5],buffer[byte+ 6],buffer[byte+ 7],
395               buffer[byte+ 8],buffer[byte+ 9],buffer[byte+10],buffer[byte+11],
396               buffer[byte+12],buffer[byte+13],buffer[byte+14],buffer[byte+15] );
397
398         byte += 16;
399    }
400#endif
401
402    // check sector size from boot record
403    uint32_t sector_size = fatfs_get_record( BPB_BYTSPERSEC , buffer , 1 );
404
405    nolock_assert( (sector_size == 512) , __FUNCTION__ ,
406                   "sector size must be 512 bytes\n" );
407
408    // check cluster size from boot record
409    uint32_t nb_sectors = fatfs_get_record( BPB_SECPERCLUS , buffer , 1 );
410
411    nolock_assert( (nb_sectors == 8) , __FUNCTION__ ,
412                   "cluster size must be 8 sectors\n" );
413
414    // check number of FAT copies from boot record
415    uint32_t nb_fats = fatfs_get_record( BPB_NUMFATS , buffer , 1 );
416
417    nolock_assert( (nb_fats == 1) , __FUNCTION__ ,
418                   "number of FAT copies must be 1\n" );
419
420    // get & check number of sectors in FAT from boot record
421    uint32_t fat_sectors = fatfs_get_record( BPB_FAT32_FATSZ32 , buffer , 1 );
422
423    nolock_assert( ((fat_sectors & 0xF) == 0) , __FUNCTION__ ,
424                   "FAT not multiple of 16 sectors\n");
425
426    // get and check root cluster from boot record
427    uint32_t root_cluster = fatfs_get_record( BPB_FAT32_ROOTCLUS , buffer , 1 );
428
429    nolock_assert( (root_cluster == 2) , __FUNCTION__ ,
430                   "root cluster index must be  2\n");
431
432    // get FAT lba from boot record
433    uint32_t fat_lba = fatfs_get_record( BPB_RSVDSECCNT , buffer , 1 );
434
435    // release the 512 bytes buffer
436    req.type = KMEM_512_BYTES;
437    req.ptr  = buffer;
438    kmem_free( &req );
439
440    // allocate a mapper for the FAT itself
441    mapper_t * fat_mapper = mapper_create();
442
443    assert( (fat_mapper != NULL) , __FUNCTION__ , "no memory for FAT mapper" );
444
445    // initialize the FATFS context
446    fatfs_ctx->fat_begin_lba         = fat_lba;
447    fatfs_ctx->fat_sectors_count     = fat_sectors; 
448    fatfs_ctx->bytes_per_sector      = sector_size;
449    fatfs_ctx->sectors_per_cluster   = nb_sectors;
450    fatfs_ctx->cluster_begin_lba     = fat_lba + fat_sectors;
451    fatfs_ctx->root_dir_cluster      = 2;
452    fatfs_ctx->last_allocated_sector = 0;    // TODO ???
453    fatfs_ctx->last_allocated_index  = 0;    // TODO ???
454    fatfs_ctx->fat_mapper_xp         = XPTR( local_cxy , fat_mapper );
455
456    fatfs_dmsg("\n*** FAT context ***\n" 
457               "- fat_sectors     = %d\n"
458               "- sector size     = %d\n"
459               "- cluster size    = %d\n"
460               "- fat_first_lba   = %d\n"
461               "- data_first_lba  = %d\n"
462               "- mapper          = %l\n",
463               fatfs_ctx->fat_sectors_count,
464               fatfs_ctx->bytes_per_sector,
465               fatfs_ctx->bytes_per_cluster,
466               fatfs_ctx->fat_begin_lba,
467               fatfs_ctx->cluster_begin_lba,
468               fatfs_ctx->fat_mapper_xp );
469
470}  // end fatfs_ctx_init()
471
472/////////////////////////////////////////////////
473void fatfs_ctx_destroy( fatfs_ctx_t * fatfs_ctx )
474{
475    kmem_req_t    req;
476    req.type = KMEM_FATFS_CTX;
477    req.ptr  = fatfs_ctx;
478    kmem_free( &req );
479}
480
481///////////////////////////////////////
482error_t fatfs_move_page( page_t * page,
483                         bool_t   to_mapper )
484{
485    // get memory buffer base address
486    uint8_t * buffer = (uint8_t *)ppm_page2vaddr( page );
487 
488    // get pointer on source mapper and page index from page descriptor
489    mapper_t * mapper      = page->mapper;
490    uint32_t   page_index  = page->index;
491
492    // get VFS inode pointer from mapper
493    vfs_inode_t * vfs_inode = mapper->inode;
494
495    // get first cluster index from VFS inode
496    uint32_t  first_cluster = (uint32_t)(intptr_t)vfs_inode->extend;
497
498    // get FATFS context pointer from VFS context
499    fatfs_ctx_t * fatfs_ctx = (fatfs_ctx_t *)fs_context[FS_TYPE_FATFS].extend;
500
501    // get number of sectors
502    uint32_t count = fatfs_ctx->sectors_per_cluster;
503
504    // compute FATFS_cluster index for the accessed page
505    uint32_t cluster = 0;
506    error_t  error = fatfs_cluster_from_index( fatfs_ctx,
507                                               first_cluster,
508                                               page_index,
509                                               &cluster );
510    if( error ) return EIO;
511
512    // get lba from cluster
513    uint32_t lba = fatfs_lba_from_cluster( fatfs_ctx , cluster );
514
515    // access device
516    if( to_mapper ) error = dev_ioc_read ( buffer , lba , count );
517    else            error = dev_ioc_write( buffer , lba , count );     
518
519    if( error )
520    {
521        printk("\n[ERROR] in %s : cannot access IOC device\n", __FUNCTION__ );
522        return error;
523    } 
524
525    // successful access
526    return 0;
527}
528
529/////////////////////////////////////////////////////////////////
530error_t fatfs_inode_load( vfs_inode_t * parent_inode,
531                          char        * name,
532                          xptr_t        child_inode_xp )
533{
534    // Two embedded loops:
535    // - scan the parent mapper pages
536    // - scan the directory entries in each 4 Kbytes page
537
538    fatfs_dmsg("\n[INFO] %s : enter for child <%s> in parent inode %l\n",
539               __FUNCTION__ , name , child_inode_xp );
540
541    mapper_t * mapper = parent_inode->mapper;
542
543    assert( (mapper != NULL) , __FUNCTION__ , "parent mapper undefined\n");
544   
545    char       cname[CONFIG_VFS_MAX_NAME_LENGTH];  // name extracter from each directory entry
546
547    char       lfn1[16];         // buffer for one partial cname
548    char       lfn2[16];         // buffer for one partial cname
549    char       lfn3[16];         // buffer for one partial cname
550    page_t   * page;             // pointer on current page descriptor
551    uint8_t  * base;             // pointer on current page base
552    uint32_t   offset  = 0;      // byte offset in page
553    uint32_t   index   = 0;      // page index in mapper
554    uint32_t   attr;             // directory entry ATTR field
555    uint32_t   ord;              // directory entry ORD field
556    uint32_t   seq;              // sequence index
557    uint32_t   lfn     = 0;      // LFN entries number
558    uint32_t   size    = 0;      // searched file/dir size (bytes)
559    uint32_t   cluster = 0;      // searched file/dir cluster index
560    uint32_t   is_dir  = 0;      // searched file/dir type
561    uint32_t   dentry;           // directory entry index
562    int32_t    found   = 0;      // not found (0) / name found (1) / end of dir (-1)
563
564    // scan the parent directory mapper
565    while ( found == 0 )
566    {
567        // get one page
568        page = mapper_get_page( mapper , index );
569
570        assert( (page != NULL) , __FUNCTION__ , "bad parent mapper\n");
571
572        // get page base
573        base = ppm_page2vaddr( page );
574
575        // scan this page until end of directory, end of page, or name found
576        while( (offset < 4096) && (found == 0) )
577        {
578            attr = fatfs_get_record( DIR_ATTR , base + offset , 0 );   
579            ord  = fatfs_get_record( LDIR_ORD , base + offset , 0 );   
580
581            if (ord == NO_MORE_ENTRY)                 // no more entry => break
582            {
583                found = -1;
584            }
585            else if ( ord == FREE_ENTRY )             // free entry => skip
586            {
587                offset = offset + 32;
588            }
589            else if ( attr == ATTR_LONG_NAME_MASK )   // LFN entry => get partial cname
590            {
591                seq = ord & 0x3;
592                lfn = (seq > lfn) ? seq : lfn;   
593                if      ( seq == 1 ) fatfs_get_name_from_long( base + offset, lfn1 );
594                else if ( seq == 2 ) fatfs_get_name_from_long( base + offset, lfn2 );
595                else if ( seq == 3 ) fatfs_get_name_from_long( base + offset, lfn3 );
596                offset = offset + 32;
597            }
598            else                                 // NORMAL entry
599            {
600                // build the extracted name
601                if      ( lfn == 0 )
602                {
603                    fatfs_get_name_from_short( base + offset , cname );
604                }
605                else if ( lfn == 1 )
606                {
607                    strcpy( cname      , lfn1 );
608                }   
609                else if ( lfn == 2 ) 
610                {
611                    strcpy( cname      , lfn1 );
612                    strcpy( cname + 13 , lfn2 );
613                }
614                else if ( lfn == 3 ) 
615                {
616                    strcpy( cname      , lfn1 );
617                    strcpy( cname + 13 , lfn2 );
618                    strcpy( cname + 26 , lfn3 );
619                }
620
621                // get dentry arguments if extracted cname == searched name
622                if ( strcmp( name , cname ) == 0 )
623                {
624                    cluster = (fatfs_get_record( DIR_FST_CLUS_HI , base + offset , 1 ) << 16) |
625                              (fatfs_get_record( DIR_FST_CLUS_LO , base + offset , 1 )      ) ;
626                    dentry  = ((index<<12) + offset)>>5;
627                    is_dir  = ((attr & ATTR_DIRECTORY) == ATTR_DIRECTORY);
628                    size    = fatfs_get_record( DIR_FILE_SIZE , base + offset , 1 );
629                    found   = 1;
630                }
631                offset = offset + 32;
632                lfn    = 0;
633            }
634        }  // end loop on directory entries
635        index++;
636        offset = 0;
637    }  // end loop on pages
638
639    // analyse the result of scan
640
641    if ( found == -1 )  // found end of directory => failure
642    {
643        fatfs_dmsg("\n[INFO] %s : child <%s> not found in parent inode %l\n",
644                   __FUNCTION__ , name , parent_inode_xp );
645
646        return ENOENT;
647    }
648    else               // found searched child name
649    {
650        fatfs_dmsg("\n[INFO] %s : child <%s> found in parent inode %l\n",
651                   __FUNCTION__ , name , parent_inode_xp );
652
653        // get child inode cluster and local pointer
654        cxy_t         child_cxy = GET_CXY( child_inode_xp );
655        vfs_inode_t * child_ptr = (vfs_inode_t *)GET_PTR( child_inode_xp );
656
657        // update the child inode "type", "size", and "extend" fields
658        vfs_inode_type_t type = (is_dir) ? INODE_TYPE_DIR : INODE_TYPE_FILE;
659
660        hal_remote_sw( XPTR( child_cxy , &child_ptr->type   ) , type );
661        hal_remote_sw( XPTR( child_cxy , &child_ptr->size   ) , size );
662        hal_remote_sw( XPTR( child_cxy , &child_ptr->extend ) , cluster );
663
664        return 0;
665    }
666}  // end fatfs_inode_load()
Note: See TracBrowser for help on using the repository browser.