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

Last change on this file since dd66fda was dd66fda, checked in by Sebastian Huber <sebastian.huber@…>, on Aug 4, 2018 at 8:47:56 AM

tests: Avoid deprecated rtems_disk_io_initialize()

Update #3358.

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