Context Navigation

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

Last change on this file since 786 was 783, checked in by alain, 9 years ago
Fix various bugs.
Property svn:executable set to ``*
File size: 150.6 KB

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

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

Download in other formats: