Context Navigation

msdos_misc.c @ 5ed41a6

4.11

Last change on this file since 5ed41a6 was 5ed41a6, checked in by Sebastian Huber <sebastian.huber@…>, on 03/14/17 at 10:41:18

dosfs: Fix msdos_add_file()

Make sure that long file names work accross cluster boundaries.

Close #2929.

Property mode set to 100644

File size: 64.3 KB

Line
1	/**
2	* @file
3	*
4	* @brief Miscellaneous Routines Implementation for MSDOS FileSystem
5	* @ingroup libfs
6	*/
7
8	/*
9	* Copyright (C) 2001 OKTET Ltd., St.-Petersburg, Russia
10	* Author: Eugeny S. Mints <Eugeny.Mints@oktet.ru>
11	*
12	* Modifications to support UTF-8 in the file system are
13	* Copyright (c) 2013 embedded brains GmbH.
14	*
15	* The license and distribution terms for this file may be
16	* found in the file LICENSE in this distribution or at
17	* http://www.rtems.org/license/LICENSE.
18	*/
19
20	#define MSDOS_TRACE 1
21
22	#if HAVE_CONFIG_H
23	#include "config.h"
24	#endif
25
26	#include <stdlib.h>
27	#include <ctype.h>
28	#include <sys/time.h>
29	#include <unistd.h>
30	#include <string.h>
31	#include <assert.h>
32	#include <errno.h>
33	#include <inttypes.h>
34	#include <rtems/libio_.h>
35
36	#include "fat.h"
37	#include "fat_fat_operations.h"
38	#include "fat_file.h"
39
40	#include "msdos.h"
41
42
43	#include <stdio.h>
44
45	#define MSDOS_LFN_ENTRY_SIZE \
46	(MSDOS_LFN_LEN_PER_ENTRY * MSDOS_NAME_LFN_BYTES_PER_CHAR)
47
48	#define MSDOS_LFN_ENTRY_SIZE_UTF8 \
49	((MSDOS_LFN_LEN_PER_ENTRY + 1 ) * MSDOS_NAME_LFN_BYTES_PER_CHAR \
50	* MSDOS_NAME_MAX_UTF8_BYTES_PER_CHAR)
51
52	/*
53	* External strings. Saves space this way.
54	*/
55	const char *const MSDOS_DOT_NAME = ". ";
56	const char *const MSDOS_DOTDOT_NAME = ".. ";
57
58	uint8_t
59	msdos_lfn_checksum(const void *entry)
60	{
61	const uint8_t *name;
62	uint8_t cs;
63	int i;
64
65	name = (const uint8_t *) MSDOS_DIR_NAME(entry);
66	cs = 0;
67
68	for (i = 0; i < MSDOS_SHORT_NAME_LEN; ++i) {
69	cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + name[i];
70	}
71
72	return cs;
73	}
74
75	/* msdos_is_valid_name_char --
76	* Routine to check the character in a file or directory name.
77	* The characters support in the short file name are letters,
78	* digits, or characters with code points values greater than
79	* 127 (not sure what this last is) plus the following special
80	* characters "$%'-_@~`!(){}^#&". The must be uppercase.
81	*
82	* The following 6 characters are allowed in a long names,
83	* " +,;=[]" including a space and lower case letters.
84	*
85	* PARAMETERS:
86	* ch - character to check.
87	*
88	* RETURNS:
89	* MSDOS_NAME_INVALID - Not valid in a long or short name.
90	* MSDOS_NAME_SHORT - Valid in a short name or long name.
91	* MSDOS_NAME_LONG - Valid in a long name only.
92	*
93	*/
94	static msdos_name_type_t
95	msdos_is_valid_name_char(const char ch)
96	{
97	if (strchr(" +,;=[]", ch) != NULL)
98	return MSDOS_NAME_LONG;
99
100	if ((ch == '.') \|\| isalnum((unsigned char)ch) \|\|
101	(strchr("$%'-_@~`!(){}^#&", ch) != NULL) \|\| (unsigned char) ch > 127)
102	return MSDOS_NAME_SHORT;
103
104	return MSDOS_NAME_INVALID;
105	}
106
107	/* msdos_short_hex_number --
108	* Routine to set the hex number in the SFN.
109	*
110	* PARAMETERS:
111	* name - name to change
112	* num - number to set
113	*
114	* RETURNS:
115	* nothing
116	*
117	*/
118	static void
119	msdos_short_name_hex(char* sfn, uint32_t num)
120	{
121	static const char* hex = "0123456789ABCDEF";
122	char* c = MSDOS_DIR_NAME(sfn);
123	int i;
124	for (i = 0; i < 2; i++, c++)
125	if ((c == ' ') \|\| (c == '.'))
126	*c = '_';
127	for (i = 0; i < 4; i++, c++)
128	c = hex[(num >> ((3 - i) 4)) & 0xf];
129	*c++ = '~';
130	*c = '1';
131	}
132
133	/* msdos_name_type --
134	* Routine the type of file name.
135	*
136	* PARAMETERS:
137	* name - name to check
138	*
139	* RETURNS:
140	* true the name is long, else the name is short.
141	*
142	*/
143	#define MSDOS_NAME_TYPE_PRINT 0
144	static msdos_name_type_t
145	msdos_name_type(const char *name, int name_len)
146	{
147	bool lowercase = false;
148	bool uppercase = false;
149	int dot_at = -1;
150	int count = 0;
151
152	while (*name && (count < name_len))
153	{
154	bool is_dot = *name == '.';
155	msdos_name_type_t type = msdos_is_valid_name_char(*name);
156
157	#if MSDOS_NAME_TYPE_PRINT
158	printf ("MSDOS_NAME_TYPE: c:%02x type:%d\n", *name, type);
159	#endif
160
161	if ((type == MSDOS_NAME_INVALID) \|\| (type == MSDOS_NAME_LONG))
162	return type;
163
164	if (dot_at >= 0)
165	{
166	if (is_dot \|\| ((count - dot_at) > 3))
167	{
168	#if MSDOS_NAME_TYPE_PRINT
169	printf ("MSDOS_NAME_TYPE: LONG[1]: is_dot:%d, at:%d cnt\n",
170	is_dot, dot_at, count);
171	#endif
172	return MSDOS_NAME_LONG;
173	}
174	}
175	else
176	{
177	if (count == 8 && !is_dot)
178	{
179	#if MSDOS_NAME_TYPE_PRINT
180	printf ("MSDOS_NAME_TYPE: LONG[2]: is_dot:%d, at:%d cnt\n",
181	is_dot, dot_at, count);
182	#endif
183	return MSDOS_NAME_LONG;
184	}
185	}
186
187	if (is_dot)
188	dot_at = count;
189	else if ((name >= 'A') && (name <= 'Z'))
190	uppercase = true;
191	else if ((name >= 'a') && (name <= 'z'))
192	lowercase = true;
193
194	count++;
195	name++;
196	}
197
198	if (lowercase && uppercase)
199	{
200	#if MSDOS_NAME_TYPE_PRINT
201	printf ("MSDOS_NAME_TYPE: LONG[3]\n");
202	#endif
203	return MSDOS_NAME_LONG;
204	}
205
206	#if MSDOS_NAME_TYPE_PRINT
207	printf ("MSDOS_NAME_TYPE: SHORT[1]\n");
208	#endif
209	return MSDOS_NAME_SHORT;
210	}
211
212	/* msdos_long_to_short --
213	* Routine to creates a short name from a long. Start the end of the
214	*
215	* PARAMETERS:
216	* name - name to check
217	*
218	* RETURNS:
219	* true the name is long, else the name is short.
220	*
221	*/
222	#define MSDOS_L2S_PRINT 0
223	msdos_name_type_t
224	msdos_long_to_short(rtems_dosfs_convert_control *converter,
225	const char *lfn,
226	int lfn_len,
227	char *sfn,
228	int sfn_len)
229	{
230	msdos_name_type_t type;
231	int eno = 0;
232	int i;
233	ssize_t short_filename_length = sfn_len;
234	void *buffer = converter->buffer.data;
235	size_t codepage_name_len = converter->buffer.size;
236
237	/*
238	* Fill with spaces. This is how a short directory entry is padded.
239	*/
240	memset (sfn, ' ', sfn_len);
241
242	/*
243	* Handle '.' and '..' specially.
244	*/
245	if ((lfn[0] == '.') && (lfn_len == 1))
246	{
247	sfn[0] = '.';
248	#if MSDOS_L2S_PRINT
249	printf ("MSDOS_L2S: SHORT[1]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
250	#endif
251	return MSDOS_NAME_SHORT;
252	}
253
254	if ((lfn[0] == '.') && (lfn[1] == '.') && (lfn_len == 2))
255	{
256	sfn[0] = sfn[1] = '.';
257	#if MSDOS_L2S_PRINT
258	printf ("MSDOS_L2S: SHORT[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
259	#endif
260	return MSDOS_NAME_SHORT;
261	}
262
263	/*
264	* Filenames with only blanks and dots are not allowed!
265	*/
266	for (i = 0; i < lfn_len; i++)
267	if ((lfn[i] != ' ') && (lfn[i] != '.'))
268	break;
269
270	if (i == lfn_len)
271	{
272	#if MSDOS_L2S_PRINT
273	printf ("MSDOS_L2S: INVALID[1]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
274	#endif
275	return MSDOS_NAME_INVALID;
276	}
277
278	/*
279	* Is this a short name ?
280	*/
281
282	eno = (*converter->handler->utf8_to_codepage) (
283	converter,
284	(const uint8_t*)&lfn[0],
285	lfn_len,
286	buffer,
287	&codepage_name_len);
288	if (eno == EINVAL)
289	{
290	eno = 0;
291	type = MSDOS_NAME_LONG;
292	}
293	else
294	{
295	type = msdos_name_type (
296	buffer,
297	codepage_name_len);
298	}
299
300	if (type != MSDOS_NAME_INVALID)
301	{
302	short_filename_length = msdos_filename_utf8_to_short_name_for_save (
303	converter,
304	(const uint8_t*)lfn,
305	lfn_len,
306	sfn,
307	short_filename_length);
308	if (short_filename_length < 0 ) {
309	type = MSDOS_NAME_INVALID;
310	}
311	#if MSDOS_L2S_PRINT
312	printf ("MSDOS_L2S: TYPE:%d lfn:'%s' SFN:'%s'\n", type, lfn, sfn);
313	#endif
314	}
315	else
316	{
317	#if MSDOS_L2S_PRINT
318	printf ("MSDOS_L2S: INVALID[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
319	#endif
320	}
321
322	return type;
323	}
324
325	/* msdos_find_name --
326	* Find the node which correspondes to the name, open fat-file which
327	* correspondes to the found node and close fat-file which correspondes
328	* to the node we searched in.
329	*
330	* PARAMETERS:
331	* parent_loc - parent node description
332	* name - name to find
333	*
334	* RETURNS:
335	* RC_OK and updated 'parent_loc' on success, or -1 if error
336	* occured (errno set apropriately)
337	*
338	*/
339	int
340	msdos_find_name(
341	rtems_filesystem_location_info_t *parent_loc,
342	const char *name,
343	int name_len
344	)
345	{
346	int rc = RC_OK;
347	msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
348	fat_file_fd_t *fat_fd = NULL;
349	msdos_name_type_t name_type;
350	fat_dir_pos_t dir_pos;
351	unsigned short time_val = 0;
352	unsigned short date = 0;
353	char node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE];
354
355	memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
356
357	name_type = msdos_long_to_short (
358	fs_info->converter,
359	name,
360	name_len,
361	MSDOS_DIR_NAME(node_entry),
362	MSDOS_NAME_MAX);
363
364	/*
365	* find the node which corresponds to the name in the directory pointed by
366	* 'parent_loc'
367	*/
368	rc = msdos_get_name_node(parent_loc, false, name, name_len, name_type,
369	&dir_pos, node_entry);
370	if (rc != RC_OK)
371	return rc;
372
373	if (((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_VOLUME_ID) \|\|
374	((*MSDOS_DIR_ATTR(node_entry) & MSDOS_ATTR_LFN_MASK) == MSDOS_ATTR_LFN))
375	return MSDOS_NAME_NOT_FOUND_ERR;
376
377	/* open fat-file corresponded to the found node */
378	rc = fat_file_open(&fs_info->fat, &dir_pos, &fat_fd);
379	if (rc != RC_OK)
380	return rc;
381
382	fat_fd->dir_pos = dir_pos;
383
384	/*
385	* I don't like this if, but: we should do it, or should write new file
386	* size and first cluster num to the disk after each write operation
387	* (even if one byte is written - that is TOO slow) because
388	* otherwise real values of these fields stored in fat-file descriptor
389	* may be accidentally rewritten with wrong values stored on the disk
390	*/
391	if (fat_fd->links_num == 1)
392	{
393	fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
394
395	time_val = *MSDOS_DIR_WRITE_TIME(node_entry);
396	date = *MSDOS_DIR_WRITE_DATE(node_entry);
397
398	fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
399
400	time_val = *MSDOS_DIR_CRT_TIME(node_entry);
401	date = *MSDOS_DIR_CRT_DATE(node_entry);
402
403	fat_fd->ctime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
404
405	if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
406	{
407	fat_fd->fat_file_type = FAT_DIRECTORY;
408	fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
409
410	rc = fat_file_size(&fs_info->fat, fat_fd);
411	if (rc != RC_OK)
412	{
413	fat_file_close(&fs_info->fat, fat_fd);
414	return rc;
415	}
416	}
417	else
418	{
419	fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
420	fat_fd->fat_file_type = FAT_FILE;
421	fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;
422	}
423
424	/* these data is not actual for zero-length fat-file */
425	fat_fd->map.file_cln = 0;
426	fat_fd->map.disk_cln = fat_fd->cln;
427
428	if ((fat_fd->fat_file_size != 0) &&
429	(fat_fd->fat_file_size <= fs_info->fat.vol.bpc))
430	{
431	fat_fd->map.last_cln = fat_fd->cln;
432	}
433	else
434	{
435	fat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
436	}
437	}
438
439	/* close fat-file corresponded to the node we searched in */
440	rc = fat_file_close(&fs_info->fat, parent_loc->node_access);
441	if (rc != RC_OK)
442	{
443	fat_file_close(&fs_info->fat, fat_fd);
444	return rc;
445	}
446
447	/* update node_info_ptr field */
448	parent_loc->node_access = fat_fd;
449
450	return rc;
451	}
452
453	/* msdos_get_name_node --
454	* This routine is used in two ways: for a new node creation (a) or for
455	* search the node which correspondes to the name parameter (b).
456	* In case (a) 'name' should be set up to NULL and 'name_dir_entry' should
457	* point to initialized 32 bytes structure described a new node.
458	* In case (b) 'name' should contain a valid string.
459	*
460	* (a): reading fat-file which correspondes to directory we are going to
461	* create node in. If free slot is found write contents of
462	* 'name_dir_entry' into it. If reach end of fat-file and no free
463	* slot found, write 32 bytes to the end of fat-file.
464	*
465	* (b): reading fat-file which correspondes to directory and trying to
466	* find slot with the name field == 'name' parameter
467	*
468	*
469	* PARAMETERS:
470	* parent_loc - node description to create node in or to find name in
471	* name - NULL or name to find
472	* paux - identify a node location on the disk -
473	* cluster num and offset inside the cluster
474	* short_dir_entry - node to create/placeholder for found node (IN/OUT)
475	*
476	* RETURNS:
477	* RC_OK, filled aux_struct_ptr and name_dir_entry on success, or -1 if
478	* error occured (errno set apropriately)
479	*
480	*/
481	int
482	msdos_get_name_node(
483	const rtems_filesystem_location_info_t *parent_loc,
484	bool create_node,
485	const char *name,
486	int name_len,
487	msdos_name_type_t name_type,
488	fat_dir_pos_t *dir_pos,
489	char *name_dir_entry
490	)
491	{
492	int rc = RC_OK;
493	fat_file_fd_t *fat_fd = parent_loc->node_access;
494	uint32_t dotdot_cln = 0;
495
496	/* find name in fat-file which corresponds to the directory */
497	rc = msdos_find_name_in_fat_file(parent_loc->mt_entry, fat_fd,
498	create_node, (const uint8_t*)name, name_len, name_type,
499	dir_pos, name_dir_entry);
500	if ((rc != RC_OK) && (rc != MSDOS_NAME_NOT_FOUND_ERR))
501	return rc;
502
503	if (!create_node)
504	{
505	/* if we search for valid name and name not found -> return */
506	if (rc == MSDOS_NAME_NOT_FOUND_ERR)
507	return rc;
508
509	/*
510	* if we have deal with ".." - it is a special case :(((
511	*
512	* Really, we should return cluster num and offset not of ".." slot, but
513	* slot which correspondes to real directory name.
514	*/
515	if (rc == RC_OK)
516	{
517	if (strncmp(name, "..", 2) == 0)
518	{
519	dotdot_cln = MSDOS_EXTRACT_CLUSTER_NUM((name_dir_entry));
520
521	/* are we right under root dir ? */
522	if (dotdot_cln == 0)
523	{
524	/*
525	* we can relax about first_char field - it never should be
526	* used for root dir
527	*/
528	fat_dir_pos_init(dir_pos);
529	dir_pos->sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
530	}
531	else
532	{
533	rc =
534	msdos_get_dotdot_dir_info_cluster_num_and_offset(parent_loc->mt_entry,
535	dotdot_cln,
536	dir_pos,
537	name_dir_entry);
538	if (rc != RC_OK)
539	return rc;
540	}
541	}
542	}
543	}
544	return rc;
545	}
546
547	/*
548	* msdos_get_dotdot_dir_info_cluster_num_and_offset
549	*
550	* Unfortunately, in general, we cann't work here in fat-file ideologic
551	* (open fat_file "..", get ".." and ".", open "..", find an entry ...)
552	* because if we open
553	* fat-file ".." it may happend that we have two different fat-file
554	* descriptors ( for real name of directory and ".." name ) for a single
555	* file ( cluster num of both pointers to the same cluster )
556	* But...we do it because we protected by semaphore
557	*
558	*/
559
560	/* msdos_get_dotdot_dir_info_cluster_num_and_offset --
561	* Get cluster num and offset not of ".." slot, but slot which correspondes
562	* to real directory name.
563	*
564	* PARAMETERS:
565	* mt_entry - mount table entry
566	* cln - data cluster num extracted drom ".." slot
567	* paux - identify a node location on the disk -
568	* number of cluster and offset inside the cluster
569	* dir_entry - placeholder for found node
570	*
571	* RETURNS:
572	* RC_OK, filled 'paux' and 'dir_entry' on success, or -1 if error occured
573	* (errno set apropriately)
574	*
575	*/
576	int
577	msdos_get_dotdot_dir_info_cluster_num_and_offset(
578	rtems_filesystem_mount_table_entry_t *mt_entry,
579	uint32_t cln,
580	fat_dir_pos_t *dir_pos,
581	char *dir_entry
582	)
583	{
584	int rc = RC_OK;
585	msdos_fs_info_t *fs_info = mt_entry->fs_info;
586	fat_file_fd_t *fat_fd = NULL;
587	char dot_node[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE];
588	char dotdot_node[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE];
589	uint32_t cl4find = 0;
590	rtems_dosfs_convert_control *converter = fs_info->converter;
591
592	/*
593	* open fat-file corresponded to ".."
594	*/
595	rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);
596	if (rc != RC_OK)
597	return rc;
598
599	fat_fd->cln = cln;
600	fat_fd->fat_file_type = FAT_DIRECTORY;
601	fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
602
603	fat_fd->map.file_cln = 0;
604	fat_fd->map.disk_cln = fat_fd->cln;
605
606	rc = fat_file_size(&fs_info->fat, fat_fd);
607	if (rc != RC_OK)
608	{
609	fat_file_close(&fs_info->fat, fat_fd);
610	return rc;
611	}
612
613	/* find "." node in opened directory */
614	memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
615	msdos_long_to_short(
616	converter,
617	".", 1, dot_node, MSDOS_SHORT_NAME_LEN);
618	rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, (const uint8_t*)".", 1,
619	MSDOS_NAME_SHORT, dir_pos, dot_node);
620
621	if (rc != RC_OK)
622	{
623	fat_file_close(&fs_info->fat, fat_fd);
624	return rc;
625	}
626
627	/* find ".." node in opened directory */
628	memset(dotdot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
629	msdos_long_to_short(
630	converter,
631	"..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);
632	rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, (const uint8_t*)"..", 2,
633	MSDOS_NAME_SHORT, dir_pos,
634	dotdot_node);
635
636	if (rc != RC_OK)
637	{
638	fat_file_close(&fs_info->fat, fat_fd);
639	return rc;
640	}
641
642	cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
643
644	/* close fat-file corresponded to ".." directory */
645	rc = fat_file_close(&fs_info->fat, fat_fd);
646	if ( rc != RC_OK )
647	return rc;
648
649	if ( (MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
650	{
651	/*
652	* we handle root dir for all FAT types in the same way with the
653	* ordinary directories ( through fat_file_* calls )
654	*/
655	fat_dir_pos_init(dir_pos);
656	dir_pos->sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
657	}
658
659	/* open fat-file corresponded to second ".." */
660	rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);
661	if (rc != RC_OK)
662	return rc;
663
664	if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
665	fat_fd->cln = fs_info->fat.vol.rdir_cl;
666	else
667	fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
668
669	fat_fd->fat_file_type = FAT_DIRECTORY;
670	fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
671
672	fat_fd->map.file_cln = 0;
673	fat_fd->map.disk_cln = fat_fd->cln;
674
675	rc = fat_file_size(&fs_info->fat, fat_fd);
676	if (rc != RC_OK)
677	{
678	fat_file_close(&fs_info->fat, fat_fd);
679	return rc;
680	}
681
682	/* in this directory find slot with specified cluster num */
683	rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
684	dir_pos, dir_entry);
685	if (rc != RC_OK)
686	{
687	fat_file_close(&fs_info->fat, fat_fd);
688	return rc;
689	}
690	rc = fat_file_close(&fs_info->fat, fat_fd);
691	return rc;
692	}
693
694
695	/* fat_file_write_time_and_date --
696	* Write last write date and time for a file to the disk (to corresponded
697	* 32bytes node)
698	*
699	* PARAMETERS:
700	* fs_info - fat fs info
701	* fat_fd - fat-file descriptor
702	*
703	* RETURNS:
704	* RC_OK on success, or -1 if error occured (errno set apropriately).
705	*
706	*/
707	int
708	fat_file_write_time_and_date(
709	fat_fs_info_t *fs_info,
710	fat_file_fd_t *fat_fd
711	)
712	{
713	int rc = RC_OK;
714	ssize_t ret;
715	uint16_t time_val;
716	uint16_t date;
717	uint32_t sec = 0;
718	uint32_t byte = 0;
719
720	/*
721	* calculate input for fat_sector_write: convert (cluster num, offset) to
722	* (sector num, new offset)
723	*/
724	sec = fat_cluster_num_to_sector_num(fs_info, fat_fd->dir_pos.sname.cln);
725	sec += (fat_fd->dir_pos.sname.ofs >> fs_info->vol.sec_log2);
726	/* byte points to start of 32bytes structure */
727	byte = fat_fd->dir_pos.sname.ofs & (fs_info->vol.bps - 1);
728
729	msdos_date_unix2dos(fat_fd->mtime, &date, &time_val);
730
731	time_val = CT_LE_W(time_val);
732	ret = fat_sector_write(fs_info, sec, byte + MSDOS_FILE_WTIME_OFFSET,
733	2, (char *)(&time_val));
734	if ( ret < 0 )
735	rc = -1;
736
737	date = CT_LE_W(date);
738	ret = fat_sector_write(fs_info, sec, byte + MSDOS_FILE_WDATE_OFFSET,
739	2, (char *)(&date));
740	if ( ret < 0 )
741	rc = -1;
742
743	ret = fat_sector_write(fs_info, sec, byte + MSDOS_FILE_ADATE_OFFSET,
744	2, (char *)(&date));
745	if ( ret < 0 )
746	rc = -1;
747
748	msdos_date_unix2dos(fat_fd->ctime, &date, &time_val);
749
750	time_val = CT_LE_W(time_val);
751	ret = fat_sector_write(fs_info, sec, byte + MSDOS_FILE_CTIME_OFFSET,
752	2, (char *)(&time_val));
753	if ( ret < 0 )
754	rc = -1;
755
756	date = CT_LE_W(date);
757	ret = fat_sector_write(fs_info, sec, byte + MSDOS_FILE_CDATE_OFFSET,
758	2, (char *)(&date));
759	if ( ret < 0 )
760	rc = -1;
761
762	return rc;
763	}
764
765	/* fat_set_first_cluster_num --
766	* Write number of first cluster of the file to the disk (to corresponded
767	* 32bytes slot)
768	*
769	* PARAMETERS:
770	* fs_info - fat fs info
771	* fat_fd - fat-file descriptor
772	*
773	* RETURNS:
774	* RC_OK on success, or -1 if error occured
775	*
776	*/
777	int
778	fat_file_write_first_cluster_num(
779	fat_fs_info_t *fs_info,
780	fat_file_fd_t *fat_fd
781	)
782	{
783	ssize_t ret1 = 0, ret2 = 0;
784	uint32_t new_cln = fat_fd->cln;
785	uint16_t le_cl_low = 0;
786	uint16_t le_cl_hi = 0;
787	uint32_t sec = 0;
788	uint32_t byte = 0;
789
790	/*
791	* calculate input for fat_sector_write: convert (cluster num, offset) to
792	* (sector num, new offset)
793	*/
794	sec = fat_cluster_num_to_sector_num(fs_info, fat_fd->dir_pos.sname.cln);
795	sec += (fat_fd->dir_pos.sname.ofs >> fs_info->vol.sec_log2);
796	/* byte from points to start of 32bytes structure */
797	byte = fat_fd->dir_pos.sname.ofs & (fs_info->vol.bps - 1);
798
799	le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
800	ret1 = fat_sector_write(fs_info, sec,
801	byte + MSDOS_FIRST_CLUSTER_LOW_OFFSET, 2,
802	(char *)(&le_cl_low));
803	le_cl_hi = CT_LE_W((uint16_t )((new_cln & 0xFFFF0000) >> 16));
804	ret2 = fat_sector_write(fs_info, sec,
805	byte + MSDOS_FIRST_CLUSTER_HI_OFFSET, 2,
806	(char *)(&le_cl_hi));
807	if ( (ret1 < 0) \|\| (ret2 < 0) )
808	return -1;
809
810	return RC_OK;
811	}
812
813
814	/* fat_set_file size --
815	* Write file size of the file to the disk (to corresponded 32bytes slot)
816	*
817	* PARAMETERS:
818	* fs_info - fat fs info
819	* fat_fd - fat-file descriptor
820	*
821	* RETURNS:
822	* RC_OK on success, or -1 if error occured (errno set apropriately).
823	*
824	*/
825	int
826	fat_file_write_file_size(
827	fat_fs_info_t *fs_info,
828	fat_file_fd_t *fat_fd
829	)
830	{
831	ssize_t ret = 0;
832	uint32_t le_new_length = 0;
833	uint32_t sec = 0;
834	uint32_t byte = 0;
835
836	sec = fat_cluster_num_to_sector_num(fs_info, fat_fd->dir_pos.sname.cln);
837	sec += (fat_fd->dir_pos.sname.ofs >> fs_info->vol.sec_log2);
838	byte = (fat_fd->dir_pos.sname.ofs & (fs_info->vol.bps - 1));
839
840	if (fat_fd->fat_file_type == FAT_DIRECTORY) {
841	le_new_length = CT_LE_L(0);
842	} else {
843	le_new_length = CT_LE_L(fat_fd->fat_file_size);
844	}
845
846	ret = fat_sector_write(fs_info, sec, byte + MSDOS_FILE_SIZE_OFFSET, 4,
847	(char *)(&le_new_length));
848	if ( ret < 0 )
849	return -1;
850
851	return RC_OK;
852	}
853
854	/*
855	* We should not check whether this routine is called for root dir - it
856	* never can happend
857	*/
858
859	/* msdos_set_first_char4file_name --
860	* Write first character of the name of the file to the disk (to
861	* corresponded 32bytes slot)
862	*
863	* PARAMETERS:
864	* mt_entry - mount table entry
865	* cl - number of cluster
866	* ofs - offset inside cluster
867	* fchar - character to set up
868	*
869	* RETURNS:
870	* RC_OK on success, or -1 if error occured (errno set apropriately)
871	*
872	*/
873	int
874	msdos_set_first_char4file_name(
875	rtems_filesystem_mount_table_entry_t *mt_entry,
876	fat_dir_pos_t *dir_pos,
877	unsigned char fchar
878	)
879	{
880	ssize_t ret;
881	msdos_fs_info_t *fs_info = mt_entry->fs_info;
882	uint32_t dir_block_size;
883	fat_pos_t start = dir_pos->lname;
884	fat_pos_t end = dir_pos->sname;
885
886	if ((end.cln == fs_info->fat.vol.rdir_cl) &&
887	(fs_info->fat.vol.type & (FAT_FAT12 \| FAT_FAT16)))
888	dir_block_size = fs_info->fat.vol.rdir_size;
889	else
890	dir_block_size = fs_info->fat.vol.bpc;
891
892	if (dir_pos->lname.cln == FAT_FILE_SHORT_NAME)
893	start = dir_pos->sname;
894
895	/*
896	* We handle the changes directly due the way the short file
897	* name code was written rather than use the fat_file_write
898	* interface.
899	*/
900	while (true)
901	{
902	uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
903	(start.ofs >> fs_info->fat.vol.sec_log2));
904	uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
905
906	ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
907	1, &fchar);
908	if (ret < 0)
909	return -1;
910
911	if ((start.cln == end.cln) && (start.ofs == end.ofs))
912	break;
913
914	start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
915	if (start.ofs >= dir_block_size)
916	{
917	int rc;
918	if ((end.cln == fs_info->fat.vol.rdir_cl) &&
919	(fs_info->fat.vol.type & (FAT_FAT12 \| FAT_FAT16)))
920	break;
921	rc = fat_get_fat_cluster(&fs_info->fat, start.cln, &start.cln);
922	if ( rc != RC_OK )
923	return rc;
924	start.ofs = 0;
925	}
926	}
927
928	return RC_OK;
929	}
930
931	/* msdos_dir_is_empty --
932	* Check whether directory which correspondes to the fat-file descriptor is
933	* empty.
934	*
935	* PARAMETERS:
936	* mt_entry - mount table entry
937	* fat_fd - fat-file descriptor
938	* ret_val - placeholder for result
939	*
940	* RETURNS:
941	* RC_OK on success, or -1 if error occured
942	*
943	*/
944	int
945	msdos_dir_is_empty(
946	rtems_filesystem_mount_table_entry_t *mt_entry,
947	fat_file_fd_t *fat_fd,
948	bool *ret_val
949	)
950	{
951	ssize_t ret = 0;
952	msdos_fs_info_t *fs_info = mt_entry->fs_info;
953	uint32_t j = 0, i = 0;
954
955	/* dir is not empty */
956	*ret_val = false;
957
958	while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * fs_info->fat.vol.bps,
959	fs_info->fat.vol.bps,
960	fs_info->cl_buf)) != FAT_EOF)
961	{
962	if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
963	return -1;
964
965	assert(ret == fs_info->fat.vol.bps);
966
967	/* have to look at the DIR_NAME as "raw" 8-bit data */
968	for (i = 0;
969	i < fs_info->fat.vol.bps;
970	i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
971	{
972	char* entry = (char*) fs_info->cl_buf + i;
973
974	/*
975	* If the entry is empty, a long file name entry, or '.' or '..'
976	* then consider it as empty.
977	*
978	* Just ignore long file name entries. They must have a short entry to
979	* be valid.
980	*/
981	if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
982	MSDOS_THIS_DIR_ENTRY_EMPTY) \|\|
983	((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
984	MSDOS_ATTR_LFN) \|\|
985	(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
986	MSDOS_SHORT_NAME_LEN) == 0) \|\|
987	(strncmp(MSDOS_DIR_NAME((entry)),
988	MSDOS_DOTDOT_NAME,
989	MSDOS_SHORT_NAME_LEN) == 0))
990	continue;
991
992	/*
993	* Nothing more to look at.
994	*/
995	if ((*MSDOS_DIR_NAME(entry)) ==
996	MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
997	{
998	*ret_val = true;
999	return RC_OK;
1000	}
1001
1002	/*
1003	* Short file name entries mean not empty.
1004	*/
1005	return RC_OK;
1006	}
1007	j++;
1008	}
1009	*ret_val = true;
1010	return RC_OK;
1011	}
1012
1013	#define MSDOS_FIND_PRINT 0
1014	static int
1015	msdos_on_entry_found (
1016	msdos_fs_info_t *fs_info,
1017	fat_file_fd_t *fat_fd,
1018	const uint32_t bts2rd,
1019	char *name_dir_entry,
1020	char *entry,
1021	fat_dir_pos_t *dir_pos,
1022	uint32_t dir_offset,
1023	const uint32_t dir_entry,
1024	const fat_pos_t *lfn_start
1025	)
1026	{
1027	int rc = RC_OK;
1028	#if MSDOS_FIND_PRINT
1029	printf ("MSFS:[9.3] SNF found\n");
1030	#endif
1031	/*
1032	* We get the entry we looked for - fill the position
1033	* structure and the 32 bytes of the short entry
1034	*/
1035	rc = fat_file_ioctl(&fs_info->fat,
1036	fat_fd,
1037	F_CLU_NUM,
1038	dir_offset * bts2rd,
1039	&dir_pos->sname.cln);
1040	if (rc == RC_OK) {
1041	dir_pos->sname.ofs = dir_entry;
1042
1043	if (lfn_start->cln != FAT_FILE_SHORT_NAME)
1044	{
1045	rc = fat_file_ioctl (&fs_info->fat,
1046	fat_fd,
1047	F_CLU_NUM,
1048	lfn_start->cln * bts2rd,
1049	&lfn_start->cln);
1050	}
1051	if ( rc == RC_OK ) {
1052	dir_pos->lname.cln = lfn_start->cln;
1053	dir_pos->lname.ofs = lfn_start->ofs;
1054
1055	memcpy(name_dir_entry, entry,
1056	MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
1057	}
1058	}
1059
1060	return rc;
1061	}
1062
1063	ssize_t
1064	msdos_get_utf16_string_from_long_entry (
1065	const char *entry,
1066	uint16_t *entry_string_buf,
1067	const size_t buf_size,
1068	bool is_first_entry
1069	)
1070	{
1071	ssize_t chars_in_entry;
1072
1073	if (buf_size >= MSDOS_LFN_ENTRY_SIZE) {
1074	memcpy (&entry_string_buf[0], &entry[1], 10 );
1075	memcpy (&entry_string_buf[5], &entry[14], 12 );
1076	memcpy (&entry_string_buf[11], &entry[28], 4 );
1077
1078	if (is_first_entry) {
1079	for (chars_in_entry = 0;
1080	( chars_in_entry < MSDOS_LFN_LEN_PER_ENTRY
1081	&& entry_string_buf[chars_in_entry] != 0x0000);
1082	++chars_in_entry) {
1083	;
1084	}
1085	}
1086	else
1087	chars_in_entry = MSDOS_LFN_LEN_PER_ENTRY;
1088
1089	return chars_in_entry * MSDOS_NAME_LFN_BYTES_PER_CHAR;
1090	}
1091	else
1092	return ENOMEM;
1093	}
1094
1095	/* msdos_format_dirent_with_dot --
1096	* This routine convert a (short) MSDOS filename as present on disk
1097	* (fixed 8+3 characters, filled with blanks, without separator dot)
1098	* to a "normal" format, with between 0 and 8 name chars,
1099	* a separating dot and up to 3 extension characters
1100	* Rules to work:
1101	* - copy any (0-8) "name" part characters that are non-blank
1102	* - if an extension exists, append a dot
1103	* - copy any (0-3) non-blank extension characters
1104	* - append a '\0' (dont count it for the rturn code
1105	*
1106	* PARAMETERS:
1107	* dst: pointer to destination char array (must be big enough)
1108	* src: pointer to source characters
1109	*
1110	*
1111	* RETURNS:
1112	* the number of bytes (without trailing '\0'(written to destination
1113	*/
1114	ssize_t
1115	msdos_format_dirent_with_dot(char dst,const char src)
1116	{
1117	ssize_t len;
1118	int i;
1119	const char *src_tmp;
1120
1121	/*
1122	* find last non-blank character of base name
1123	*/
1124	for (i = MSDOS_SHORT_BASE_LEN, src_tmp = src + MSDOS_SHORT_BASE_LEN - 1;
1125	i > 0 && *src_tmp == ' ';
1126	--i,--src_tmp)
1127	{};
1128	/*
1129	* copy base name to destination
1130	*/
1131	src_tmp = src;
1132	len = i;
1133	while (i-- > 0) {
1134	dst++ = tolower((unsigned char)(src_tmp++));
1135	}
1136	/*
1137	* find last non-blank character of extension
1138	*/
1139	for (i = MSDOS_SHORT_EXT_LEN,
1140	src_tmp = src + MSDOS_SHORT_BASE_LEN+MSDOS_SHORT_EXT_LEN-1;
1141	i > 0 && *src_tmp == ' ';
1142	--i, --src_tmp)
1143	{};
1144	/*
1145	* extension is not empty
1146	*/
1147	if (i > 0) {
1148	dst++ = '.'; / append dot */
1149	++len; /* dot */
1150	src_tmp = src + MSDOS_SHORT_BASE_LEN;
1151	while (i-- > 0) {
1152	dst++ = tolower((unsigned char)(src_tmp++));
1153	++len;
1154	}
1155	}
1156	dst = '\0'; / terminate string */
1157
1158	return len;
1159	}
1160
1161	static ssize_t
1162	msdos_long_entry_to_utf8_name (
1163	rtems_dosfs_convert_control *converter,
1164	const char *entry,
1165	const bool is_first_entry,
1166	uint8_t *entry_utf8_buf,
1167	const size_t buf_size)
1168	{
1169	ssize_t retval = 0;
1170	int eno = 0;
1171	size_t bytes_in_utf8 = buf_size;
1172	size_t bytes_in_buf;
1173	uint16_t entry_string[MSDOS_LFN_LEN_PER_ENTRY];
1174
1175	retval = msdos_get_utf16_string_from_long_entry (
1176	entry,
1177	entry_string,
1178	sizeof (entry_string),
1179	is_first_entry
1180	);
1181
1182	if (retval >= 0) {
1183	bytes_in_buf = retval;
1184	eno = (*converter->handler->utf16_to_utf8) (
1185	converter,
1186	&entry_string[0],
1187	bytes_in_buf,
1188	&entry_utf8_buf[0],
1189	&bytes_in_utf8);
1190	if ( eno == 0 ) {
1191	retval = bytes_in_utf8;
1192	}
1193	}
1194
1195	if (eno != 0) {
1196	retval = -1;
1197	errno = eno;
1198	}
1199
1200	return retval;
1201	}
1202
1203	static ssize_t msdos_short_entry_to_utf8_name (
1204	rtems_dosfs_convert_control *converter,
1205	const char *entry,
1206	uint8_t *buf,
1207	const size_t buf_size)
1208	{
1209	char char_buf[MSDOS_NAME_MAX_WITH_DOT];
1210	int eno = 0;
1211	size_t bytes_converted = buf_size;
1212	ssize_t bytes_written = msdos_format_dirent_with_dot(char_buf, entry);
1213
1214	if (bytes_written > 0) {
1215	if (char_buf[0] == 0x05)
1216	char_buf[0] = 0xE5;
1217
1218	eno = (*converter->handler->codepage_to_utf8) (
1219	converter,
1220	char_buf,
1221	bytes_written,
1222	buf,
1223	&bytes_converted);
1224	if (eno == 0)
1225	bytes_written = bytes_converted;
1226	} else {
1227	eno = EINVAL;
1228	}
1229
1230	if (eno != 0) {
1231	bytes_written = -1;
1232	errno = eno;
1233	}
1234
1235	return bytes_written;
1236	}
1237
1238	static ssize_t
1239	msdos_compare_entry_against_filename (
1240	rtems_dosfs_convert_control *converter,
1241	const uint8_t *entry,
1242	const size_t entry_size,
1243	const uint8_t *filename,
1244	const size_t filename_size_remaining,
1245	bool *is_matching)
1246	{
1247	ssize_t size_remaining = filename_size_remaining;
1248	int eno = 0;
1249	uint8_t entry_normalized[MSDOS_LFN_ENTRY_SIZE_UTF8];
1250	size_t bytes_in_entry_normalized = sizeof ( entry_normalized );
1251
1252	eno = (*converter->handler->utf8_normalize_and_fold) (
1253	converter,
1254	&entry[0],
1255	entry_size,
1256	&entry_normalized[0],
1257	&bytes_in_entry_normalized);
1258	if (eno == 0) {
1259	#if MSDOS_FIND_PRINT > 1
1260	printf ( "MSFS:[6] entry_normalized:%s"
1261	"name:%s\n",
1262	entry,
1263	filename );
1264	#endif
1265	if (bytes_in_entry_normalized <= size_remaining) {
1266	size_remaining = size_remaining - bytes_in_entry_normalized;
1267	if (0 == memcmp ( &entry_normalized[0],
1268	&filename[size_remaining],
1269	bytes_in_entry_normalized)) {
1270	*is_matching = true;
1271	} else {
1272	*is_matching = false;
1273	size_remaining = filename_size_remaining;
1274	}
1275
1276	}
1277	else {
1278	*is_matching = false;
1279	}
1280	}
1281
1282	if (eno != 0) {
1283	size_remaining = -1;
1284	errno = eno;
1285	}
1286
1287	return size_remaining;
1288	}
1289
1290	static int
1291	msdos_find_file_in_directory (
1292	const uint8_t *filename_converted,
1293	const size_t name_len_for_compare,
1294	const size_t name_len_for_save,
1295	const msdos_name_type_t name_type,
1296	msdos_fs_info_t *fs_info,
1297	fat_file_fd_t *fat_fd,
1298	const uint32_t bts2rd,
1299	const bool create_node,
1300	const unsigned int fat_entries,
1301	char *name_dir_entry,
1302	fat_dir_pos_t *dir_pos,
1303	uint32_t *empty_file_offset,
1304	uint32_t *empty_entry_count)
1305	{
1306	int rc = RC_OK;
1307	ssize_t bytes_read;
1308	uint32_t dir_entry;
1309	fat_pos_t lfn_start;
1310	uint8_t lfn_checksum = 0;
1311	bool entry_matched = false;
1312	bool empty_space_found = false;
1313	uint32_t entries_per_block = bts2rd / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
1314	int lfn_entry = 0;
1315	uint8_t entry_utf8_normalized[MSDOS_LFN_ENTRY_SIZE_UTF8];
1316	size_t bytes_in_entry;
1317	bool filename_matched = false;
1318	ssize_t filename_size_remaining = name_len_for_compare;
1319	rtems_dosfs_convert_control *converter = fs_info->converter;
1320	uint32_t dir_offset = 0;
1321
1322	/*
1323	* Scan the directory seeing if the file is present. While
1324	* doing this see if a suitable location can be found to
1325	* create the entry if the name is not found.
1326	*/
1327
1328	lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
1329
1330	while ( (bytes_read = fat_file_read (&fs_info->fat, fat_fd, (dir_offset * bts2rd),
1331	bts2rd, fs_info->cl_buf)) != FAT_EOF
1332	&& rc == RC_OK)
1333	{
1334	bool remainder_empty = false;
1335	#if MSDOS_FIND_PRINT
1336	printf ("MSFS:[2] dir_offset:%li\n", dir_offset);
1337	#endif
1338
1339	if (bytes_read < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
1340	rtems_set_errno_and_return_minus_one(EIO);
1341
1342	assert(bytes_read == bts2rd);
1343
1344	/* have to look at the DIR_NAME as "raw" 8-bit data */
1345	for (dir_entry = 0;
1346	dir_entry < bts2rd && rc == RC_OK && (! filename_matched);
1347	dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
1348	{
1349	char* entry = (char*) fs_info->cl_buf + dir_entry;
1350
1351	/*
1352	* See if the entry is empty or the remainder of the directory is
1353	* empty ? Localize to make the code read better.
1354	*/
1355	bool entry_empty = (*MSDOS_DIR_ENTRY_TYPE(entry) ==
1356	MSDOS_THIS_DIR_ENTRY_EMPTY);
1357	remainder_empty = (*MSDOS_DIR_ENTRY_TYPE(entry) ==
1358	MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY);
1359	#if MSDOS_FIND_PRINT
1360	printf ("MSFS:[3] re:%i ee:%i do:%li de:%li(%ld)\n",
1361	remainder_empty, entry_empty, dir_offset,
1362	dir_entry, (dir_entry / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE));
1363	#endif
1364	/*
1365	* Remember where the we are, ie the start, so we can come back
1366	* to here and write the long file name if this is the start of
1367	* a series of empty entries. If empty_entry_count is 0 then
1368	* we are currently not inside an empty series of entries. It
1369	* is a count of empty entries.
1370	*/
1371	if (*empty_entry_count == 0)
1372	{
1373	empty_file_offset = dir_offset bts2rd + dir_entry;
1374	}
1375
1376	if (remainder_empty)
1377	{
1378	#if MSDOS_FIND_PRINT
1379	printf ("MSFS:[3.1] cn:%i esf:%i\n", create_node, empty_space_found);
1380	#endif
1381	/*
1382	* If just looking and there is no more entries in the
1383	* directory - return name-not-found
1384	*/
1385	if (!create_node)
1386	rc = MSDOS_NAME_NOT_FOUND_ERR;
1387
1388	/*
1389	* Lets go and write the directory entries. If we have not found
1390	* any available space add the remaining number of entries to any that
1391	* we may have already found that are just before this entry. If more
1392	* are needed FAT_EOF is returned by the read and we extend the file.
1393	*/
1394	if ( !empty_space_found
1395	&& rc == RC_OK )
1396	{
1397	*empty_entry_count +=
1398	entries_per_block - (dir_entry / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
1399	empty_space_found = true;
1400	#if MSDOS_FIND_PRINT
1401	printf ( "MSFS:[3.2] esf:%i esc%"PRIu32"\n", empty_space_found, *empty_entry_count );
1402	#endif
1403	}
1404	break;
1405	}
1406	else if (entry_empty)
1407	{
1408	if (create_node)
1409	{
1410	/*
1411	* Remainder is not empty so is this entry empty ?
1412	*/
1413	(*empty_entry_count)++;
1414
1415	if (*empty_entry_count == (fat_entries + 1))
1416	empty_space_found = true;
1417	}
1418	#if MSDOS_FIND_PRINT
1419	printf ("MSFS:[4.1] esc:%li esf:%i\n",
1420	*empty_entry_count, empty_space_found);
1421	#endif
1422	}
1423	else
1424	{
1425	/*
1426	* A valid entry so handle it.
1427	*
1428	* If empty space has not been found we need to start the
1429	* count again.
1430	*/
1431	if (create_node && !empty_space_found)
1432	{
1433	*empty_file_offset = 0;
1434	*empty_entry_count = 0;
1435	}
1436
1437	/*
1438	* Check the attribute to see if the entry is for a long
1439	* file name.
1440	*/
1441	if ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
1442	MSDOS_ATTR_LFN)
1443	{
1444	/* int o;*/
1445	#if MSDOS_FIND_PRINT
1446	printf ("MSFS:[4.2] lfn:%c entry:%i checksum:%i\n",
1447	lfn_start.cln == FAT_FILE_SHORT_NAME ? 'f' : 't',
1448	*MSDOS_DIR_ENTRY_TYPE(entry) & MSDOS_LAST_LONG_ENTRY_MASK,
1449	*MSDOS_DIR_LFN_CHECKSUM(entry));
1450	#endif
1451	/*
1452	* If we are not already processing a LFN see if this is
1453	* the first entry of a LFN ?
1454	*/
1455	if (lfn_start.cln == FAT_FILE_SHORT_NAME)
1456	{
1457	entry_matched = false;
1458
1459	/*
1460	* The first entry must have the last long entry
1461	* flag set.
1462	*/
1463	if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
1464	MSDOS_LAST_LONG_ENTRY) == 0)
1465	continue;
1466
1467	/*
1468	* Does the number of entries in the LFN directory
1469	* entry match the number we expect for this
1470	* file name. Note we do not know the number of
1471	* characters in the entry so this is check further
1472	* on when the characters are checked.
1473	*/
1474	if (fat_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
1475	MSDOS_LAST_LONG_ENTRY_MASK))
1476	continue;
1477
1478	/*
1479	* Get the checksum of the short entry.
1480	*/
1481	lfn_start.cln = dir_offset;
1482	lfn_start.ofs = dir_entry;
1483	lfn_entry = fat_entries;
1484	lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
1485
1486	#if MSDOS_FIND_PRINT
1487	printf ("MSFS:[4.3] lfn_checksum:%i\n",
1488	lfn_checksum);
1489	#endif
1490	}
1491
1492	/*
1493	* If the entry number or the check sum do not match
1494	* forget this series of long directory entries. These
1495	* could be orphaned entries depending on the history
1496	* of the disk.
1497	*/
1498	if ((lfn_entry != (*MSDOS_DIR_ENTRY_TYPE(entry) &
1499	MSDOS_LAST_LONG_ENTRY_MASK)) \|\|
1500	(lfn_checksum != *MSDOS_DIR_LFN_CHECKSUM(entry)))
1501	{
1502	#if MSDOS_FIND_PRINT
1503	printf ("MSFS:[4.4] no match\n");
1504	#endif
1505	lfn_start.cln = FAT_FILE_SHORT_NAME;
1506	continue;
1507	}
1508	#if MSDOS_FIND_PRINT
1509	printf ("MSFS:[5] lfne:%i\n", lfn_entry);
1510	#endif
1511	lfn_entry--;
1512
1513	bytes_in_entry = msdos_long_entry_to_utf8_name (
1514	converter,
1515	entry,
1516	(lfn_entry + 1) == fat_entries,
1517	&entry_utf8_normalized[0],
1518	sizeof (entry_utf8_normalized));
1519	if (bytes_in_entry > 0) {
1520	filename_size_remaining = msdos_compare_entry_against_filename (
1521	converter,
1522	&entry_utf8_normalized[0],
1523	bytes_in_entry,
1524	&filename_converted[0],
1525	filename_size_remaining,
1526	&entry_matched);
1527
1528	if (filename_size_remaining < 0
1529	\|\| (! entry_matched)) {
1530	filename_size_remaining = name_len_for_compare;
1531	lfn_start.cln = FAT_FILE_SHORT_NAME;
1532	}
1533	} else {
1534	lfn_start.cln = FAT_FILE_SHORT_NAME;
1535	entry_matched = false;
1536	}
1537	}
1538	else
1539	{
1540	#if MSDOS_FIND_PRINT
1541	printf ("MSFS:[9.1] SFN entry, entry_matched:%i\n", entry_matched);
1542	#endif
1543	/*
1544	* SFN entry found.
1545	*
1546	* If a LFN has been found and it matched check the
1547	* entries have all been found and the checksum is
1548	* correct. If this is the case return the short file
1549	* name entry.
1550	*/
1551	if (entry_matched)
1552	{
1553	if (lfn_entry \|\|
1554	lfn_checksum != msdos_lfn_checksum(entry))
1555	entry_matched = false;
1556	else if (filename_size_remaining == 0) {
1557	filename_matched = true;
1558	rc = msdos_on_entry_found (
1559	fs_info,
1560	fat_fd,
1561	bts2rd,
1562	name_dir_entry,
1563	entry,
1564	dir_pos,
1565	dir_offset,
1566	dir_entry,
1567	&lfn_start
1568	);
1569	}
1570
1571	#if MSDOS_FIND_PRINT
1572	printf ("MSFS:[9.2] checksum, entry_matched:%i, lfn_entry:%i, lfn_checksum:%02x/%02x\n",
1573	entry_matched, lfn_entry, lfn_checksum, msdos_lfn_checksum(entry));
1574	#endif
1575	} else {
1576	bytes_in_entry = MSDOS_SHORT_NAME_LEN + 1;
1577	bytes_in_entry = msdos_short_entry_to_utf8_name (
1578	converter,
1579	MSDOS_DIR_NAME (entry),
1580	&entry_utf8_normalized[0],
1581	bytes_in_entry);
1582	if (bytes_in_entry > 0) {
1583	filename_size_remaining = msdos_compare_entry_against_filename (
1584	converter,
1585	&entry_utf8_normalized[0],
1586	bytes_in_entry,
1587	&filename_converted[0],
1588	name_len_for_compare,
1589	&entry_matched);
1590	if (entry_matched && filename_size_remaining == 0) {
1591	filename_matched = true;
1592	rc = msdos_on_entry_found (
1593	fs_info,
1594	fat_fd,
1595	bts2rd,
1596	name_dir_entry,
1597	entry,
1598	dir_pos,
1599	dir_offset,
1600	dir_entry,
1601	&lfn_start
1602	);
1603	}
1604	if (rc == RC_OK && (! filename_matched)) {
1605	lfn_start.cln = FAT_FILE_SHORT_NAME;
1606	entry_matched = false;
1607	filename_size_remaining = name_len_for_compare;
1608	}
1609	} else {
1610	lfn_start.cln = FAT_FILE_SHORT_NAME;
1611	entry_matched = false;
1612	filename_size_remaining = name_len_for_compare;
1613	}
1614	}
1615	}
1616	}
1617	}
1618
1619	if (filename_matched \|\| remainder_empty)
1620	break;
1621
1622	dir_offset++;
1623	}
1624	if ( ! filename_matched ) {
1625	/*
1626	* If we are not to create the entry return a not found error.
1627	*/
1628	if (!create_node)
1629	rc = MSDOS_NAME_NOT_FOUND_ERR;
1630
1631	#if MSDOS_FIND_PRINT
1632	printf ( "MSFS:[8.1] WRITE do:%"PRIu32" esc:%"PRIu32" efo:%"PRIu32"\n",
1633	dir_offset, empty_entry_count, empty_file_offset );
1634	#endif
1635	}
1636
1637	return rc;
1638	}
1639
1640	static int
1641	msdos_get_pos(
1642	msdos_fs_info_t *fs_info,
1643	fat_file_fd_t *fat_fd,
1644	uint32_t bts2rd,
1645	uint32_t file_offset,
1646	fat_pos_t *pos
1647	)
1648	{
1649	pos->ofs = file_offset & (bts2rd - 1);
1650	return fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
1651	file_offset, &pos->cln);
1652	}
1653
1654	static int
1655	msdos_add_file (
1656	const char *name_converted,
1657	const msdos_name_type_t name_type,
1658	msdos_fs_info_t *fs_info,
1659	fat_file_fd_t *fat_fd,
1660	const uint32_t bts2rd,
1661	const unsigned int fat_entries,
1662	const char *name_dir_entry,
1663	fat_dir_pos_t *dir_pos,
1664	uint32_t empty_file_offset,
1665	const uint32_t empty_entry_count
1666	)
1667	{
1668	int ret;
1669	ssize_t bytes_written;
1670	uint8_t lfn_checksum;
1671	int lfn_entry;
1672	uint8_t *entry;
1673	uint32_t short_file_offset;
1674	uint32_t length;
1675
1676	/*
1677	* If there is not enough space available then extend the file.
1678	*/
1679	if (empty_entry_count < fat_entries + 1)
1680	{
1681	uint32_t unused;
1682
1683	empty_file_offset = fat_fd->fat_file_size -
1684	empty_entry_count * MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
1685
1686	ret = fat_file_extend(&fs_info->fat,
1687	fat_fd,
1688	true,
1689	fat_fd->fat_file_size + fs_info->fat.vol.bpc,
1690	&unused);
1691	if (ret != RC_OK)
1692	return ret;
1693	}
1694
1695	if (name_type == MSDOS_NAME_LONG)
1696	{
1697	uint32_t slot;
1698
1699	/*
1700	* If a long file name calculate the checksum of the short file name
1701	* data to place in each long file name entry. First set the short
1702	* file name to the slot of the SFN entry. This will mean no clashes
1703	* in this directory.
1704	*/
1705	slot = (empty_file_offset /
1706	MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE) + fat_entries + 1;
1707	msdos_short_name_hex(MSDOS_DIR_NAME(name_dir_entry), slot);
1708
1709	lfn_checksum = msdos_lfn_checksum(name_dir_entry);
1710
1711	short_file_offset = empty_file_offset + fat_entries
1712	* MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
1713
1714	/* Get position of first long file name entry */
1715	ret = msdos_get_pos(fs_info, fat_fd, bts2rd, empty_file_offset,
1716	&dir_pos->lname);
1717	if (ret != RC_OK)
1718	return ret;
1719	} else {
1720	lfn_checksum = 0;
1721	short_file_offset = empty_file_offset;
1722	dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
1723	dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
1724	}
1725
1726	/* Get position of short file name entry */
1727	ret = msdos_get_pos(fs_info, fat_fd, bts2rd, short_file_offset,
1728	&dir_pos->sname);
1729
1730	/*
1731	* Handle the entry writes.
1732	*/
1733	entry = fs_info->cl_buf;
1734
1735	#if MSDOS_FIND_PRINT
1736	printf ("MSFS:[9] read_cluster:%d efo:%ld ese:%ld\n",
1737	read_cluster, empty_file_offset, empty_space_entry);
1738	#endif
1739
1740	/* Long file name entries */
1741	for (lfn_entry = 0; lfn_entry < fat_entries; ++lfn_entry) {
1742	uint8_t *p;
1743	const uint8_t *n;
1744	int i;
1745	uint8_t fill = 0;
1746
1747	/*
1748	* Clear the entry before loading the data.
1749	*/
1750	memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
1751
1752	*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
1753
1754	p = entry + 1;
1755	n = (const uint8_t *) name_converted +
1756	(fat_entries - lfn_entry - 1) * MSDOS_LFN_ENTRY_SIZE;
1757
1758	#if MSDOS_FIND_PRINT
1759	printf ("MSFS:[11] ");
1760	#endif
1761	for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; ++i)
1762	{
1763	if (!(n == 0 && (n+1) == 0))
1764	{
1765	p = n;
1766	(p+1) = (n+1);
1767	}
1768	else
1769	{
1770	p [0] = fill;
1771	p [1] = fill;
1772	fill = 0xff;
1773	}
1774	n += MSDOS_NAME_LFN_BYTES_PER_CHAR;
1775	#if MSDOS_FIND_PRINT
1776	printf ( "'%c''%c'", p, (p+1) );
1777	#endif
1778
1779	switch (i)
1780	{
1781	case 4:
1782	p += 5;
1783	break;
1784	case 10:
1785	p += 4;
1786	break;
1787	default:
1788	p += 2;
1789	break;
1790	}
1791	}
1792	#if MSDOS_FIND_PRINT
1793	printf ( "\n" );
1794	#endif
1795	*MSDOS_DIR_ENTRY_TYPE(entry) = fat_entries - lfn_entry;
1796	if (lfn_entry == 0)
1797	*MSDOS_DIR_ENTRY_TYPE(entry) \|= MSDOS_LAST_LONG_ENTRY;
1798	*MSDOS_DIR_ATTR(entry) \|= MSDOS_ATTR_LFN;
1799
1800	entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
1801	}
1802
1803	/* Short file name entry */
1804	memcpy(entry, name_dir_entry, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
1805
1806	length = (fat_entries + 1) * MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
1807	bytes_written = fat_file_write(&fs_info->fat, fat_fd,
1808	empty_file_offset,
1809	length, fs_info->cl_buf);
1810	if (bytes_written == (ssize_t) length)
1811	return 0;
1812	else if (bytes_written == -1)
1813	return -1;
1814	else
1815	rtems_set_errno_and_return_minus_one(EIO);
1816	}
1817
1818	int
1819	msdos_find_name_in_fat_file (
1820	rtems_filesystem_mount_table_entry_t *mt_entry,
1821	fat_file_fd_t *fat_fd,
1822	bool create_node,
1823	const uint8_t *name_utf8,
1824	int name_utf8_len,
1825	msdos_name_type_t name_type,
1826	fat_dir_pos_t *dir_pos,
1827	char *name_dir_entry)
1828	{
1829	int retval = 0;
1830	msdos_fs_info_t *fs_info = mt_entry->fs_info;
1831	ssize_t name_len_for_save;
1832	ssize_t name_len_for_compare;
1833	uint32_t bts2rd = 0;
1834	uint32_t empty_file_offset = 0;
1835	uint32_t empty_entry_count = 0;
1836	unsigned int fat_entries;
1837	rtems_dosfs_convert_control *converter = fs_info->converter;
1838	void *buffer = converter->buffer.data;
1839	size_t buffer_size = converter->buffer.size;
1840
1841	assert(name_utf8_len > 0);
1842
1843	fat_dir_pos_init(dir_pos);
1844
1845
1846
1847	if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
1848	(fs_info->fat.vol.type & (FAT_FAT12 \| FAT_FAT16)))
1849	bts2rd = fat_fd->fat_file_size;
1850	else
1851	bts2rd = fs_info->fat.vol.bpc;
1852
1853	switch ( name_type ) {
1854	case MSDOS_NAME_SHORT:
1855	name_len_for_compare = msdos_filename_utf8_to_short_name_for_compare (
1856	converter,
1857	name_utf8,
1858	name_utf8_len,
1859	buffer,
1860	MSDOS_SHORT_NAME_LEN);
1861	if (name_len_for_compare > 0) {
1862	fat_entries = 0;
1863	}
1864	else
1865	retval = -1;
1866	break;
1867	case MSDOS_NAME_LONG:
1868	name_len_for_save = msdos_filename_utf8_to_long_name_for_save (
1869	converter,
1870	name_utf8,
1871	name_utf8_len,
1872	buffer,
1873	buffer_size);
1874	if (name_len_for_save > 0) {
1875	fat_entries = (name_len_for_save + MSDOS_LFN_ENTRY_SIZE - 1)
1876	/ MSDOS_LFN_ENTRY_SIZE;
1877	name_len_for_compare = msdos_filename_utf8_to_long_name_for_compare (
1878	converter,
1879	name_utf8,
1880	name_utf8_len,
1881	buffer,
1882	buffer_size);
1883	if (0 >= name_len_for_compare) {
1884	retval = -1;
1885	}
1886	}
1887	else
1888	retval = -1;
1889	break;
1890	default:
1891	errno = EINVAL;
1892	retval = -1;
1893	break;
1894	}
1895	if (retval == RC_OK) {
1896	/* See if the file/directory does already exist */
1897	retval = msdos_find_file_in_directory (
1898	buffer,
1899	name_len_for_compare,
1900	name_len_for_save,
1901	name_type,
1902	fs_info,
1903	fat_fd,
1904	bts2rd,
1905	create_node,
1906	fat_entries,
1907	name_dir_entry,
1908	dir_pos,
1909	&empty_file_offset,
1910	&empty_entry_count);
1911	}
1912	/* Create a non-existing file/directory if requested */
1913	if ( retval == RC_OK
1914	&& create_node) {
1915	switch (name_type) {
1916	case MSDOS_NAME_SHORT:
1917	name_len_for_save = msdos_filename_utf8_to_short_name_for_save (
1918	converter,
1919	name_utf8,
1920	name_utf8_len,
1921	buffer,
1922	MSDOS_SHORT_NAME_LEN);
1923	if (name_len_for_save > 0 ) {
1924	fat_entries = 0;
1925	}
1926	else
1927	retval = -1;
1928	break;
1929	case MSDOS_NAME_LONG:
1930	name_len_for_save = msdos_filename_utf8_to_long_name_for_save (
1931	converter,
1932	name_utf8,
1933	name_utf8_len,
1934	buffer,
1935	buffer_size);
1936	if (name_len_for_save > 0) {
1937	fat_entries = (name_len_for_save + MSDOS_LFN_ENTRY_SIZE - 1)
1938	/ MSDOS_LFN_ENTRY_SIZE;
1939	}
1940	else
1941	retval = -1;
1942	break;
1943	default:
1944	errno = EINVAL;
1945	retval = -1;
1946	break;
1947	}
1948
1949	if (retval == RC_OK)
1950	retval = msdos_add_file (
1951	buffer,
1952	name_type,
1953	fs_info,
1954	fat_fd,
1955	bts2rd,
1956	fat_entries,
1957	name_dir_entry,
1958	dir_pos,
1959	empty_file_offset,
1960	empty_entry_count
1961	);
1962	}
1963
1964	return retval;
1965	}
1966
1967
1968	/* msdos_find_node_by_cluster_num_in_fat_file --
1969	* Find node with specified number of cluster in fat-file.
1970	*
1971	* Note, not updated in the LFN change because it is only used
1972	* for . and .. entries and these are always short.
1973	*
1974	* PARAMETERS:
1975	* mt_entry - mount table entry
1976	* fat_fd - fat-file descriptor
1977	* cl4find - number of cluster to find
1978	* paux - identify a node location on the disk -
1979	* cluster num and offset inside the cluster
1980	* dir_entry - placeholder for found node
1981	*
1982	* RETURNS:
1983	* RC_OK on success, or error code if error occured
1984	*
1985	*/
1986	int msdos_find_node_by_cluster_num_in_fat_file(
1987	rtems_filesystem_mount_table_entry_t *mt_entry,
1988	fat_file_fd_t *fat_fd,
1989	uint32_t cl4find,
1990	fat_dir_pos_t *dir_pos,
1991	char *dir_entry
1992	)
1993	{
1994	int rc = RC_OK;
1995	ssize_t ret = 0;
1996	msdos_fs_info_t *fs_info = mt_entry->fs_info;
1997	uint32_t bts2rd = 0;
1998	uint32_t i = 0, j = 0;
1999
2000	if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
2001	(fs_info->fat.vol.type & (FAT_FAT12 \| FAT_FAT16)))
2002	bts2rd = fat_fd->fat_file_size;
2003	else
2004	bts2rd = fs_info->fat.vol.bpc;
2005
2006	while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * bts2rd, bts2rd,
2007	fs_info->cl_buf)) != FAT_EOF)
2008	{
2009	if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )
2010	rtems_set_errno_and_return_minus_one( EIO );
2011
2012	assert(ret == bts2rd);
2013
2014	for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
2015	{
2016	char* entry = (char*) fs_info->cl_buf + i;
2017
2018	/* if this and all rest entries are empty - return not-found */
2019	if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
2020	MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
2021	return MSDOS_NAME_NOT_FOUND_ERR;
2022
2023	/* if this entry is empty - skip it */
2024	if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
2025	MSDOS_THIS_DIR_ENTRY_EMPTY)
2026	continue;
2027
2028	/* if get a non-empty entry - compare clusters num */
2029	if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)
2030	{
2031	/* on success fill aux structure and copy all 32 bytes */
2032	rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM, j * bts2rd,
2033	&dir_pos->sname.cln);
2034	if (rc != RC_OK)
2035	return rc;
2036
2037	dir_pos->sname.ofs = i;
2038	dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
2039	dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
2040
2041	memcpy(dir_entry, entry,
2042	MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
2043	return RC_OK;
2044	}
2045	}
2046	j++;
2047	}
2048	return MSDOS_NAME_NOT_FOUND_ERR;
2049	}
2050
2051	int
2052	msdos_sync(rtems_libio_t *iop)
2053	{
2054	int rc = RC_OK;
2055	rtems_status_code sc = RTEMS_SUCCESSFUL;
2056	msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
2057
2058	sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
2059	MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
2060	if (sc != RTEMS_SUCCESSFUL)
2061	rtems_set_errno_and_return_minus_one(EIO);
2062
2063	rc = fat_sync(&fs_info->fat);
2064
2065	rtems_semaphore_release(fs_info->vol_sema);
2066	return rc;
2067	}

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

Context Navigation

source: rtems/cpukit/libfs/src/dosfs/msdos_misc.c @ 5ed41a6

Download in other formats: