source: rtems/testsuites/fstests/fsdosfsformat01/init.c @ 0098c522

4.11
Last change on this file since 0098c522 was 0098c522, checked in by Ralf Kirchner <ralf.kirchner@…>, on Oct 18, 2013 at 4:07:10 PM

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
38static 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
99static 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
129static 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
166static 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
472static 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.