Context Navigation

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

Last change on this file since 612 was 612, checked in by alain, 5 years ago
Fix several bugs in vfs.c, fatfs.c, and devfs.c to support the <.> and <..> directory entries.
File size: 80.5 KB

Line
1	/*
2	* fatfs.c - FATFS file system API implementation.
3	*
4	* Author Alain Greiner (2016,2017,2018)
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
40	//////////////////////////////////////////////////////////////////////////////////////////
41	// Extern variables
42	//////////////////////////////////////////////////////////////////////////////////////////
43
44	extern vfs_ctx_t fs_context[FS_TYPES_NR]; // allocated in kernel_init.c file
45
46	//////////////////////////////////////////////////////////////////////////////////////////
47	// FATFS specific static functions
48	//////////////////////////////////////////////////////////////////////////////////////////
49
50	//////////////////////////////////////////////////////////////////////////////////////////
51	// These functions return the "offset" and "length" values of an
52	// [offset,length] constant defined in the fatfs.h file.
53	//////////////////////////////////////////////////////////////////////////////////////////
54
55	static inline int get_length( int offset __attribute__((unused)), int length ) { return length; }
56
57	static inline int get_offset( int offset, int length __attribute__((unused)) ) { return offset; }
58
59	//////////////////////////////////////////////////////////////////////////////////////////
60	// This static function returns the LBA of the first sector of a FAT cluster.
61	// This function can be called by any thread running in any cluster.
62	//////////////////////////////////////////////////////////////////////////////////////////
63	// @ ctx : pointer on FATFS context.
64	// @ cluster : cluster index in FATFS.
65	// @ return the lba value.
66	//////////////////////////////////////////////////////////////////////////////////////////
67	static inline uint32_t fatfs_lba_from_cluster( fatfs_ctx_t * ctx,
68	uint32_t cluster )
69	{
70	return (ctx->cluster_begin_lba + ((cluster - 2) << 3));
71	}
72
73	//////////////////////////////////////////////////////////////////////////////////////////
74	// This function return an integer record value (one, two, or four bytes)
75	// from a memory buffer, taking into account endianness.
76	//////////////////////////////////////////////////////////////////////////////////////////
77	// @ offset : first byte of record in buffer.
78	// @ size : record length in bytes (1/2/4).
79	// @ buffer : pointer on buffer base.
80	// @ little endian : the most significant byte has the highest address when true.
81	// @ return the integer value in a 32 bits word.
82	//////////////////////////////////////////////////////////////////////////////////////////
83	static uint32_t fatfs_get_record( uint32_t offset,
84	uint32_t size,
85	uint8_t * buffer,
86	uint32_t little_endian )
87	{
88	uint32_t n;
89	uint32_t res = 0;
90
91	if ( little_endian )
92	{
93	for( n = size ; n > 0 ; n-- ) res = (res<<8) \| buffer[offset+n-1];
94	}
95	else // big_endian
96	{
97	for( n = 0 ; n < size ; n++ ) res = (res<<8) \| buffer[offset+n];
98	}
99	return res;
100
101	} // end fatfs_get_record()
102
103	//////////////////////////////////////////////////////////////////////////////////////////
104	// This function writes one, two, or four bytes from a 32 bits integer to a memory buffer,
105	// taking into account endianness.
106	//////////////////////////////////////////////////////////////////////////////////////////
107	// @ offset : first byte of record in buffer.
108	// @ size : record length in bytes (1/2/4).
109	// @ buffer : pointer on buffer base.
110	// @ little endian : the most significant byte has the highest address when true.
111	// @ return the integer value in a 32 bits word.
112	//////////////////////////////////////////////////////////////////////////////////////////
113	static void fatfs_set_record( uint32_t offset,
114	uint32_t size,
115	uint8_t * buffer,
116	uint32_t little_endian,
117	uint32_t value )
118	{
119	uint32_t n;
120
121	if ( little_endian )
122	{
123	for( n = size ; n > 0 ; n-- ) buffer[offset+n-1] = (uint8_t)(value>>((n-1)<<3));
124	}
125	else // big_endian
126	{
127	for( n = 0 ; n < size ; n++ ) buffer[offset+n] = (uint8_t)(value>>((size-1-n)<<3));
128	}
129
130	} // end fatfs_set_record()
131
132	//////////////////////////////////////////////////////////////////////////////////////////
133	// This static function retun in the <name> buffer a short name stored in
134	// a SFN FATFS directory entry.
135	/////////////////////////i////////////////////////////////////////////////////////////////
136	// @ buffer : pointer on buffer containing the directory entry.
137	// @ name : [out] buffer allocated by the caller.
138	//////////////////////////////////////////////////////////////////////////////////////////
139	static void fatfs_get_name_from_short( uint8_t * buffer,
140	char * name )
141	{
142	uint32_t i;
143	uint32_t j = 0;
144
145	// get name
146	for ( i = 0; i < 8 && buffer[i] != ' '; i++ )
147	{
148	name[j] = to_lower( buffer[i] );
149	j++;
150	}
151
152	// get extension
153	for ( i = 8; i < 8 + 3 && buffer[i] != ' '; i++ )
154	{
155	// we entered the loop so there is an extension. add the dot
156	if ( i == 8 )
157	{
158	name[j] = '.';
159	j++;
160	}
161
162	name[j] = to_lower( buffer[i] );
163	j++;
164	}
165
166	name[j] = '\0';
167
168	} // fatfs_get_name_from_short()
169
170	//////////////////////////////////////////////////////////////////////////////////////////
171	// This static function retun in the <name> buffer a partial name stored in
172	// a LFN FATFS directory entry.
173	/////////////////////////i////////////////////////////////////////////////////////////////
174	// @ buffer : pointer on buffer containing the directory entry.
175	// @ name : [out] buffer allocated by the caller.
176	//////////////////////////////////////////////////////////////////////////////////////////
177	static void fatfs_get_name_from_long( uint8_t * buffer,
178	char * name )
179	{
180	uint32_t name_offset = 0;
181	uint32_t buffer_offset = get_length(LDIR_ORD);
182	uint32_t l_name_1 = get_length(LDIR_NAME_1);
183	uint32_t l_name_2 = get_length(LDIR_NAME_2);
184	uint32_t l_name_3 = get_length(LDIR_NAME_3);
185	uint32_t l_attr = get_length(LDIR_ATTR);
186	uint32_t l_type = get_length(LDIR_TYPE);
187	uint32_t l_chksum = get_length(LDIR_CHKSUM);
188	uint32_t l_rsvd = get_length(LDIR_RSVD);
189
190	uint32_t j = 0;
191	uint32_t eof = 0;
192
193	while ( (buffer_offset != DIR_ENTRY_SIZE) && (!eof) )
194	{
195	while (j != l_name_1 && !eof )
196	{
197	if ( (buffer[buffer_offset] == 0x00) \|\|
198	(buffer[buffer_offset] == 0xFF) )
199	{
200	eof = 1;
201	continue;
202	}
203	name[name_offset] = buffer[buffer_offset];
204	buffer_offset += 2;
205	j += 2;
206	name_offset++;
207	}
208
209	buffer_offset += (l_attr + l_type + l_chksum);
210	j = 0;
211
212	while (j != l_name_2 && !eof )
213	{
214	if ( (buffer[buffer_offset] == 0x00) \|\|
215	(buffer[buffer_offset] == 0xFF) )
216	{
217	eof = 1;
218	continue;
219	}
220	name[name_offset] = buffer[buffer_offset];
221	buffer_offset += 2;
222	j += 2;
223	name_offset++;
224	}
225
226	buffer_offset += l_rsvd;
227	j = 0;
228
229	while (j != l_name_3 && !eof )
230	{
231	if ( (buffer[buffer_offset] == 0x00) \|\|
232	(buffer[buffer_offset] == 0xFF) )
233	{
234	eof = 1;
235	continue;
236	}
237	name[name_offset] = buffer[buffer_offset];
238	buffer_offset += 2;
239	j += 2;
240	name_offset++;
241	}
242	}
243	name[name_offset] = 0;
244
245	} // end fatfs_get_name_from_long()
246
247	//////////////////////////////////////////////////////////////////////////////////////////
248	// This static function analyse the <name> input argument, and returns in other
249	// output arguments various informations required to store the name in FATFS directory.
250	// The <name> length cannot be larger than 31 characters :
251	// - Short name (less than 13 characters) require 1 LFN entry.
252	// - Medium names (from 14 to 26 characters require 2 LFN entries.
253	// - Large names (up to 31 characters) require 3 LFN entries.
254	//////////////////////////////////////////////////////////////////////////////////////////
255	// @ name : [in] complete directory entry name.
256	// @ length : [out] total number of characters in name.
257	// @ nb_lfn : [out] number of LFN entries required to store the name.
258	// @ sfn : [out] a legal SFN name extracted from name / upper case and 8-3 format.
259	// @ checksum : [out] checksum to be stored in SFN.
260	// @ returns 0 on success / returns 1 if the name length is larger than 31 characters.
261	//////////////////////////////////////////////////////////////////////////////////////////
262	static error_t fatfs_name_format( const char * name,
263	uint32_t * length,
264	uint32_t * nb_lfn,
265	char * sfn,
266	uint8_t * checksum )
267	{
268	// compute name length
269	uint32_t name_length = strlen( name );
270	*length = name_length;
271
272	uint32_t suffix_length = 0;
273	uint32_t prefix_length = 0;
274	uint32_t dot_found = 0;
275	uint32_t i;
276
277	// compute prefix and suffix length
278	// only the last '.' is taken into account
279	for ( i=0 ; i<name_length ; i++ )
280	{
281	if (name[i] == '.' )
282	{
283	if ( dot_found )
284	{
285	prefix_length += suffix_length + 1;
286	suffix_length = 0;
287	}
288	else
289	{
290	dot_found = 1;
291	}
292	}
293	else
294	{
295	if ( dot_found) suffix_length++;
296	else prefix_length++;
297	}
298	}
299
300	// build SFN prefix (8bits)
301	if (prefix_length <= 8)
302	{
303	for( i=0 ; i<8 ; i++)
304	{
305	if ( i<prefix_length ) sfn[i] = to_upper( name[i] );
306	else sfn[i] = 0x20;
307	}
308	}
309	else
310	{
311	for( i=0 ; i<6 ; i++)
312	{
313	sfn[i] = to_upper( name[i] );
314	}
315	sfn[6] = 0x7E;
316	sfn[7] = 0x31;
317	}
318
319	// build SFN suffix (3 bits)
320	if ( suffix_length == 0 )
321	{
322	sfn[8] = 0x20;
323	sfn[9] = 0x20;
324	sfn[10] = 0x20;
325	}
326	else if ( suffix_length == 1 )
327	{
328	sfn[8] = to_upper( name[name_length-1] );
329	sfn[9] = 0x20;
330	sfn[10] = 0x20;
331	}
332	else if ( suffix_length == 2 )
333	{
334	sfn[8] = to_upper( name[name_length-2] );
335	sfn[9] = to_upper( name[name_length-1] );
336	sfn[10] = 0x20;
337	}
338	else
339	{
340	sfn[8] = to_upper( name[name_length-suffix_length] );
341	sfn[9] = to_upper( name[name_length-suffix_length+1] );
342	sfn[10] = to_upper( name[name_length-suffix_length+2] );
343	}
344
345	// compute 8 bits checksum
346	uint8_t sum = 0;
347	for ( i=0 ; i<11 ; i++ )
348	{
349	sum = (((sum & 0x01)<<7) \| ((sum & 0xFE)>>1)) + sfn[i];
350	}
351	*checksum = sum;
352
353	// set nb_lfn and length values
354	if ( name_length <= 13 )
355	{
356	*nb_lfn = 1;
357	return 0;
358	}
359	else if ( name_length <= 26 )
360	{
361	*nb_lfn = 2;
362	return 0;
363	}
364	else if ( name_length <= 31 )
365	{
366	*nb_lfn = 3;
367	return 0;
368	}
369	else
370	{
371	return 1;
372	}
373	} // end fatfs_name_format()
374
375	//////////////////////////////////////////////////////////////////////////////////////////
376	// This static function - atomically - decrements "free_clusters", and updates
377	// the "free_cluster_hint" shared variables in the FATFS context in the FAT cluster.
378	// It scan the FAT to find the first free slot larger than the <cluster> argument,
379	// and set "free_cluster_hint" <= (free - 1).
380	//
381	// WARNING : The free_lock protecting exclusive access to these variables
382	// must be taken by the calling function.
383	//////////////////////////////////////////////////////////////////////////////////////////
384	// @ cluster : recently allocated cluster index in FAT.
385	//////////////////////////////////////////////////////////////////////////////////////////
386	static error_t fatfs_free_clusters_decrement( uint32_t cluster )
387	{
388	fatfs_ctx_t * loc_ctx; // local pointer on local FATFS context
389	fatfs_ctx_t * fat_ctx; // local pointer on FATFS in cluster containing FAT mapper
390	cxy_t mapper_cxy; // cluster identifier for cluster containing FAT mapper
391	xptr_t mapper_xp; // extended pointer on FAT mapper
392	xptr_t hint_xp; // extended pointer on "free_cluster_hint" shared variable
393	xptr_t numb_xp; // extended pointer on "free_clusters" shared variable
394	uint32_t numb; // "free_clusters" variable current value
395	uint32_t page_id; // page index in FAT mapper
396	uint32_t slot_id; // slot index in one page of FAT (1024 slots per page)
397	uint32_t page_max; // max number of pages in FAT mapper
398	xptr_t page_xp; // extended pointer on current page in FAT mapper
399	xptr_t slot_xp; // extended pointer on current slot in FAT mapper
400
401	#if DEBUG_FATFS_FREE_CLUSTERS
402	uint32_t cycle = (uint32_t)hal_get_cycles();
403	thread_t * this = CURRENT_THREAD;
404	if( DEBUG_FATFS_FREE_CLUSTERS < (uint32_t)hal_get_cycles() )
405	printk("\n[%s] thread[%x,%x] enter for allocated cluster %x / cycle %d\n",
406	__FUNCTION__, this->process->pid, this->trdid, cluster , cycle );
407	#endif
408
409	// get local pointer on local FATFS context
410	loc_ctx = fs_context[FS_TYPE_FATFS].extend;
411
412	// get cluster containing FAT mapper
413	mapper_xp = loc_ctx->fat_mapper_xp;
414	mapper_cxy = GET_CXY( mapper_xp );
415
416	// get local pointer on FATFS context in FAT cluster
417	fat_ctx = hal_remote_lpt( XPTR( mapper_cxy , &fs_context[FS_TYPE_FATFS].extend ) );
418
419	// build extended pointers on free_clusters, and free_cluster_hint
420	hint_xp = XPTR( mapper_cxy , &fat_ctx->free_cluster_hint );
421	numb_xp = XPTR( mapper_cxy , &fat_ctx->free_clusters );
422
423	// update "free_clusters"
424	numb = hal_remote_l32( numb_xp );
425	hal_remote_s32( numb_xp , numb - 1 );
426
427	// scan FAT mapper to find the first free slot > cluster
428	// and update "free_cluster_hint" as (free - 1)
429	page_id = (cluster + 1) >> 10;
430	slot_id = (cluster + 1) & 0x3FF;
431	page_max = (loc_ctx->fat_sectors_count >> 3);
432
433	// scan FAT mapper / loop on pages
434	while ( page_id < page_max )
435	{
436	// get current page from mapper
437	page_xp = mapper_remote_get_page( mapper_xp , page_id );
438
439	if( page_xp == XPTR_NULL )
440	{
441	printk("\n[ERROR] in %s : cannot access FAT mapper\n", __FUNCTION__ );
442	return -1;
443	}
444
445	// scan FAT mapper / loop on slots
446	while ( slot_id < 1024 )
447	{
448	// get extended pointer on current slot
449	slot_xp = ppm_page2base( page_xp ) + (slot_id << 2);
450
451	// test FAT slot value
452	if ( hal_remote_l32( slot_xp ) == FREE_CLUSTER )
453	{
454	// update "free_cluster_hint" <= (free - 1)
455	hal_remote_s32( hint_xp , (page_id << 10) + slot_id - 1 );
456
457	#if DEBUG_FATFS_FREE_CLUSTERS
458	cycle = (uint32_t)hal_get_cycles();
459	if( DEBUG_FATFS_FREE_CLUSTERS < (uint32_t)hal_get_cycles() )
460	printk("\n[%s] thread[%x,%x] exit / hint %x / free_clusters %x / cycle %d\n",
461	__FUNCTION__, this->process->pid, this->trdid,
462	hal_remote_l32(hint_xp), hal_remote_l32(numb_xp), cycle );
463	#endif
464	return 0;
465	}
466
467	// increment slot_id
468	slot_id++;
469
470	} // end loop on slots
471
472	// update loop variables
473	page_id++;
474	slot_id = 0;
475
476	} // end loop on pages
477
478	// return error if no free cluster found
479	printk("\n[ERROR] in %s : No free cluster found\n", __FUNCTION__ );
480	return -1;
481
482	} // end fatfs_free_clusters_decrement()
483
484	//////////////////////////////////////////////////////////////////////////////////////////
485	// This static function atomically increments <free_clusters>, and updates
486	// the <free_cluster_hint> shared variables in the FATFS context in the FAT cluster.
487	// If the released cluster index is smaller than the current (hint + 1) value,
488	// it set "free_cluster_hint" <= cluster - 1.
489	//
490	// WARNING : The free_lock protecting exclusive access to these variables
491	// must be taken by the calling function.
492	//////////////////////////////////////////////////////////////////////////////////////////
493	// @ cluster : recently released cluster index in FAT.
494	//////////////////////////////////////////////////////////////////////////////////////////
495	static void fatfs_free_clusters_increment( uint32_t cluster )
496	{
497	fatfs_ctx_t * loc_ctx; // local pointer on local FATFS context
498	fatfs_ctx_t * fat_ctx; // local pointer on FATFS in cluster containing FAT mapper
499	cxy_t fat_cxy; // cluster identifier for cluster containing FAT mapper
500	xptr_t hint_xp; // extended pointer on "free_cluster_hint" shared variable
501	xptr_t numb_xp; // extended pointer on "free_clusters" shared variable
502	uint32_t hint; // "free_cluster_hint" variable current value
503	uint32_t numb; // "free_clusters" variable current value
504
505	// get local pointer on local FATFS context
506	loc_ctx = fs_context[FS_TYPE_FATFS].extend;
507
508	// get cluster containing FAT mapper
509	fat_cxy = GET_CXY( loc_ctx->fat_mapper_xp );
510
511	// get local pointer on FATFS context in FAT cluster
512	fat_ctx = hal_remote_lpt( XPTR( fat_cxy , &fs_context[FS_TYPE_FATFS].extend ) );
513
514	// build extended pointers free_lock, free_clusters, and free_cluster_hint
515	hint_xp = XPTR( fat_cxy , &fat_ctx->free_cluster_hint );
516	numb_xp = XPTR( fat_cxy , &fat_ctx->free_clusters );
517
518	// get current value of free_cluster_hint and free_clusters
519	hint = hal_remote_l32( hint_xp );
520	numb = hal_remote_l32( numb_xp );
521
522	// update free_cluster_hint if required
523	if ( cluster < (hint + 1) ) hal_remote_s32( hint_xp , (cluster - 1) );
524
525	// update free_clusters
526	hal_remote_s32( numb_xp , numb + 1 );
527
528	#if DEBUG_FATFS_FREE_CLUSTERS
529	thread_t * this = CURRENT_THREAD;
530	if( DEBUG_FATFS_FREE_CLUSTERS < (uint32_t)hal_get_cycles() )
531	printk("\n[%s] thread[%x,%x] updates free cluster info : hint %x / number %x\n",
532	__FUNCTION__, this->process->pid, this->trdid,
533	hal_remote_l32( hint_xp ), hal_remote_l32( numb_xp ) );
534	#endif
535
536	} // end fatfs_free_clusters_increment()
537
538	//////////////////////////////////////////////////////////////////////////////////////////
539	// This recursive function is called by the generic function fatfs_release_all_clusters()
540	// It release all clusters allocated to a given inode in the FAT mapper.
541	// The removal is done in reverse order of the linked list (from last to first).
542	// It does NOT update the FS on the IOC device.
543	//////////////////////////////////////////////////////////////////////////////////////////
544	// @ fat_mapper_xp : extended pointer on FAT mapper.
545	// @ cluster : cluster index in FAT.
546	// @ return 0 if success / return -1 if error (cannot access FAT)
547	//////////////////////////////////////////////////////////////////////////////////////////
548	static error_t fatfs_recursive_release( xptr_t fat_mapper_xp,
549	uint32_t cluster )
550	{
551	uint32_t next;
552
553	// get next cluster from FAT mapper
554	if ( mapper_remote_get_32( fat_mapper_xp , cluster , &next ) ) return -1;
555
556	#if (DEBUG_FATFS_RELEASE_INODE & 1)
557	thread_t * this = CURRENT_THREAD;
558	if ( DEBUG_FATFS_RELEASE_INODE < (uint32_t)hal_get_cycles() )
559	printk("\n[%s] thread[%x,%x] access FAT for cluster %x / next %x\n",
560	__FUNCTION__, this->process->pid, this->trdid, cluster, next );
561	#endif
562
563	if ( next < END_OF_CHAIN_CLUSTER_MIN ) // non terminal case
564	{
565	// call fatfs_recursive_release() on next cluster
566	if ( fatfs_recursive_release( fat_mapper_xp , next ) ) return -1;
567	}
568
569	// update current cluster in FAT mapper
570	if ( mapper_remote_set_32( fat_mapper_xp, cluster , FREE_CLUSTER ) ) return -1;
571
572	// Update free_cluster_hint and free_clusters in FAT context
573	fatfs_free_clusters_increment( cluster );
574
575	return 0;
576
577	} // end fatfs_recursive_release()
578
579
580	//////////////////////////////////////////////////////////////////////////////////////////
581	// FATFS specific extern functions
582	//////////////////////////////////////////////////////////////////////////////////////////
583
584	//////////////////////////////
585	void fatfs_ctx_display( void )
586	{
587	// get pointer on local FATFS context
588	vfs_ctx_t * vfs_ctx = &fs_context[FS_TYPE_FATFS];
589	fatfs_ctx_t * fatfs_ctx = (fatfs_ctx_t *)vfs_ctx->extend;
590
591	printk("\n* FAT context *\n"
592	"- fat_sectors = %d\n"
593	"- sector size = %d\n"
594	"- cluster size = %d\n"
595	"- fat_first_lba = %d\n"
596	"- data_first_lba = %d\n"
597	"- root_dir_cluster = %d\n"
598	"- free_clusters = %d\n"
599	"- free_cluster_hint = %d\n"
600	"- fat_mapper_xp = %l\n",
601	fatfs_ctx->fat_sectors_count,
602	fatfs_ctx->bytes_per_sector,
603	fatfs_ctx->sectors_per_cluster * fatfs_ctx->bytes_per_sector,
604	fatfs_ctx->fat_begin_lba,
605	fatfs_ctx->cluster_begin_lba,
606	fatfs_ctx->root_dir_cluster,
607	fatfs_ctx->free_clusters,
608	fatfs_ctx->free_cluster_hint,
609	fatfs_ctx->fat_mapper_xp );
610
611	} // end fatfs_ctx_display()
612
613	//////////////////////////////////////////
614	void fatfs_display_fat( uint32_t page_id,
615	uint32_t nentries )
616	{
617	uint32_t line;
618	uint32_t maxline;
619
620	// copute numner of lines to display
621	maxline = nentries >> 3;
622	if( nentries & 0x7 ) maxline++;
623
624	// get pointer on local FATFS context
625	vfs_ctx_t * vfs_ctx = &fs_context[FS_TYPE_FATFS];
626	fatfs_ctx_t * fatfs_ctx = (fatfs_ctx_t *)vfs_ctx->extend;
627
628	// get extended pointer on FAT mapper
629	xptr_t fat_mapper_xp = fatfs_ctx->fat_mapper_xp;
630
631	// get extended pointer and cluster of FAT mapper requested page
632	xptr_t page_xp = mapper_remote_get_page( fat_mapper_xp , page_id );
633
634	// get extended pointer on requested page base
635	xptr_t base_xp = ppm_page2base( page_xp );
636
637	printk("\n*** FAT content / page %d ***\n", page_id );
638	for( line = 0 ; line < maxline ; line++ )
639	{
640	printk("%x : %X \| %X \| %X \| %X \| %X \| %X \| %X \| %X\n", (line<<3),
641	hal_remote_l32( base_xp + ((line<<5) ) ),
642	hal_remote_l32( base_xp + ((line<<5) + 4 ) ),
643	hal_remote_l32( base_xp + ((line<<5) + 8 ) ),
644	hal_remote_l32( base_xp + ((line<<5) + 12 ) ),
645	hal_remote_l32( base_xp + ((line<<5) + 16 ) ),
646	hal_remote_l32( base_xp + ((line<<5) + 20 ) ),
647	hal_remote_l32( base_xp + ((line<<5) + 24 ) ),
648	hal_remote_l32( base_xp + ((line<<5) + 28 ) ) );
649	}
650
651	} // end fatfs_display_fat()
652
653	///////////////////////////////////////////////////////
654	error_t fatfs_get_cluster( uint32_t first_cluster_id,
655	uint32_t searched_page_index,
656	uint32_t * searched_cluster_id )
657	{
658	xptr_t current_page_xp; // pointer on current page descriptor
659	uint32_t * buffer; // pointer on current page (array of uint32_t)
660	uint32_t current_page_index; // index of current page in FAT
661	uint32_t current_page_offset; // offset of slot in current page
662	uint32_t page_count_in_file; // index of page in file (index in linked list)
663	uint32_t next_cluster_id; // content of current FAT slot
664
665	assert( (searched_page_index > 0) ,
666	"no FAT access required for first page\n");
667
668	#if DEBUG_FATFS_GET_CLUSTER
669	uint32_t cycle = (uint32_t)hal_get_cycles();
670	thread_t * this = CURRENT_THREAD;
671	if( DEBUG_FATFS_GET_CLUSTER < cycle )
672	printk("\n[%s] thread[%x,%x] enter / first_cluster_id %d / searched_index / cycle %d\n",
673	__FUNCTION__, this->process->pid, this->trdid, first_cluster_id, searched_page_index, cycle );
674	#endif
675
676	// get local pointer on local FATFS context
677	fatfs_ctx_t * ctx = fs_context[FS_TYPE_FATFS].extend;
678
679	// get extended pointer and cluster on FAT mapper
680	xptr_t mapper_xp = ctx->fat_mapper_xp;
681	cxy_t mapper_cxy = GET_CXY( mapper_xp );
682
683	// initialize loop variable (1024 slots per page)
684	current_page_index = first_cluster_id >> 10;
685	current_page_offset = first_cluster_id & 0x3FF;
686	page_count_in_file = 0;
687	next_cluster_id = 0xFFFFFFFF;
688
689	// scan FAT (i.e. traverse FAT linked list)
690	while( page_count_in_file < searched_page_index )
691	{
692	// get pointer on current page descriptor
693	current_page_xp = mapper_remote_get_page( mapper_xp , current_page_index );
694
695	if( current_page_xp == XPTR_NULL )
696	{
697	// TODO
698	return -1;
699	}
700
701	// get pointer on buffer for current page
702	xptr_t base_xp = ppm_page2base( current_page_xp );
703	buffer = (uint32_t *)GET_PTR( base_xp );
704
705	// get FAT slot content
706	next_cluster_id = hal_remote_l32( XPTR( mapper_cxy , &buffer[current_page_offset] ) );
707
708	#if (DEBUG_FATFS_GET_CLUSTER & 1)
709	if( DEBUG_FATFS_GET_CLUSTER < cycle )
710	printk("\n[%s] traverse FAT / current_page_index = %d\n"
711	"current_page_offset = %d / next_cluster_id = %d\n",
712	__FUNCTION__, current_page_index, current_page_offset , next_cluster_id );
713	#endif
714
715	// update loop variables
716	current_page_index = next_cluster_id >> 10;
717	current_page_offset = next_cluster_id & 0x3FF;
718	page_count_in_file++;
719	}
720
721	if( next_cluster_id == 0xFFFFFFFF ) return -1;
722
723	#if DEBUG_FATFS_GET_CLUSTER
724	cycle = (uint32_t)hal_get_cycles();
725	if( DEBUG_FATFS_GET_CLUSTER < cycle )
726	printk("\n[%s] thread[%x,%x] exit / searched_cluster_id = %d / cycle %d\n",
727	__FUNCTION__, this->process->pid, this->trdid, next_cluster_id / cycle );
728	#endif
729
730	*searched_cluster_id = next_cluster_id;
731	return 0;
732
733	} // end fatfs_get_cluster()
734
735
736
737	///////////////////////////////////////////////////////////////////////////////////////
738	// Generic API : the following functions are called by the kernel VFS
739	// and must be defined by all supported file systems.
740	///////////////////////////////////////////////////////////////////////////////////////
741
742	/////////////////////////////////////
743	fatfs_ctx_t * fatfs_ctx_alloc( void )
744	{
745	kmem_req_t req;
746	req.type = KMEM_FATFS_CTX;
747	req.size = sizeof(fatfs_ctx_t);
748	req.flags = AF_KERNEL \| AF_ZERO;
749
750	return (fatfs_ctx_t *)kmem_alloc( &req );
751	}
752
753	//////////////////////////////////////////////
754	void fatfs_ctx_init( fatfs_ctx_t * fatfs_ctx )
755	{
756	error_t error;
757	kmem_req_t req;
758	uint8_t * buffer;
759
760	#if DEBUG_FATFS_CTX_INIT
761	uint32_t cycle = (uint32_t)hal_get_cycles();
762	if( DEBUG_FATFS_CTX_INIT < cycle )
763	printk("\n[%s] thread[%x,%x] enter for fatfs_ctx = %x / cycle %d\n",
764	__FUNCTION__ , this->process->pid, this->trdid, fatfs_ctx , cycle );
765	#endif
766
767	// check argument
768	assert( (fatfs_ctx != NULL) , "pointer on FATFS context is NULL\n" );
769
770	// check only cluster 0 does FATFS init
771	assert( (local_cxy == 0) , "only cluster 0 can initialize FATFS\n");
772
773	// allocate a 512 bytes buffer to store the boot record
774	req.type = KMEM_512_BYTES;
775	req.flags = AF_KERNEL \| AF_ZERO;
776	buffer = (uint8_t *)kmem_alloc( &req );
777
778	if( buffer == NULL )
779	{
780	printk("\n[PANIC] in %s : cannot allocate buffer\n", __FUNCTION__ );
781	hal_core_sleep();
782	}
783
784	// load the BOOT record from device
785	error = dev_ioc_sync_read( buffer , 0 , 1 );
786
787	if ( error )
788	{
789	printk("\n[PANIC] in %s : cannot access boot record\n", __FUNCTION__ );
790	hal_core_sleep();
791	}
792
793	#if (DEBUG_FATFS_CTX_INIT & 0x1)
794	if( DEBUG_FATFS_CTX_INIT < cycle )
795	{
796	uint32_t line;
797	uint32_t byte = 0;
798	printk("\n***** %s : FAT boot record\n", __FUNCTION__ );
799	for ( line = 0 ; line < 32 ; line++ )
800	{
801	printk(" %X \| %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x \|\n",
802	byte,
803	buffer[byte+ 0],buffer[byte+ 1],buffer[byte+ 2],buffer[byte+ 3],
804	buffer[byte+ 4],buffer[byte+ 5],buffer[byte+ 6],buffer[byte+ 7],
805	buffer[byte+ 8],buffer[byte+ 9],buffer[byte+10],buffer[byte+11],
806	buffer[byte+12],buffer[byte+13],buffer[byte+14],buffer[byte+15] );
807
808	byte += 16;
809	}
810	}
811	#endif
812
813	// get sector size from boot record
814	uint32_t sector_size = fatfs_get_record( BPB_BYTSPERSEC , buffer , 1 );
815	if ( sector_size != 512 )
816	{
817	printk("\n[PANIC] in %s : sector size must be 512 bytes\n", __FUNCTION__ );
818	hal_core_sleep();
819	}
820
821	// get cluster size from boot record
822	uint32_t nb_sectors = fatfs_get_record( BPB_SECPERCLUS , buffer , 1 );
823	if ( nb_sectors != 8 )
824	{
825	printk("\n[PANIC] in %s : cluster size must be 8 sectors\n", __FUNCTION__ );
826	hal_core_sleep();
827	}
828
829	// get number of FAT copies from boot record
830	uint32_t nb_fats = fatfs_get_record( BPB_NUMFATS , buffer , 1 );
831	if ( nb_fats != 1 )
832	{
833	printk("\n[PANIC] in %s : number of FAT copies must be 1\n", __FUNCTION__ );
834	hal_core_sleep();
835	}
836
837	// get number of sectors in FAT from boot record
838	uint32_t fat_sectors = fatfs_get_record( BPB_FAT32_FATSZ32 , buffer , 1 );
839	if ( (fat_sectors & 0xF) != 0 )
840	{
841	printk("\n[PANIC] in %s : FAT size not multiple of 16 sectors\n", __FUNCTION__ );
842	hal_core_sleep();
843	}
844
845	// get root cluster from boot record
846	uint32_t root_cluster = fatfs_get_record( BPB_FAT32_ROOTCLUS , buffer , 1 );
847	if ( root_cluster != 2 )
848	{
849	printk("\n[PANIC] in %s : root cluster index must be 2\n", __FUNCTION__ );
850	hal_core_sleep();
851	}
852
853	// get FAT lba from boot record
854	uint32_t fat_lba = fatfs_get_record( BPB_RSVDSECCNT , buffer , 1 );
855
856	// get FS_INFO sector lba from boot record
857	uint32_t fs_info_lba = fatfs_get_record( BPB_FAT32_FSINFO , buffer , 1 );
858
859	// load the FS_INFO record from device
860	error = dev_ioc_sync_read( buffer , fs_info_lba , 1 );
861
862	if ( error )
863	{
864	printk("\n[PANIC] in %s : cannot access FS_INFO record\n", __FUNCTION__ );
865	hal_core_sleep();
866	}
867
868	// get free clusters number from FS_INFO record
869	uint32_t free_clusters = fatfs_get_record( FS_FREE_CLUSTERS , buffer , 1 );
870	if ( free_clusters >= fat_sectors << 7 )
871	{
872	printk("\n[PANIC] in %s : unconsistent free_clusters\n", __FUNCTION__ );
873	hal_core_sleep();
874	}
875
876	// get cluster hint from FS_INFO record
877	uint32_t free_cluster_hint = fatfs_get_record( FS_FREE_CLUSTER_HINT , buffer , 1 );
878	if ( free_cluster_hint >= fat_sectors << 7 )
879	{
880	printk("\n[PANIC] in %s : unconsistent free_cluster_hint\n", __FUNCTION__ );
881	hal_core_sleep();
882	}
883
884	// release the 512 bytes buffer
885	req.type = KMEM_512_BYTES;
886	req.ptr = buffer;
887	kmem_free( &req );
888
889	// allocate a mapper for the FAT itself
890	mapper_t * fat_mapper = mapper_create( FS_TYPE_FATFS );
891	if ( fat_mapper == NULL )
892	{
893	printk("\n[PANIC] in %s : no memory for FAT mapper\n", __FUNCTION__ );
894	hal_core_sleep();
895	}
896
897	// WARNING : the inode field MUST be NULL for the FAT mapper
898	fat_mapper->inode = NULL;
899
900	// initialize the FATFS context
901	fatfs_ctx->fat_begin_lba = fat_lba;
902	fatfs_ctx->fat_sectors_count = fat_sectors;
903	fatfs_ctx->bytes_per_sector = sector_size;
904	fatfs_ctx->sectors_per_cluster = nb_sectors;
905	fatfs_ctx->cluster_begin_lba = fat_lba + fat_sectors;
906	fatfs_ctx->root_dir_cluster = 2;
907	fatfs_ctx->fat_mapper_xp = XPTR( local_cxy , fat_mapper );
908	fatfs_ctx->free_clusters = free_clusters;
909	fatfs_ctx->free_cluster_hint = free_cluster_hint;
910
911	remote_queuelock_init( XPTR( local_cxy , &fatfs_ctx->free_lock ) , LOCK_FATFS_FREE );
912
913	#if DEBUG_FATFS_CTX_INIT
914	cycle = (uint32_t)hal_get_cycles();
915	if( DEBUG_FATFS_CTX_INIT < cycle )
916	printk("\n[%s] thread[%x,%x] exit for fatfs_ctx = %x / cycle %d\n",
917	__FUNCTION__, this->process->pid, this->trdid, fatfs_ctx, cycle );
918	#endif
919
920	} // end fatfs_ctx_init()
921
922	/////////////////////////////////////////////////
923	void fatfs_ctx_destroy( fatfs_ctx_t * fatfs_ctx )
924	{
925	kmem_req_t req;
926	req.type = KMEM_FATFS_CTX;
927	req.ptr = fatfs_ctx;
928	kmem_free( &req );
929	}
930
931	///////////////////////////////////////////////
932	error_t fatfs_add_dentry( vfs_inode_t * inode,
933	vfs_dentry_t * dentry )
934	{
935	error_t error;
936	uint32_t length; // dentry name length
937	uint32_t nb_lfn; // number or required LFN
938	char sfn[11]; // buffer for SFN name
939	uint8_t checksum; // name checksum
940	mapper_t * mapper; // loal pointer on parent inode mapper
941	xptr_t mapper_xp; // extended pointer on parent inode mapper
942	xptr_t child_xp; // extended pointer on child inode
943	cxy_t child_cxy; // child inode cluster
944	vfs_inode_t * child_ptr; // child inode local pointer
945	uint32_t size; // child inode size
946	uint32_t type; // child inode type
947	uint32_t cluster; // child inode cluster index
948
949	#if DEBUG_FATFS_ADD_DENTRY
950	char dir_name[CONFIG_VFS_MAX_NAME_LENGTH];
951	uint32_t cycle = (uint32_t)hal_get_cycles();
952	thread_t * this = CURRENT_THREAD;
953	vfs_inode_get_name( XPTR( local_cxy , inode ) , dir_name );
954	if( DEBUG_FATFS_ADD_DENTRY < cycle )
955	printk("\n[%s] thread[%x,%x] enter / parent <%s> / child <%s> / cycle %d\n",
956	__FUNCTION__, this->process->pid, this->trdid, dir_name, dentry->name, cycle );
957	#endif
958
959	// check arguments
960	assert( (inode != NULL) , "inode pointer is NULL\n" );
961	assert( (dentry != NULL) , "dentry pointer is NULL\n" );
962	assert( (inode->type == INODE_TYPE_DIR) , "inode is not a directory\n" );
963	assert( (inode->mapper != NULL ) , "mapper pointer is NULL\n" );
964
965	// get pointers on directory mapper
966	mapper = inode->mapper;
967	mapper_xp = XPTR( local_cxy , mapper );
968
969	// get extended pointers on remote child inode
970	child_xp = dentry->child_xp;
971	child_cxy = GET_CXY( child_xp );
972	child_ptr = GET_PTR( child_xp );
973
974	// get relevant infos from child inode
975	type = hal_remote_l32( XPTR( child_cxy , &child_ptr->type ) );
976	size = hal_remote_l32( XPTR( child_cxy , &child_ptr->size ) );
977	cluster = (uint32_t)(intptr_t)hal_remote_lpt( XPTR( child_cxy , &child_ptr->extend ) );
978
979	// analyse dentry name
980	error = fatfs_name_format( dentry->name,
981	&length,
982	&nb_lfn,
983	sfn,
984	&checksum );
985	if ( error )
986	{
987	printk("\n[ERROR] in %s : dentry name > 31 bytes\n", __FUNCTION__ );
988	return -1;
989	}
990
991	// Search end of directory with two embedded loops:
992	// - scan the pages in the mapper
993	// - scan the entries in each page to find NO_MORE_ENTRY
994
995	xptr_t page_xp; // extended pointer on page descriptor
996	xptr_t base_xp; // extended pointer on page base
997	uint8_t * base; // local pointer on page base (array of bytes)
998	uint32_t page_id = 0; // page index in mapper
999	uint32_t offset = 0; // position in page
1000	uint32_t found = 0; // NO_MORE_ENTRY found
1001
1002	// loop on pages in mapper
1003	while ( found == 0 )
1004	{
1005	// get extended pointer on page descriptor in mapper
1006	page_xp = mapper_remote_get_page( mapper_xp , page_id );
1007
1008	if ( page_xp == XPTR_NULL )
1009	{
1010	printk("\n[ERROR] in %s : cannot extend directory mapper\n", __FUNCTION__ );
1011	return -1;
1012	}
1013
1014	// get pointer on page base
1015	base_xp = ppm_page2base( page_xp );
1016	base = GET_PTR( base_xp );
1017
1018	// loop on directory entries in this page
1019	while ( (offset < 4096) && (found == 0) )
1020	{
1021	if ( fatfs_get_record( LDIR_ORD, (base + offset), 0 ) == NO_MORE_ENTRY )
1022	{
1023	found = 1;
1024	}
1025	else
1026	{
1027	offset = offset + 32;
1028	}
1029	} // end loop on entries
1030
1031	if ( found == 0 )
1032	{
1033	page_id++;
1034	offset = 0;
1035	}
1036	} // end loop on pages
1037
1038	// Modify the directory mapper: depending on the name length,
1039	// the new child requires to write (3, 4, or 5) directory entries.
1040	// To actually register the new child, we use a 5 steps FSM
1041	// (one state per entry to be written), that is traversed as:
1042	// LFN3 -> LFN2 -> LFN1 -> NORMAL -> NOMORE
1043	// At most two pages are modified:
1044	// - the page containing the NO_MORE_ENTRY is always modified
1045	// - the following page can be modified if the name spread on to pages.
1046
1047	char * name = dentry->name;
1048
1049	uint32_t step; // FSM state
1050
1051	if ( nb_lfn == 1 ) step = 3;
1052	else if ( nb_lfn == 2 ) step = 4;
1053	else if ( nb_lfn == 3 ) step = 5;
1054
1055	uint8_t * entry; // pointer on directory entry to be written
1056	uint32_t i; // byte index in one 32 bytes directory
1057	uint32_t c; // character index in name
1058
1059	while ( step )
1060	{
1061	// when the new child is split on two pages,
1062	// we need to access a new page in mapper
1063	if ( offset >= 4096 )
1064	{
1065	// copy the modified page to IOC device
1066	fatfs_move_page( page_xp , false );
1067
1068	// get the next page in FAT mapper
1069	page_xp = mapper_remote_get_page( mapper_xp , page_id + 1 );
1070
1071	if ( page_xp == XPTR_NULL )
1072	{
1073	printk("\n[ERROR] in %s : cannot extend directory mapper\n", __FUNCTION__ );
1074	return -1;
1075	}
1076
1077	// get pointer on page base
1078	base_xp = ppm_page2base( page_xp );
1079	base = GET_PTR( base_xp );
1080
1081	// update offset
1082	offset = 0;
1083	}
1084
1085	// compute directory entry address
1086	entry = base + offset;
1087
1088	#if (DEBUG_FATFS_ADD_DENTRY & 1)
1089	if( DEBUG_FATFS_ADD_DENTRY < cycle )
1090	printk("\n[%s] FSM step = %d / offset = %x / nb_lfn = %d\n",
1091	__FUNCTION__, step, offset, nb_lfn );
1092	#endif
1093
1094	// write 32 bytes (one directory entry) per iteration
1095	switch ( step )
1096	{
1097	case 5: // write LFN3 entry
1098	{
1099	c = 26;
1100	// scan the 32 bytes in dir_entry
1101	for ( i = 0 ; i < 32 ; i++ )
1102	{
1103	if (i == 0)
1104	{
1105	if ( nb_lfn == 3) entry[i] = 0x43;
1106	else entry[i] = 0x03;
1107	}
1108	else if ( ( ((i >= 1 ) && (i<=10) && ((i&1)==1)) \|\|
1109	((i >= 14) && (i<=25) && ((i&1)==0)) \|\|
1110	((i >= 28) && (i<=31) && ((i&1)==0)) ) &&
1111	( c < length ) )
1112	{
1113	entry[i] = name[c];
1114	c++;
1115	}
1116	else if (i == 11) entry[i] = 0x0F;
1117	else if (i == 13) entry[i] = checksum;
1118	else entry[i] = 0x00;
1119	}
1120	step--;
1121	break;
1122	}
1123	case 4: // write LFN2 entry
1124	{
1125	c = 13;
1126	// scan the 32 bytes in dir_entry
1127	for ( i = 0 ; i < 32 ; i++ )
1128	{
1129	if (i == 0)
1130	{
1131	if ( nb_lfn == 2) entry[i] = 0x42;
1132	else entry[i] = 0x02;
1133	}
1134	else if ( ( ((i >= 1 ) && (i<=10) && ((i&1)==1)) \|\|
1135	((i >= 14) && (i<=25) && ((i&1)==0)) \|\|
1136	((i >= 28) && (i<=31) && ((i&1)==0)) ) &&
1137	( c < length ) )
1138	{
1139	entry[i] = name[c];
1140	c++;
1141	}
1142	else if (i == 11) entry[i] = 0x0F;
1143	else if (i == 13) entry[i] = checksum;
1144	else entry[i] = 0x00;
1145	}
1146	step--;
1147	break;
1148	}
1149	case 3: // Write LFN1 entry
1150	{
1151	c = 0;
1152	// scan the 32 bytes in dir_entry
1153	for ( i = 0 ; i < 32 ; i++ )
1154	{
1155	if (i == 0)
1156	{
1157	if ( nb_lfn == 1) entry[i] = 0x41;
1158	else entry[i] = 0x01;
1159	}
1160	else if ( ( ((i >= 1 ) && (i<=10) && ((i&1)==1)) \|\|
1161	((i >= 14) && (i<=25) && ((i&1)==0)) \|\|
1162	((i >= 28) && (i<=31) && ((i&1)==0)) ) &&
1163	( c < length ) )
1164	{
1165	entry[i] = name[c];
1166	c++;
1167	}
1168	else if (i == 11) entry[i] = 0x0F;
1169	else if (i == 13) entry[i] = checksum;
1170	else entry[i] = 0x00;
1171	}
1172	step--;
1173	break;
1174	}
1175	case 2: // write NORMAL entry
1176	{
1177	// scan the 32 bytes in dir_entry
1178	for ( i = 0 ; i < 32 ; i++ )
1179	{
1180	if ( i < 11 ) // 8.3 SFN
1181	{
1182	entry[i] = sfn[i];
1183	}
1184	else if (i == 11) // ATTR
1185	{
1186	if (type == INODE_TYPE_DIR) entry[i] = 0x10;
1187	else entry[i] = 0x20;
1188	}
1189	else if (i == 20) entry[i] = cluster>>16; // cluster.B2
1190	else if (i == 21) entry[i] = cluster>>24; // cluster.B3
1191	else if (i == 26) entry[i] = cluster>>0; // cluster.B0
1192	else if (i == 27) entry[i] = cluster>>8; // cluster.B1
1193	else if (i == 28) entry[i] = size>>0; // size.B0
1194	else if (i == 29) entry[i] = size>>8; // size.B1
1195	else if (i == 30) entry[i] = size>>16; // size.B2
1196	else if (i == 31) entry[i] = size>>24; // size.B3
1197	else entry[i] = 0x00;
1198	}
1199
1200	// update the "extend" field in dentry descriptor
1201	dentry->extend = (void*)(intptr_t)(((page_id<<12) + offset)>>5);
1202
1203	step--;
1204	break;
1205	}
1206	case 1: // write NOMORE entry
1207	{
1208	entry [0] = 0x00;
1209	step--;
1210	break;
1211	}
1212	} // end switch step
1213
1214	offset += 32;
1215
1216	} // exit while
1217
1218	// copy the modified page to the IOC device
1219	fatfs_move_page( page_xp , false );
1220
1221	#if DEBUG_FATFS_ADD_DENTRY
1222	cycle = (uint32_t)hal_get_cycles();
1223	if( DEBUG_FATFS_ADD_DENTRY < cycle )
1224	printk("\n[%s] thread[%x,%x] exit / parent %s / child %s / cycle %d\n",
1225	__FUNCTION__, this->process->pid, this->trdid, dir_name, dentry->name, cycle );
1226	#endif
1227
1228	return 0;
1229
1230	} // end fatfs_add_dentry()
1231
1232	//////////////////////////////////////////////////
1233	error_t fatfs_remove_dentry( vfs_inode_t * inode,
1234	vfs_dentry_t * dentry )
1235	{
1236	xptr_t mapper_xp; // extended pointer on mapper
1237	mapper_t * mapper; // local pointer on mapper
1238	xptr_t page_xp; // extended pointer on mapper page descriptor
1239	xptr_t base_xp; // extended pointer on mapper page base
1240	uint8_t * base; // local pointer on mapper page base
1241
1242	#if DEBUG_FATFS_REMOVE_DENTRY
1243	char dir_name[CONFIG_VFS_MAX_NAME_LENGTH];
1244	uint32_t cycle = (uint32_t)hal_get_cycles();
1245	thread_t * this = CURRENT_THREAD;
1246	vfs_inode_get_name( XPTR( local_cxy , inode ) , dir_name );
1247	if( DEBUG_FATFS_REMOVE_DENTRY < cycle )
1248	printk("\n[%s] thread[%x,%x] enter / parent <%s> / child <%s> / cycle %d\n",
1249	__FUNCTION__, this->process->pid, this->trdid, dir_name, dentry->name, cycle );
1250	#endif
1251
1252	// check arguments
1253	assert( (inode != NULL) , "inode pointer is NULL\n" );
1254	assert( (dentry != NULL) , "dentry pointer is NULL\n" );
1255	assert( (inode->type == INODE_TYPE_DIR) , "inode is not a directory\n" );
1256	assert( (inode->mapper != NULL ) , "mapper pointer is NULL\n" );
1257
1258	// get pointers on directory mapper
1259	mapper = inode->mapper;
1260	mapper_xp = XPTR( local_cxy , mapper );
1261
1262	// compute number of LFN entries
1263	uint32_t nb_lfn;
1264	uint32_t name_length = strlen( dentry->name );
1265
1266	if ( name_length <= 13 ) nb_lfn = 1;
1267	else if ( name_length <= 26 ) nb_lfn = 2;
1268	else nb_lfn = 3;
1269
1270	// we must invalidate (2, 3 or 4) 32 bytes entries:
1271	// the NORMAL entry (registered in dentry->extend) and all preceding LFN entries
1272	// At most two pages are modified:
1273	// - the page containing the NORMAL entry is always modified.
1274	// - the preceding page is modified when the name spread on two pages.
1275
1276	// get 32 bytes directory entry index from dentry->extend
1277	uint32_t dentry_id = (uint32_t)(intptr_t)dentry->extend;
1278
1279	// get page index and offset in parent directory mapper
1280	uint32_t page_id = dentry_id >> 7;
1281	uint32_t offset = (dentry_id & 0x7F)<<5;
1282
1283	#if DEBUG_FATFS_REMOVE_DENTRY & 1
1284	if( DEBUG_FATFS_REMOVE_DENTRY < cycle )
1285	printk("\n[%s] dentry_id %x / page_id %x / offset %x\n",
1286	__FUNCTION__, dentry_id, page_id, offset );
1287	#endif
1288
1289	// get extended pointer on page descriptor from parent directory mapper
1290	page_xp = mapper_remote_get_page( mapper_xp , page_id );
1291
1292	if ( page_xp == XPTR_NULL )
1293	{
1294	printk("\n[ERROR] in %s : cannot extend directory mapper\n", __FUNCTION__ );
1295	return -1;
1296	}
1297
1298	// get pointers on page base
1299	base_xp = ppm_page2base( page_xp );
1300	base = GET_PTR( base_xp );
1301
1302	// invalidate NORMAL entry in directory cache
1303	base[offset] = 0xE5;
1304
1305	// invalidate LFN entries
1306	while ( nb_lfn )
1307	{
1308	if (offset == 0) // we must load page (page_id - 1)
1309	{
1310
1311	// check page_id
1312	assert( (page_id > 0), "page_id and offset cannot be both 0\n" );
1313
1314	// copy the modified page to the IOC device
1315	fatfs_move_page( page_xp , false );
1316
1317	// get extended pointer on page descriptor from parent directory mapper
1318	page_xp = mapper_remote_get_page( mapper_xp , page_id );
1319
1320	if ( page_xp == XPTR_NULL )
1321	{
1322	printk("\n[ERROR] in %s : cannot access directory mapper\n", __FUNCTION__ );
1323	return -1;
1324	}
1325
1326	// get pointers on page base
1327	base_xp = ppm_page2base( page_xp );
1328	base = GET_PTR( base_xp );
1329
1330	// update offset
1331	offset = 4096;
1332	}
1333
1334	offset = offset - 32;
1335
1336	// check for LFN entry
1337	assert( (fatfs_get_record( DIR_ATTR, base + offset, 0 ) == ATTR_LONG_NAME_MASK ),
1338	"this directory entry must be a LFN\n");
1339
1340	// invalidate LFN entry
1341	base[offset] = 0xE5;
1342
1343	nb_lfn--;
1344	}
1345
1346	// copy the modified page to the IOC device
1347	fatfs_move_page( page_xp , false );
1348
1349
1350	#if DEBUG_FATFS_REMOVE_DENTRY
1351	cycle = (uint32_t)hal_get_cycles();
1352	if( DEBUG_FATFS_REMOVE_DENTRY < cycle )
1353	printk("\n[%s] thread[%x,%x] exit / parent %s / child %s / cycle %d\n",
1354	__FUNCTION__, this->process->pid, this->trdid, dir_name, dentry->name, cycle );
1355	#endif
1356
1357	return 0;
1358
1359	} // end fatfs_remove_dentry
1360
1361	/////////////////////////////////////////////////////
1362	error_t fatfs_get_dentry( vfs_inode_t * parent_inode,
1363	char * name,
1364	xptr_t child_inode_xp )
1365	{
1366	// Two embedded loops to scan the directory mapper:
1367	// - scan the parent directory mapper pages
1368	// - scan the directory entries in each 4 Kbytes page
1369
1370	#if DEBUG_FATFS_GET_DENTRY
1371	char parent_name[CONFIG_VFS_MAX_NAME_LENGTH];
1372	uint32_t cycle = (uint32_t)hal_get_cycles();
1373	thread_t * this = CURRENT_THREAD;
1374	vfs_inode_get_name( XPTR( local_cxy , parent_inode ) , parent_name );
1375	if( DEBUG_FATFS_GET_DENTRY < cycle )
1376	printk("\n[%s] thread[%x,%x] enter for child <%s> in parent <%s> / cycle %d\n",
1377	__FUNCTION__, this->process->pid, this->trdid, name , parent_name , cycle );
1378	#endif
1379
1380	// check parent_inode and child_inode
1381	assert( (parent_inode != NULL) , "parent_inode is NULL\n" );
1382	assert( (child_inode_xp != XPTR_NULL ) , "child_inode is XPTR_NULL\n" );
1383
1384	mapper_t * mapper = parent_inode->mapper;
1385	xptr_t mapper_xp = XPTR( local_cxy , mapper );
1386
1387	// check parent mapper
1388	assert( (mapper != NULL) , "parent mapper is NULL\n");
1389
1390	char cname[CONFIG_VFS_MAX_NAME_LENGTH]; // name extracter from each directory entry
1391
1392	char lfn1[16]; // buffer for one partial cname
1393	char lfn2[16]; // buffer for one partial cname
1394	char lfn3[16]; // buffer for one partial cname
1395	xptr_t page_xp; // extended pointer on page descriptor
1396	xptr_t base_xp; // extended pointer on page base
1397	uint8_t * base; // local pointer on page base
1398	uint32_t attr; // directory entry ATTR field
1399	uint32_t ord; // directory entry ORD field
1400	uint32_t seq; // sequence index
1401	uint32_t lfn = 0; // LFN entries number
1402	uint32_t size = 0; // searched file/dir size (bytes)
1403	uint32_t cluster = 0; // searched file/dir cluster index
1404	uint32_t is_dir = 0; // searched file/dir type
1405	int32_t found = 0; // not found (0) / name found (1) / end of dir (-1)
1406	uint32_t page_id = 0; // page index in mapper
1407	uint32_t dentry_id = 0; // directory entry index
1408	uint32_t offset = 0; // byte offset in page
1409
1410	// scan the parent directory mapper
1411	while ( found == 0 )
1412	{
1413	// get one page
1414	page_xp = mapper_remote_get_page( mapper_xp , page_id );
1415
1416	if( page_xp == XPTR_NULL) return EIO;
1417
1418	// get page base
1419	base_xp = ppm_page2base( page_xp );
1420	base = (uint8_t *)GET_PTR( base_xp );
1421
1422	#if (DEBUG_FATFS_GET_DENTRY & 0x1)
1423	if( DEBUG_FATFS_GET_DENTRY < cycle )
1424	mapper_display_page( mapper_xp , page_id , 256 , parent_name );
1425	#endif
1426	// scan this page until end of directory, end of page, or name found
1427	while( (offset < 4096) && (found == 0) )
1428	{
1429	attr = fatfs_get_record( DIR_ATTR , base + offset , 0 );
1430	ord = fatfs_get_record( LDIR_ORD , base + offset , 0 );
1431
1432	if (ord == NO_MORE_ENTRY) // no more entry => break
1433	{
1434	found = -1;
1435	}
1436	else if ( ord == FREE_ENTRY ) // free entry => skip
1437	{
1438	offset = offset + 32;
1439	}
1440	else if ( attr == ATTR_LONG_NAME_MASK ) // LFN entry => get partial cname
1441	{
1442	seq = ord & 0x3;
1443	lfn = (seq > lfn) ? seq : lfn;
1444	if ( seq == 1 ) fatfs_get_name_from_long( base + offset, lfn1 );
1445	else if ( seq == 2 ) fatfs_get_name_from_long( base + offset, lfn2 );
1446	else if ( seq == 3 ) fatfs_get_name_from_long( base + offset, lfn3 );
1447	offset = offset + 32;
1448	}
1449	else // NORMAL entry
1450	{
1451	// build the extracted name
1452	if ( lfn == 0 )
1453	{
1454	fatfs_get_name_from_short( base + offset , cname );
1455	}
1456	else if ( lfn == 1 )
1457	{
1458	strcpy( cname , lfn1 );
1459	}
1460	else if ( lfn == 2 )
1461	{
1462	strcpy( cname , lfn1 );
1463	strcpy( cname + 13 , lfn2 );
1464	}
1465	else if ( lfn == 3 )
1466	{
1467	strcpy( cname , lfn1 );
1468	strcpy( cname + 13 , lfn2 );
1469	strcpy( cname + 26 , lfn3 );
1470	}
1471
1472	// get dentry arguments if extracted cname == searched name
1473	if ( strcmp( name , cname ) == 0 )
1474	{
1475	cluster = (fatfs_get_record( DIR_FST_CLUS_HI , base + offset , 1 ) << 16) \|
1476	(fatfs_get_record( DIR_FST_CLUS_LO , base + offset , 1 ) ) ;
1477	dentry_id = ((page_id<<12) + offset)>>5;
1478	is_dir = ((attr & ATTR_DIRECTORY) == ATTR_DIRECTORY);
1479	size = fatfs_get_record( DIR_FILE_SIZE , base + offset , 1 );
1480	found = 1;
1481	}
1482	offset = offset + 32;
1483	lfn = 0;
1484	}
1485	} // end loop on directory entries in page
1486
1487	page_id++;
1488	offset = 0;
1489
1490	} // end loop on pages
1491
1492	// analyse the result of scan
1493
1494	if ( found == -1 ) // found end of directory => failure
1495	{
1496
1497	#if DEBUG_FATFS_GET_DENTRY
1498	cycle = (uint32_t)hal_get_cycles();
1499	if( DEBUG_FATFS_GET_DENTRY < cycle )
1500	printk("\n[%s] thread[%x,%x] exit / child <%s> not found / cycle %d\n",
1501	__FUNCTION__, this->process->pid, this->trdid, name, cycle );
1502	#endif
1503
1504	return -1;
1505	}
1506
1507	// get child inode cluster and local pointer
1508	cxy_t inode_cxy = GET_CXY( child_inode_xp );
1509	vfs_inode_t * inode_ptr = GET_PTR( child_inode_xp );
1510
1511	// build extended pointer on parent dentried root
1512	xptr_t parents_root_xp = XPTR( inode_cxy , &inode_ptr->parents );
1513
1514	// check child inode has at least one parent
1515	assert( (xlist_is_empty( parents_root_xp ) == false ), "child inode must have one parent\n");
1516
1517	// get dentry pointers and cluster
1518	xptr_t dentry_xp = XLIST_FIRST( parents_root_xp , vfs_dentry_t , parents );
1519	vfs_dentry_t * dentry_ptr = GET_PTR( dentry_xp );
1520	cxy_t dentry_cxy = GET_CXY( dentry_xp );
1521
1522	// check dentry descriptor in same cluster as parent inode
1523	assert( (dentry_cxy == local_cxy) , "illegal dentry cluster\n" );
1524
1525	// update the child inode "type", "size", and "extend" fields
1526	vfs_inode_type_t type = (is_dir) ? INODE_TYPE_DIR : INODE_TYPE_FILE;
1527
1528	hal_remote_s32( XPTR( inode_cxy , &inode_ptr->type ) , type );
1529	hal_remote_s32( XPTR( inode_cxy , &inode_ptr->size ) , size );
1530	hal_remote_s32( XPTR( inode_cxy , &inode_ptr->extend ) , cluster );
1531
1532	// update the dentry "extend" field
1533	dentry_ptr->extend = (void *)(intptr_t)dentry_id;
1534
1535	#if DEBUG_FATFS_GET_DENTRY
1536	cycle = (uint32_t)hal_get_cycles();
1537	if( DEBUG_FATFS_GET_DENTRY < cycle )
1538	printk("\n[%s] thread[%x,%x] exit / child <%s> loaded in <%s> / cycle %d\n",
1539	__FUNCTION__, this->process->pid, this->trdid, name, parent_name, cycle );
1540	#endif
1541
1542	return 0;
1543
1544	} // end fatfs_get_dentry()
1545
1546	///////////////////////////////////////////////////////
1547	error_t fatfs_get_user_dir( struct vfs_inode_s * inode,
1548	struct dirent * array,
1549	uint32_t max_dirent,
1550	uint32_t min_dentry,
1551	bool_t detailed,
1552	uint32_t * entries,
1553	bool_t * done )
1554	{
1555	// Two embedded loops to scan the directory mapper:
1556	// - scan the parent directory mapper pages starting always from page 0
1557	// - scan the 32 bytes NORMAL/LFN directory entries in each page
1558	// Only valid dentries are copied : dentry_id >= min_dentry && dirent_id < dirent_max
1559
1560	#if DEBUG_FATFS_GET_USER_DIR
1561	char inode_name[CONFIG_VFS_MAX_NAME_LENGTH];
1562	uint32_t cycle = (uint32_t)hal_get_cycles();
1563	thread_t * this = CURRENT_THREAD;
1564	vfs_inode_get_name( XPTR( local_cxy , inode ) , inode_name );
1565	if( DEBUG_FATFS_GET_USER_DIR < cycle )
1566	printk("\n[%s] thread[%x,%x] enter for inode <%s> / cycle %d\n",
1567	__FUNCTION__, this->process->pid, this->trdid, inode_name , cycle );
1568	#endif
1569
1570	mapper_t * mapper = inode->mapper;
1571	xptr_t mapper_xp = XPTR( local_cxy , mapper );
1572
1573	// check mapper pointer
1574	assert( (mapper != NULL) , "mapper is NULL\n");
1575
1576	// TODO handle the detailed flag
1577	assert( (detailed == false), "detailed argument not supported/n");
1578
1579	char cname[CONFIG_VFS_MAX_NAME_LENGTH]; // name extracter from each directory entry
1580
1581	char lfn1[16]; // buffer for one partial cname
1582	char lfn2[16]; // buffer for one partial cname
1583	char lfn3[16]; // buffer for one partial cname
1584	xptr_t page_xp; // extended pointer on page descriptor
1585	xptr_t base_xp; // extended pointer on page base
1586	uint8_t * base; // local pointer on page base
1587	uint32_t attr; // directory entry ATTR field
1588	uint32_t ord; // directory entry ORD field
1589	uint32_t seq; // sequence index
1590	uint32_t lfn = 0; // LFN entries number
1591	uint32_t offset = 0; // byte offset in page
1592	uint32_t page_id = 0; // page index in mapper
1593	uint32_t dentry_id = 0; // valid (i.e. copied) dentry index in mapper
1594	uint32_t dirent_id = 0; // slot index in dirent array to initialize
1595	bool_t end = false; // true if end of directory found
1596
1597	// loop on mapper pages
1598	while ( (end == false) && (dirent_id < max_dirent) )
1599	{
1600	// get one page from mapper
1601	page_xp = mapper_remote_get_page( mapper_xp , page_id );
1602
1603	if( page_xp == XPTR_NULL) return -1;
1604
1605	// get page base
1606	base_xp = ppm_page2base( page_xp );
1607	base = (uint8_t *)GET_PTR( base_xp );
1608
1609	#if (DEBUG_FATFS_GET_USER_DIR & 0x1)
1610	if( DEBUG_FATFS_GET_USER_DIR < cycle )
1611	mapper_display_page( mapper_xp , page_id , 256 , inode_name );
1612	#endif
1613	// loop on NORMAL/LFN (32 bytes) directory entries in this page
1614	while( (end == false) && (offset < 4096) )
1615	{
1616	// compute condition to copy one dentry to dirent array
1617	bool_t valid = (dentry_id >= min_dentry) && (dirent_id < max_dirent );
1618
1619	attr = fatfs_get_record( DIR_ATTR , base + offset , 0 );
1620	ord = fatfs_get_record( LDIR_ORD , base + offset , 0 );
1621
1622	if (ord == NO_MORE_ENTRY) // no more entry => break
1623	{
1624	end = true;
1625	}
1626	else if ( ord == FREE_ENTRY ) // free entry => skip
1627	{
1628	offset = offset + 32;
1629	}
1630	else if ( attr == ATTR_LONG_NAME_MASK ) // LFN entry
1631	{
1632	if( valid )
1633	{
1634	// get partial cname
1635	seq = ord & 0x3;
1636	lfn = (seq > lfn) ? seq : lfn;
1637	if ( seq == 1 ) fatfs_get_name_from_long( base + offset, lfn1 );
1638	else if ( seq == 2 ) fatfs_get_name_from_long( base + offset, lfn2 );
1639	else if ( seq == 3 ) fatfs_get_name_from_long( base + offset, lfn3 );
1640	}
1641	offset = offset + 32;
1642	}
1643	else // NORMAL entry
1644	{
1645	// increment dentry_id
1646	dentry_id++;
1647
1648	if( valid )
1649	{
1650	// build the complete cname
1651	if ( lfn == 0 )
1652	{
1653	fatfs_get_name_from_short( base + offset , cname );
1654	}
1655	else if ( lfn == 1 )
1656	{
1657	strcpy( cname , lfn1 );
1658	}
1659	else if ( lfn == 2 )
1660	{
1661	strcpy( cname , lfn1 );
1662	strcpy( cname + 13 , lfn2 );
1663	}
1664	else if ( lfn == 3 )
1665	{
1666	strcpy( cname , lfn1 );
1667	strcpy( cname + 13 , lfn2 );
1668	strcpy( cname + 26 , lfn3 );
1669	}
1670
1671	// copy cname into dirent array
1672	strcpy( array[dirent_id].d_name , cname );
1673
1674	// increment dirent_id
1675	dirent_id++;
1676	}
1677	offset = offset + 32;
1678	lfn = 0;
1679	}
1680	} // end loop on directory entries in page
1681
1682	page_id++;
1683	offset = 0;
1684
1685	} // end loop on pages
1686
1687	// return result of scan
1688	*done = end;
1689	*entries = dirent_id;
1690
1691	#if DEBUG_FATFS_GET_USER_DIR
1692	cycle = (uint32_t)hal_get_cycles();
1693	if( DEBUG_FATFS_GET_USER_DIR < cycle )
1694	printk("\n[%s] thread[%x,%x] exit for inode <%s> / %d entries / cycle %d\n",
1695	__FUNCTION__, this->process->pid, this->trdid, inode_name, entries, cycle );
1696	#endif
1697
1698	return 0;
1699
1700	} // end fatfs_get_user_dir()
1701
1702	///////////////////////////////////////////////
1703	error_t fatfs_sync_inode( vfs_inode_t * inode )
1704	{
1705
1706	// check inode pointer and cluster index
1707	assert( (inode != NULL) , "inode pointer undefined\n" );
1708	assert( (inode->mapper != NULL ) , "mapper pointer undefined\n" );
1709	assert( (inode->type == INODE_TYPE_FILE) , "inode must be a file\n" );
1710
1711	#if DEBUG_FATFS_SYNC_INODE
1712	char name[CONFIG_VFS_MAX_NAME_LENGTH];
1713	uint32_t cycle = (uint32_t)hal_get_cycles();
1714	thread_t * this = CURRENT_THREAD;
1715	vfs_inode_get_name( XPTR( local_cxy , inode ) , name );
1716	if( DEBUG_FATFS_SYNC_INODE < cycle )
1717	printk("\n[%s] thread[%x,%x] enter for <%s> / cycle %d\n",
1718	__FUNCTION__ , this->process->pid, this->trdid, name, cycle );
1719	#endif
1720
1721	error_t error;
1722	mapper_t * mapper;
1723	page_t * page;
1724	uint32_t page_id;
1725
1726	// get mapper from inode
1727	mapper = inode->mapper;
1728
1729	// compute max number of pages in mapper from file size
1730	uint32_t size = inode->size;
1731	uint32_t pages = size >> CONFIG_PPM_PAGE_SHIFT;
1732	if( size & CONFIG_PPM_PAGE_MASK ) pages++;
1733
1734	// get pointer on mapper radix tree
1735	grdxt_t * rt = &mapper->rt;
1736
1737	// scan all pages
1738	for( page_id = 0 ; page_id < pages ; page_id++ )
1739	{
1740	// get page descriptor from mapper
1741	page = grdxt_lookup( rt , page_id );
1742
1743	// check all existing pages
1744	if ( page != NULL )
1745	{
1746	if ( page->flags & PG_DIRTY )
1747	{
1748
1749	#if (DEBUG_FATFS_SYNC_INODE & 1)
1750	if( DEBUG_FATFS_SYNC_INODE < cycle )
1751	printk("\n[%s] thread[%x,%x] synchronizes page %d from <%s> mapper to IOC device\n",
1752	__FUNCTION__, page_id, name );
1753	#endif
1754	// build extended pointer on page descriptor
1755	xptr_t page_xp = XPTR( local_cxy , page );
1756
1757	// move page from mapper to device
1758	error = fatfs_move_page( page_xp , false );
1759
1760	if ( error ) return -1;
1761
1762	// reset page dirty flag
1763	ppm_page_undo_dirty( page_xp );
1764	}
1765	}
1766	} // end loop on pages
1767
1768	#if DEBUG_FATFS_SYNC_INODE
1769	cycle = (uint32_t)hal_get_cycles();
1770	if( DEBUG_FATFS_SYNC_INODE < cycle )
1771	printk("\n[%s] thread[%x,%x] exit for <%s> / cycle %d\n",
1772	__FUNCTION__ , this->process->pid, this->trdid, name, cycle );
1773	#endif
1774
1775	return 0;
1776
1777	} // end fatfs_sync_inode()
1778
1779	//////////////////////////////
1780	error_t fatfs_sync_fat( void )
1781	{
1782
1783	#if DEBUG_FATFS_SYNC_FAT
1784	uint32_t cycle = (uint32_t)hal_get_cycles();
1785	thread_t * this = CURRENT_THREAD;
1786	if( DEBUG_FATFS_SYNC_FAT < cycle )
1787	printk("\n[%s] thread[%x,%x] enter / cycle %d\n",
1788	__FUNCTION__ , this->process->pid, this->trdid, cycle );
1789	#endif
1790
1791	uint32_t page_id;
1792	error_t error;
1793
1794	// get FAT mapper pointers an cluster
1795	fatfs_ctx_t * fatfs_ctx = fs_context[FS_TYPE_FATFS].extend;
1796	xptr_t mapper_xp = fatfs_ctx->fat_mapper_xp;
1797	cxy_t mapper_cxy = GET_CXY( mapper_xp );
1798	mapper_t * mapper_ptr = GET_PTR( mapper_xp );
1799
1800	// compute max number of 4 Kbytes pages in FAT mapper
1801	// TODO : this could be improved (see fatfs.h) [AG]
1802	uint32_t pages = fatfs_ctx->fat_sectors_count >> 3;
1803
1804	// get pointers on remote FAT mapper radix tree
1805	grdxt_t * rt_ptr = &mapper_ptr->rt;
1806	xptr_t rt_xp = XPTR( mapper_cxy , rt_ptr );
1807
1808	// scan all pages
1809	for( page_id = 0 ; page_id < pages ; page_id++ )
1810	{
1811	// get extended pointer on page descriptor from FAT mapper
1812	xptr_t page_xp = grdxt_remote_lookup( rt_xp , page_id );
1813
1814	// check all existing pages
1815	if ( page_xp != XPTR_NULL )
1816	{
1817	page_t * page_ptr = GET_PTR( page_xp );
1818	uint32_t flags = hal_remote_l32( XPTR( mapper_cxy , &page_ptr->flags ) );
1819
1820	if ( flags & PG_DIRTY )
1821	{
1822
1823	#if (DEBUG_FATFS_SYNC_FAT & 1)
1824	if( DEBUG_FATFS_SYNC_FAT < cycle )
1825	printk("\n[%s] thread[%x,%x] synchronizes page %d from FAT mapper to IOC device\n",
1826	__FUNCTION__, page_id );
1827	#endif
1828	// move page from mapper to device
1829	error = fatfs_move_page( page_xp , false );
1830
1831	if ( error ) return -1;
1832
1833	// reset page dirty flag
1834	ppm_page_undo_dirty( page_xp );
1835	}
1836	}
1837	} // end loop on pages
1838
1839	#if DEBUG_FATFS_SYNC_FAT
1840	cycle = (uint32_t)hal_get_cycles();
1841	if( DEBUG_FATFS_SYNC_FAT < cycle )
1842	printk("\n[%s] thread[%x,%x] exit / cycle %d\n",
1843	__FUNCTION__ , this->process->pid, this->trdid, cycle );
1844	#endif
1845
1846	return 0;
1847
1848	} // end fatfs_sync_fat()
1849
1850	////////////////////////////////////
1851	error_t fatfs_sync_free_info( void )
1852	{
1853
1854	#if DEBUG_FATFS_SYNC_FSINFO
1855	uint32_t cycle = (uint32_t)hal_get_cycles();
1856	thread_t * this = CURRENT_THREAD;
1857	if( DEBUG_FATFS_SYNC_FSINFO < cycle )
1858	printk("\n[%s] thread[%x,%x] enter / cycle %d\n",
1859	__FUNCTION__ , this->process->pid, this->trdid, cycle );
1860	#endif
1861
1862	uint8_t * buffer; // dynamically allocated aligned 512 bytes buffer
1863	kmem_req_t req;
1864	error_t error;
1865
1866	// get FS_INFO lba, free_ from FATFS context
1867	fatfs_ctx_t * fatfs_ctx = fs_context[FS_TYPE_FATFS].extend;
1868	uint32_t lba = fatfs_ctx->fs_info_lba;
1869	uint32_t hint = fatfs_ctx->free_cluster_hint;
1870	uint32_t number = fatfs_ctx->free_clusters;
1871
1872	// allocate buffer to store the FS_INFO sector
1873	req.type = KMEM_512_BYTES;
1874	req.flags = AF_KERNEL \| AF_ZERO;
1875	buffer = (uint8_t *)kmem_alloc( &req );
1876	if( buffer == NULL )
1877	{
1878	printk("\n[PANIC] in %s : cannot allocate buffer\n", __FUNCTION__ );
1879	return ENOMEM;
1880	}
1881
1882	// load the FS_INFO sector from device to buffer
1883	error = dev_ioc_read( buffer , lba , 1 );
1884	if ( error )
1885	{
1886	printk("\n[PANIC] in %s : cannot read FS_INFO record\n", __FUNCTION__ );
1887	return EIO;
1888	}
1889
1890	// update buffer
1891	fatfs_set_record( FS_FREE_CLUSTERS , buffer , 1 , number );
1892	fatfs_set_record( FS_FREE_CLUSTER_HINT , buffer , 1 , hint );
1893
1894	// write modified FS_INFO sector from buffer to device
1895	error = dev_ioc_write( buffer , lba , 1 );
1896	if ( error )
1897	{
1898	printk("\n[PANIC] in %s : cannot write FS_INFO record\n", __FUNCTION__ );
1899	return EIO;
1900	}
1901
1902	// release the 512 bytes buffer
1903	req.type = KMEM_512_BYTES;
1904	req.ptr = buffer;
1905	kmem_free( &req );
1906
1907	#if DEBUG_FATFS_SYNC_FSINFO
1908	cycle = (uint32_t)hal_get_cycles();
1909	if( DEBUG_FATFS_SYNC_FSINFO < cycle )
1910	printk("\n[%s] thread[%x,%x] exit / cycle %d\n",
1911	__FUNCTION__ , this->process->pid, this->trdid, cycle );
1912	#endif
1913
1914	return 0;
1915
1916	} // end fatfs_sync_fs_info()
1917
1918	//////////////////////////////////////////////////////////
1919	error_t fatfs_cluster_alloc( uint32_t * searched_cluster )
1920	{
1921	uint32_t page_id; // page index in mapper
1922	uint32_t slot_id; // slot index in page (1024 slots per page)
1923	uint32_t hint; // first free cluster index in FAT
1924	uint32_t free_clusters; // total number of free clusters
1925	vfs_ctx_t * vfs_ctx; // local pointer on VFS context (same in all clusters)
1926	fatfs_ctx_t * loc_fatfs_ctx; // local pointer on local FATFS context
1927	fatfs_ctx_t * fat_fatfs_ctx; // local pointer on FATFS context in FAT cluster
1928	xptr_t mapper_xp; // extended pointer on FAT mapper
1929	cxy_t mapper_cxy; // Fat mapper cluster identifier
1930	xptr_t page_xp; // extended pointer on current page descriptor in mapper
1931	xptr_t slot_xp; // extended pointer on FAT slot defined by hint
1932	xptr_t lock_xp; // extended pointer on lock protecting free clusters info
1933	xptr_t hint_xp; // extended pointer on free_cluster_hint in FAT cluster
1934	xptr_t numb_xp; // extended pointer on free_clusters_number in FAT cluster
1935
1936	#if DEBUG_FATFS_CLUSTER_ALLOC
1937	uint32_t cycle = (uint32_t)hal_get_cycles();
1938	thread_t * this = CURRENT_THREAD;
1939	if( DEBUG_FATFS_CLUSTER_ALLOC < cycle )
1940	printk("\n[%s] thread[%x,%x] enter / cycle = %d\n",
1941	__FUNCTION__, this->process->pid, this->trdid, cycle );
1942	#endif
1943
1944	// get local pointer on VFS context (same in all clusters)
1945	vfs_ctx = &fs_context[FS_TYPE_FATFS];
1946
1947	// get local pointer on local FATFS context
1948	loc_fatfs_ctx = vfs_ctx->extend;
1949
1950	// get extended pointer and cluster on FAT mapper
1951	mapper_xp = loc_fatfs_ctx->fat_mapper_xp;
1952	mapper_cxy = GET_CXY( mapper_xp );
1953
1954	// get local pointer on FATFS context in FAT cluster
1955	fat_fatfs_ctx = hal_remote_lpt( XPTR( mapper_cxy , &vfs_ctx->extend ) );
1956
1957	// build relevant extended pointers in on free clusters info in FAT cluster
1958	lock_xp = XPTR( mapper_cxy , &fat_fatfs_ctx->free_lock );
1959	hint_xp = XPTR( mapper_cxy , &fat_fatfs_ctx->free_cluster_hint );
1960	numb_xp = XPTR( mapper_cxy , &fat_fatfs_ctx->free_clusters );
1961
1962	// take the lock protecting free clusters
1963	remote_queuelock_acquire( lock_xp );
1964
1965	// get hint and free_clusters values from FATFS context
1966	hint = hal_remote_l32( hint_xp );
1967	free_clusters = hal_remote_l32( numb_xp );
1968
1969	// get page index & slot index for the first free cluster
1970	page_id = (hint + 1) >> 10;
1971	slot_id = (hint + 1) & 0x3FF;
1972
1973	// get relevant page from mapper
1974	page_xp = mapper_remote_get_page( mapper_xp , page_id );
1975
1976	if( page_xp == XPTR_NULL )
1977	{
1978	printk("\n[ERROR] in %s : cannot acces FAT mapper\n", __FUNCTION__ );
1979	return -1;
1980	}
1981
1982	// build extended pointer on free cluster slot
1983	slot_xp = ppm_page2base( page_xp ) + (slot_id<<2);
1984
1985	#if (DEBUG_FATFS_CLUSTER_ALLOC & 1)
1986	if( DEBUG_FATFS_CLUSTER_ALLOC < cycle )
1987	printk("\n[%s] thread[%x,%x] get free info / hint %x / free_clusters %x\n",
1988	__FUNCTION__, this->process->pid, this->trdid, hint, free_clusters );
1989	#endif
1990
1991	// check "free_clusters"
1992	if ( free_clusters == 0 )
1993	{
1994	printk("\n[ERROR] in %s : no more free FATFS clusters\n", __FUNCTION__ );
1995	remote_queuelock_acquire( lock_xp );
1996	return -1;
1997	}
1998	else if ( free_clusters < CONFIG_VFS_FREE_CLUSTERS_MIN )
1999	{
2000	printk("\n[WARNING] in %s : only %n free FATFS clusters\n",
2001	__FUNCTION__, CONFIG_VFS_FREE_CLUSTERS_MIN );
2002	}
2003
2004	// check "hint"
2005	if( hal_remote_l32( slot_xp ) != FREE_CLUSTER )
2006	{
2007	printk("\n[ERROR] in %s : illegal hint cluster\n", __FUNCTION__ );
2008	remote_queuelock_acquire( lock_xp );
2009	return -1;
2010	}
2011
2012	// update allocated cluster in FAT mapper
2013	hal_remote_s32( slot_xp , END_OF_CHAIN_CLUSTER_MAX );
2014
2015	// update free cluster info
2016	fatfs_free_clusters_decrement( hint + 1 );
2017
2018	// release free clusters busylock
2019	remote_queuelock_release( lock_xp );
2020
2021	#if DEBUG_FATFS_CLUSTER_ALLOC
2022	cycle = (uint32_t)hal_get_cycles();
2023	if( DEBUG_FATFS_CLUSTER_ALLOC < cycle )
2024	printk("\n[%s] thread[%x,%x] exit / cluster %x / cycle %d\n",
2025	__FUNCTION__, this->process->pid, this->trdid, hint + 1, cycle );
2026	#endif
2027
2028	*searched_cluster = hint + 1;
2029	return 0;
2030
2031	} // end fat_cluster_alloc()
2032
2033	//////////////////////////////////////////////
2034	error_t fatfs_release_inode( xptr_t inode_xp )
2035	{
2036	vfs_ctx_t * vfs_ctx; // local pointer on VFS context (same in all clusters).
2037	fatfs_ctx_t * loc_fatfs_ctx; // local pointer on local FATFS context
2038	fatfs_ctx_t * fat_fatfs_ctx; // local pointer on FATFS context in FAT cluster
2039	xptr_t mapper_xp; // extended pointer on FAT mapper
2040	cxy_t mapper_cxy; // Fat mapper cluster identifier
2041	xptr_t lock_xp; // extended pointer on lock protecting free clusters info.
2042	xptr_t first_xp; // extended pointer on inode extension
2043	uint32_t first_cluster; // first cluster index for released inode
2044	vfs_inode_t * inode_ptr;
2045	cxy_t inode_cxy;
2046
2047	// check inode pointer
2048	assert( (inode_xp != XPTR_NULL) , "inode pointer is NULL\n" );
2049
2050	// get first_cluster from inode extension
2051	inode_ptr = GET_PTR( inode_xp );
2052	inode_cxy = GET_CXY( inode_xp );
2053	first_xp = XPTR( inode_cxy , &inode_ptr->extend );
2054	first_cluster = (uint32_t)(intptr_t)hal_remote_lpt( first_xp );
2055
2056	// check first cluster index
2057	assert( (first_cluster != 0) , "inode extend is NULL\n" );
2058
2059	#if DEBUG_FATFS_RELEASE_INODE
2060	char name[CONFIG_VFS_MAX_NAME_LENGTH];
2061	uint32_t cycle = (uint32_t)hal_get_cycles();
2062	thread_t * this = CURRENT_THREAD;
2063	vfs_inode_get_name( inode_xp , name );
2064	if( DEBUG_FATFS_RELEASE_INODE < cycle )
2065	printk("\n[%s] thread[%x,%x] enter for <%s> / first_cluster %x / cycle %d\n",
2066	__FUNCTION__ , this->process->pid, this->trdid, name, first_cluster, cycle );
2067	#endif
2068
2069	// get local pointer on VFS context (same in all clusters)
2070	vfs_ctx = &fs_context[FS_TYPE_FATFS];
2071
2072	// get local pointer on local FATFS context
2073	loc_fatfs_ctx = vfs_ctx->extend;
2074
2075	// get extended pointer and cluster on FAT mapper
2076	mapper_xp = loc_fatfs_ctx->fat_mapper_xp;
2077	mapper_cxy = GET_CXY( mapper_xp );
2078
2079	// get local pointer on FATFS context in FAT cluster
2080	fat_fatfs_ctx = hal_remote_lpt( XPTR( mapper_cxy , &vfs_ctx->extend ) );
2081
2082	// get extended pointer on free clusters lock in FAT cluster
2083	lock_xp = XPTR( mapper_cxy , &fat_fatfs_ctx->free_lock );
2084
2085	// take lock protecting free clusters
2086	remote_queuelock_acquire( lock_xp );
2087
2088	// call the recursive function to release all clusters from FAT mapper
2089	if ( fatfs_recursive_release( mapper_xp , first_cluster ) )
2090	{
2091	printk("\n[ERROR] in %s : cannot update FAT mapper\n", __FUNCTION__ );
2092	remote_queuelock_release( lock_xp );
2093	return -1;
2094	}
2095
2096	// release lock protecting free cluster
2097	remote_queuelock_release( lock_xp );
2098
2099	#if (DEBUG_FATFS_RELEASE_INODE & 1)
2100	if( DEBUG_FATFS_RELEASE_INODE < cycle )
2101	printk("\n[%s] inode <%s> removed from FAT mapper\n", __FUNCTION__, name );
2102	#endif
2103
2104	// update FAT on IOC device (from FAT mapper)
2105	if ( fatfs_sync_fat() )
2106	{
2107	printk("\n[ERROR] in %s : cannot update FAT on device\n", __FUNCTION__ );
2108	return -1;
2109	}
2110
2111	#if (DEBUG_FATFS_RELEASE_INODE & 1)
2112	if( DEBUG_FATFS_RELEASE_INODE < cycle )
2113	printk("\n[%s] inode <%s> removed from FAT on IOC device\n", __FUNCTION__, name );
2114	#endif
2115
2116	// update FS-INFO sector on IOC device (from FATFS context)
2117	if ( fatfs_sync_free_info() )
2118	{
2119	printk("\n[ERROR] in %s: cannot update FS_INFO on device\n", __FUNCTION__ );
2120	return -1;
2121	}
2122
2123	#if DEBUG_FATFS_RELEASE_INODE
2124	cycle = (uint32_t)hal_get_cycles();
2125	if( DEBUG_FATFS_RELEASE_INODE < cycle )
2126	printk("\n[%s] thread[%x,%x] removed <%s> inode from FATFS / cycle %d\n",
2127	__FUNCTION__ , this->process->pid, this->trdid, name, cycle );
2128	#endif
2129
2130	return 0;
2131
2132	} // end fatfs_release_inode()
2133
2134	/////////////////////////////////////////
2135	error_t fatfs_move_page( xptr_t page_xp,
2136	bool_t to_mapper )
2137	{
2138	error_t error;
2139	vfs_inode_t * inode_ptr;
2140	mapper_t * mapper_ptr;
2141	uint32_t page_id; // page index in mapper
2142
2143	#if DEBUG_FATFS_MOVE_PAGE
2144	uint32_t cycle = (uint32_t)hal_get_cycles();
2145	thread_t * this = CURRENT_THREAD;
2146	char name[CONFIG_VFS_MAX_NAME_LENGTH];
2147	#endif
2148
2149	// get page cluster an local pointer
2150	cxy_t page_cxy = GET_CXY( page_xp );
2151	page_t * page_ptr = GET_PTR( page_xp );
2152
2153	// get mapper pointer and page index from page descriptor
2154	mapper_ptr = hal_remote_lpt( XPTR( page_cxy , &page_ptr->mapper ) );
2155	page_id = hal_remote_l32( XPTR( page_cxy , &page_ptr->index ) );
2156
2157	// get pointer on local FATFS context
2158	fatfs_ctx_t * fatfs_ctx = fs_context[FS_TYPE_FATFS].extend;
2159
2160	// get page base address
2161	xptr_t base_xp = ppm_page2base( page_xp );
2162	uint8_t * buffer = (uint8_t *)GET_PTR( base_xp );
2163
2164	// get inode pointer from mapper
2165	inode_ptr = hal_remote_lpt( XPTR( page_cxy , &mapper_ptr->inode ) );
2166
2167	////////////////////////////// it is the FAT mapper
2168	if( inode_ptr == NULL )
2169	{
2170	// get lba from FATFS context and page_id
2171	uint32_t lba = fatfs_ctx->fat_begin_lba + (page_id << 3);
2172
2173	// access device
2174	if( to_mapper ) error = dev_ioc_sync_read ( buffer , lba , 8 );
2175	else error = dev_ioc_write( buffer , lba , 8 );
2176
2177	if( error ) return EIO;
2178
2179	#if (DEBUG_FATFS_MOVE_PAGE & 0x1)
2180	if( DEBUG_FATFS_MOVE_PAGE < cycle )
2181	mapper_display_page( XPTR(page_cxy , mapper_ptr) , page_id , "FAT" );
2182	#endif
2183
2184	#if DEBUG_FATFS_MOVE_PAGE
2185	cycle = (uint32_t)hal_get_cycles();
2186	if( DEBUG_FATFS_MOVE_PAGE < cycle )
2187	{
2188	if (to_mapper)
2189	printk("\n[%s] thread[%x,%x] load page %d of FAT / cycle %d\n",
2190	__FUNCTION__, this->process->pid, this->trdid, page_id, cycle );
2191	else
2192	printk("\n[%s] thread[%x,%x] sync page %d of FAT / cycle %d\n",
2193	__FUNCTION__, this->process->pid, this->trdid, page_id, cycle );
2194	}
2195	#endif
2196
2197	}
2198	///////////////////////// it is an inode mapper
2199	else
2200	{
2201
2202	#if DEBUG_FATFS_MOVE_PAGE
2203	vfs_inode_get_name( XPTR( page_cxy , inode_ptr ) , name );
2204	#endif
2205
2206	uint32_t searched_cluster;
2207	uint32_t first_cluster;
2208
2209	// get first_cluster from inode extension
2210	void * extend = hal_remote_lpt( XPTR( page_cxy , &inode_ptr->extend ) );
2211	first_cluster = (uint32_t)(intptr_t)extend;
2212
2213	// compute searched_cluster
2214	if( page_id == 0 ) // no need to access FAT mapper
2215	{
2216	// searched cluster is first cluster
2217	searched_cluster = first_cluster;
2218	}
2219	else // FAT mapper access required
2220	{
2221	// access FAT mapper to get searched cluster
2222	error = fatfs_get_cluster( first_cluster,
2223	page_id,
2224	&searched_cluster );
2225	if( error ) return EIO;
2226	}
2227
2228	// get lba from searched_cluster
2229	uint32_t lba = fatfs_lba_from_cluster( fatfs_ctx , searched_cluster );
2230
2231	// access device
2232	if( to_mapper ) error = dev_ioc_sync_read ( buffer , lba , 8 );
2233	else error = dev_ioc_write( buffer , lba , 8 );
2234
2235	if( error ) return EIO;
2236
2237	#if (DEBUG_FATFS_MOVE_PAGE & 0x1)
2238	if( DEBUG_FATFS_MOVE_PAGE < cycle )
2239	char string[CONFIG_VFS_MAX_NAME_LENGTH];
2240	vfs_inode_get_name( XPTR(page_cxy , inode_ptr) , string );
2241	mapper_display_page( XPTR(page_cxy , mapper_ptr) , page_id , string );
2242	#endif
2243
2244	#if DEBUG_FATFS_MOVE_PAGE
2245	cycle = (uint32_t)hal_get_cycles();
2246	if(DEBUG_FATFS_MOVE_PAGE < cycle)
2247	{
2248	if(to_mapper)
2249	printk("\n[%s] thread[%x,%x] load page %d of <%s> inode / cycle %d\n",
2250	__FUNCTION__, this->process->pid, this->trdid, page_id, name, cycle );
2251	else
2252	printk("\n[%s] thread[%x,%x] sync page %d of <%s> inode / cycle %d\n",
2253	__FUNCTION__, this->process->pid, this->trdid, page_id, name, cycle );
2254	}
2255	#endif
2256
2257	}
2258
2259	return 0;
2260
2261	} // end fatfs_move_page()
2262
2263

Note: See TracBrowser for help on using the repository browser.

Download in other formats: