source: rtems/testsuites/fstests/fsdosfsformat01/init.c @ 97ae79d7

4.11
Last change on this file since 97ae79d7 was 97ae79d7, checked in by Joel Sherrill <joel.sherrill@…>, on Apr 21, 2014 at 2:07:57 PM

fsdosfsformat01: Honor BSP_SMALL_MEMORY

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