Context Navigation

source: rtems/testsuites/fstests/fsdosfsformat01/init.c @ e89ed92

4.115

Last change on this file since e89ed92 was 0098c522, checked in by Ralf Kirchner <ralf.kirchner@…>, on 10/18/13 at 16:07:10
fsdosfsformat01: Add test for re-mount of a filesystem
Property mode set to `100644`
File size: 14.7 KB

Line
1	/*
2	* Copyright (c) 2012 embedded brains GmbH. All rights reserved.
3	*
4	* embedded brains GmbH
5	* Obere Lagerstr. 30
6	* 82178 Puchheim
7	* Germany
8	* <rtems@embedded-brains.de>
9	*
10	* The license and distribution terms for this file_name may be
11	* found in the file_name LICENSE in this distribution or at
12	* http://www.rtems.com/license/LICENSE.
13	*/
14
15	#ifdef HAVE_CONFIG_H
16	#include "config.h"
17	#endif
18
19	#include "tmacros.h"
20
21	#include <fcntl.h>
22	#include <inttypes.h>
23	#include <sys/statvfs.h>
24	#include <rtems/libio.h>
25	#include <rtems/blkdev.h>
26	#include <rtems/dosfs.h>
27	#include <rtems/sparse-disk.h>
28
29	#include <bsp.h>
30
31	#define MAX_PATH_LENGTH 100 /* Maximum number of characters per path */
32	#define SECTOR_SIZE 512 /* sector size (bytes) */
33	#define FAT12_MAX_CLN 4085 /* maximum + 1 number of clusters for FAT12 */
34	#define FAT16_MAX_CLN 65525 /* maximum + 1 number of clusters for FAT16 */
35	#define FAT12_DEFAULT_SECTORS_PER_CLUSTER 8 /* Default number of sectors per cluster for FAT12 */
36	#define FAT16_DEFAULT_SECTORS_PER_CLUSTER 32 /* Default number of sectors per cluster for FAT16 */
37
38	static void test_disk_params(
39	const char *dev_name,
40	const char *mount_dir,
41	const blksize_t sector_size,
42	const blksize_t cluster_size,
43	const blkcnt_t sectors_per_cluster )
44	{
45	int rv;
46	int fildes;
47	struct stat stat_buff;
48	char file_name[MAX_PATH_LENGTH + 1];
49	ssize_t num_bytes;
50	unsigned int value = (unsigned int) -1;
51
52
53	snprintf( file_name, MAX_PATH_LENGTH, "%s/file1.txt", mount_dir );
54	memset( &stat_buff, 0, sizeof( stat_buff ) );
55
56	rv = mount( dev_name,
57	mount_dir,
58	RTEMS_FILESYSTEM_TYPE_DOSFS,
59	RTEMS_FILESYSTEM_READ_WRITE,
60	NULL );
61	rtems_test_assert( 0 == rv );
62
63	fildes = open( file_name,
64	O_RDWR \| O_CREAT \| O_TRUNC,
65	S_IRUSR \| S_IWUSR \| S_IRGRP \| S_IROTH );
66	rtems_test_assert( -1 != fildes );
67
68	num_bytes = write( fildes, &value, sizeof( value ) );
69	rtems_test_assert( sizeof( value ) == num_bytes );
70
71	rv = fstat( fildes, &stat_buff );
72	rtems_test_assert( 0 == rv );
73	rtems_test_assert( S_ISREG( stat_buff.st_mode ) );
74	rtems_test_assert( sizeof( value ) == stat_buff.st_size );
75	rtems_test_assert( cluster_size == stat_buff.st_blksize );
76	rtems_test_assert( sectors_per_cluster
77	== ( stat_buff.st_blocks * sector_size / 512 ) );
78	rtems_test_assert( ( ( ( stat_buff.st_size + cluster_size
79	- 1 ) / cluster_size ) * cluster_size / 512 )
80	== stat_buff.st_blocks );
81	rv = close( fildes );
82	rtems_test_assert( 0 == rv );
83
84	rv = unmount( mount_dir );
85	rtems_test_assert( 0 == rv );
86
87	/* See if we can re-mount the file system */
88	rv = mount( dev_name,
89	mount_dir,
90	RTEMS_FILESYSTEM_TYPE_DOSFS,
91	RTEMS_FILESYSTEM_READ_WRITE,
92	NULL );
93	rtems_test_assert( 0 == rv );
94
95	rv = unmount( mount_dir );
96	rtems_test_assert( 0 == rv );
97	}
98
99	static void test_create_file(
100	const char *mount_dir,
101	uint32_t file_idx,
102	bool expect_ok )
103	{
104	char file_name[MAX_PATH_LENGTH + 1];
105	int fd;
106
107
108	snprintf( file_name,
109	MAX_PATH_LENGTH,
110	"%s/file%" PRIu32 ".txt",
111	mount_dir,
112	file_idx );
113	fd = open( file_name,
114	O_RDWR \| O_CREAT \| O_TRUNC,
115	S_IRUSR \| S_IWUSR \| S_IRGRP \| S_IROTH );
116
117	if ( expect_ok ) {
118	int rv;
119
120	rtems_test_assert( fd >= 0 );
121
122	rv = close( fd );
123	rtems_test_assert( rv == 0 );
124	} else {
125	rtems_test_assert( fd == -1 );
126	}
127	}
128
129	static void test_file_creation(
130	const char *dev_name,
131	const char *mount_dir,
132	const uint32_t number_of_files )
133	{
134	int rv;
135	uint32_t file_idx;
136	char file_name[MAX_PATH_LENGTH + 1];
137
138
139	rv = mount( dev_name,
140	mount_dir,
141	RTEMS_FILESYSTEM_TYPE_DOSFS,
142	RTEMS_FILESYSTEM_READ_WRITE,
143	NULL );
144	rtems_test_assert( 0 == rv );
145
146	for ( file_idx = 0; file_idx < number_of_files; ++file_idx ) {
147	test_create_file( mount_dir, file_idx, true );
148	}
149
150	test_create_file( mount_dir, file_idx, false );
151
152	for ( file_idx = 0; file_idx < number_of_files; ++file_idx ) {
153	snprintf( file_name,
154	MAX_PATH_LENGTH,
155	"%s/file%" PRIu32 ".txt",
156	mount_dir,
157	file_idx );
158	rv = unlink( file_name );
159	rtems_test_assert( 0 == rv );
160	}
161
162	rv = unmount( mount_dir );
163	rtems_test_assert( 0 == rv );
164	}
165
166	static void test( void )
167	{
168	rtems_status_code sc;
169	int rv;
170	const char dev_name[] = "/dev/rda";
171	const char mount_dir[] = "/mnt";
172	msdos_format_request_param_t rqdata;
173	rtems_blkdev_bnum media_block_count;
174
175	memset( &rqdata, 0, sizeof( rqdata ) );
176
177	sc = rtems_disk_io_initialize();
178	rtems_test_assert( sc == RTEMS_SUCCESSFUL );
179
180	rv = mkdir( mount_dir, S_IRWXU \| S_IRWXG \| S_IRWXO );
181	rtems_test_assert( 0 == rv );
182
183	/* FAT12 */
184	/* For 1.44 MB disks */
185	sc = rtems_sparse_disk_create_and_register(
186	dev_name,
187	SECTOR_SIZE,
188	64,
189	2880,
190	0
191	);
192	rtems_test_assert( RTEMS_SUCCESSFUL == sc );
193
194	/* Optimized for disk space */
195	rqdata.OEMName = NULL;
196	rqdata.VolLabel = NULL;
197	rqdata.sectors_per_cluster = 1;
198	rqdata.fat_num = 1;
199	rqdata.files_per_root_dir = 32;
200	rqdata.media = 0; /* Media code. 0 == Default */
201	rqdata.quick_format = true;
202	rqdata.skip_alignment = true;
203	rv = msdos_format( dev_name, &rqdata );
204	rtems_test_assert( rv == 0 );
205	test_disk_params( dev_name, mount_dir, SECTOR_SIZE, SECTOR_SIZE, 1 );
206	test_file_creation( dev_name, mount_dir, rqdata.files_per_root_dir );
207
208	/* Try formatting with invalid values */
209	rqdata.OEMName = NULL;
210	rqdata.VolLabel = NULL;
211	rqdata.sectors_per_cluster = 1;
212	rqdata.fat_num = 7; /* Invalid number of fats */
213	rqdata.files_per_root_dir = 32;
214	rqdata.media = 0; /* Media code. 0 == Default */
215	rqdata.quick_format = true;
216	rqdata.skip_alignment = true;
217	rv = msdos_format( dev_name, &rqdata );
218	rtems_test_assert( rv != 0 );
219
220	rqdata.OEMName = NULL;
221	rqdata.VolLabel = NULL;
222	rqdata.sectors_per_cluster = 1;
223	rqdata.fat_num = 1;
224	rqdata.files_per_root_dir = 32;
225	rqdata.media = 0x11; /* Invalid media code */
226	rqdata.quick_format = true;
227	rqdata.skip_alignment = true;
228	rv = msdos_format( dev_name, &rqdata );
229	rtems_test_assert( rv != 0 );
230
231	/* Optimized for read/write speed */
232	rqdata.OEMName = NULL;
233	rqdata.VolLabel = NULL;
234	rqdata.sectors_per_cluster = 8;
235	rqdata.fat_num = 0;
236	rqdata.files_per_root_dir = 0;
237	rqdata.media = 0; /* Media code. 0 == Default */
238	rqdata.quick_format = true;
239	rqdata.skip_alignment = false;
240	rv = msdos_format( dev_name, &rqdata );
241	rtems_test_assert( rv == 0 );
242	test_disk_params( dev_name,
243	mount_dir,
244	SECTOR_SIZE,
245	SECTOR_SIZE * rqdata.sectors_per_cluster,
246	rqdata.sectors_per_cluster );
247
248	/* The same disk formatted with FAT16 because sectors per cluster is too high
249	* for FAT12 */
250	rqdata.OEMName = NULL;
251	rqdata.VolLabel = NULL;
252	rqdata.sectors_per_cluster = 16;
253	rqdata.fat_num = 1;
254	rqdata.files_per_root_dir = 32;
255	rqdata.media = 0; /* Media code. 0 == Default */
256	rqdata.quick_format = true;
257	rqdata.skip_alignment = false;
258	rv = msdos_format( dev_name, &rqdata );
259	rtems_test_assert( rv == 0 );
260	test_disk_params( dev_name,
261	mount_dir,
262	SECTOR_SIZE,
263	SECTOR_SIZE * rqdata.sectors_per_cluster,
264	rqdata.sectors_per_cluster );
265
266	rv = unlink( dev_name );
267	rtems_test_assert( rv == 0 );
268
269	/* Largest FAT12 disk */
270	sc = rtems_sparse_disk_create_and_register(
271	dev_name,
272	SECTOR_SIZE,
273	64,
274	( FAT12_MAX_CLN * FAT12_DEFAULT_SECTORS_PER_CLUSTER ) - 1L,
275	0
276	);
277	rtems_test_assert( RTEMS_SUCCESSFUL == sc );
278
279	/* Default parameters (corresponds to optimization for read/write speed) */
280	rv = msdos_format( dev_name, NULL );
281	rtems_test_assert( rv == 0 );
282	test_disk_params( dev_name,
283	mount_dir,
284	SECTOR_SIZE,
285	SECTOR_SIZE * FAT12_DEFAULT_SECTORS_PER_CLUSTER,
286	FAT12_DEFAULT_SECTORS_PER_CLUSTER );
287
288	rv = unlink( dev_name );
289	rtems_test_assert( rv == 0 );
290
291	/* FAT16 */
292	sc = rtems_sparse_disk_create_and_register(
293	dev_name,
294	SECTOR_SIZE,
295	1024,
296	( FAT12_MAX_CLN * FAT12_DEFAULT_SECTORS_PER_CLUSTER ) + 1L,
297	0
298	);
299	rtems_test_assert( RTEMS_SUCCESSFUL == sc );
300
301	/* Optimized for disk space */
302	rqdata.OEMName = NULL;
303	rqdata.VolLabel = NULL;
304	rqdata.sectors_per_cluster = 1;
305	rqdata.fat_num = 1;
306	rqdata.files_per_root_dir = 32;
307	rqdata.media = 0; /* Media code. 0 == Default */
308	rqdata.quick_format = true;
309	rqdata.skip_alignment = true;
310	rv = msdos_format( dev_name, &rqdata );
311	rtems_test_assert( rv == 0 );
312	test_disk_params( dev_name,
313	mount_dir,
314	SECTOR_SIZE,
315	rqdata.sectors_per_cluster * SECTOR_SIZE,
316	rqdata.sectors_per_cluster );
317
318	rv = unlink( dev_name );
319	rtems_test_assert( rv == 0 );
320
321	sc = rtems_sparse_disk_create_and_register(
322	dev_name,
323	SECTOR_SIZE,
324	1024,
325	( FAT16_MAX_CLN * FAT16_DEFAULT_SECTORS_PER_CLUSTER ) - 1L,
326	0
327	);
328	rtems_test_assert( RTEMS_SUCCESSFUL == sc );
329
330	/* Optimized for read/write speed */
331	rqdata.OEMName = NULL;
332	rqdata.VolLabel = NULL;
333	rqdata.sectors_per_cluster = 64;
334	rqdata.fat_num = 0;
335	rqdata.files_per_root_dir = 0;
336	rqdata.media = 0; /* Media code. 0 == Default */
337	rqdata.quick_format = true;
338	rqdata.skip_alignment = false;
339	rv = msdos_format( dev_name, &rqdata );
340	rtems_test_assert( rv == 0 );
341	test_disk_params( dev_name,
342	mount_dir,
343	SECTOR_SIZE,
344	SECTOR_SIZE * rqdata.sectors_per_cluster,
345	rqdata.sectors_per_cluster );
346
347	/* Default parameters (corresponds to optimization for read/write speed) */
348	rv = msdos_format( dev_name, NULL );
349	rtems_test_assert( rv == 0 );
350	test_disk_params( dev_name,
351	mount_dir,
352	SECTOR_SIZE,
353	SECTOR_SIZE * FAT16_DEFAULT_SECTORS_PER_CLUSTER,
354	FAT16_DEFAULT_SECTORS_PER_CLUSTER );
355
356	rv = unlink( dev_name );
357	rtems_test_assert( rv == 0 );
358
359	sc = rtems_sparse_disk_create_and_register(
360	dev_name,
361	SECTOR_SIZE,
362	1024,
363	( FAT16_MAX_CLN + 10 ) * 64,
364	0
365	);
366	rtems_test_assert( RTEMS_SUCCESSFUL == sc );
367
368	rqdata.OEMName = NULL;
369	rqdata.VolLabel = NULL;
370	rqdata.sectors_per_cluster = 64;
371	rqdata.fat_num = 0;
372	rqdata.files_per_root_dir = 0;
373	rqdata.media = 0; /* Media code. 0 == Default */
374	rqdata.quick_format = true;
375	rqdata.skip_alignment = false;
376	rv = msdos_format( dev_name, &rqdata );
377	rtems_test_assert( rv == 0 );
378	test_disk_params( dev_name,
379	mount_dir,
380	SECTOR_SIZE,
381	SECTOR_SIZE * rqdata.sectors_per_cluster,
382	rqdata.sectors_per_cluster );
383	rv = unlink( dev_name );
384	rtems_test_assert( rv == 0 );
385
386	/* Format some disks from 1MB up to 128GB */
387	rqdata.OEMName = NULL;
388	rqdata.VolLabel = NULL;
389	rqdata.sectors_per_cluster = 64;
390	rqdata.fat_num = 0;
391	rqdata.files_per_root_dir = 0;
392	rqdata.media = 0;
393	rqdata.quick_format = true;
394	rqdata.skip_alignment = false;
395	for (
396	media_block_count = 1 * 1024 * ( 1024 / SECTOR_SIZE );
397	media_block_count <= 128 * 1024 * 1024 * ( 1024 / SECTOR_SIZE );
398	media_block_count *= 2
399	) {
400	sc = rtems_sparse_disk_create_and_register(
401	dev_name,
402	SECTOR_SIZE,
403	64,
404	media_block_count,
405	0
406	);
407	rtems_test_assert( sc == RTEMS_SUCCESSFUL );
408
409	rv = msdos_format( dev_name, &rqdata );
410	rtems_test_assert( rv == 0 );
411
412	test_disk_params(
413	dev_name,
414	mount_dir,
415	SECTOR_SIZE,
416	SECTOR_SIZE * rqdata.sectors_per_cluster,
417	rqdata.sectors_per_cluster
418	);
419
420	rv = unlink( dev_name );
421	rtems_test_assert( rv == 0 );
422	}
423
424	/* FAT32 */
425
426	sc = rtems_sparse_disk_create_and_register(
427	dev_name,
428	SECTOR_SIZE,
429	1024,
430	( FAT16_MAX_CLN * FAT16_DEFAULT_SECTORS_PER_CLUSTER ) + 41L,
431	0
432	);
433	rtems_test_assert( RTEMS_SUCCESSFUL == sc );
434
435	/* Default parameters */
436	rv = msdos_format( dev_name, NULL );
437	rtems_test_assert( rv == 0 );
438	test_disk_params( dev_name, mount_dir, SECTOR_SIZE, SECTOR_SIZE, 1 );
439	rv = unlink( dev_name );
440	rtems_test_assert( rv == 0 );
441
442	sc = rtems_sparse_disk_create_and_register(
443	dev_name,
444	SECTOR_SIZE,
445	1024,
446	( FAT16_MAX_CLN + 20 ) * 64L,
447	0
448	);
449	rtems_test_assert( RTEMS_SUCCESSFUL == sc );
450
451	/* Optimized for read/write speed */
452	rqdata.OEMName = NULL;
453	rqdata.VolLabel = NULL;
454	rqdata.sectors_per_cluster = 64;
455	rqdata.fat_num = 0;
456	rqdata.files_per_root_dir = 0;
457	rqdata.media = 0; /* Media code. 0 == Default */
458	rqdata.quick_format = true;
459	rqdata.skip_alignment = false;
460	rv = msdos_format( dev_name, &rqdata );
461	rtems_test_assert( rv == 0 );
462	test_disk_params( dev_name,
463	mount_dir,
464	SECTOR_SIZE,
465	SECTOR_SIZE * rqdata.sectors_per_cluster,
466	rqdata.sectors_per_cluster );
467
468	rv = unlink( dev_name );
469	rtems_test_assert( rv == 0 );
470	}
471
472	static void Init( rtems_task_argument arg )
473	{
474	puts( "\n\n* TEST FSDOSFSFORMAT 1 *" );
475
476	test();
477
478	puts( "* END OF TEST FSDOSFSFORMAT 1 *" );
479
480	rtems_test_exit( 0 );
481	}
482
483	#define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
484	#define CONFIGURE_APPLICATION_NEEDS_CONSOLE_DRIVER
485	#define CONFIGURE_APPLICATION_NEEDS_LIBBLOCK
486
487	/* one active file + stdin + stdout + stderr + device file when mounted */
488	#define CONFIGURE_LIBIO_MAXIMUM_FILE_DESCRIPTORS 5
489
490	#define CONFIGURE_USE_IMFS_AS_BASE_FILESYSTEM
491
492	#define CONFIGURE_FILESYSTEM_DOSFS
493
494	#define CONFIGURE_MAXIMUM_TASKS 1
495	#define CONFIGURE_MAXIMUM_SEMAPHORES 1
496
497	#define CONFIGURE_INIT_TASK_STACK_SIZE ( 32 * 1024 )
498
499	#define CONFIGURE_RTEMS_INIT_TASKS_TABLE
500
501	#define CONFIGURE_BDBUF_BUFFER_MAX_SIZE ( 32 * 1024 )
502
503	#define CONFIGURE_INIT
504
505	#include <rtems/confdefs.h>

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

Download in other formats: