source: rtems/testsuites/fstests/fsdosfsname01/init.c @ 24b94c4

Last change on this file since 24b94c4 was 24b94c4, checked in by Sebastian Huber <sebastian.huber@…>, on Jul 30, 2018 at 4:39:09 AM

ramdisk: Use rtems_blkdev_create()

Update #3358.

  • Property mode set to 100644
File size: 35.5 KB
Line 
1/*
2 * Copyright (c) 2012, 2013 embedded brains GmbH.  All rights reserved.
3 *
4 *  embedded brains GmbH
5 *  Dornierstr. 4
6 *  82178 Puchheim
7 *  Germany
8 *  <rtems@embedded-brains.de>
9 *
10 * The license and distribution terms for this file may be
11 * found in the file 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
20#include "tmacros.h"
21
22#include <errno.h>
23#include <fcntl.h>
24#include <dirent.h>
25
26#include <bsp.h>
27#include <rtems/io.h>
28#include <rtems/libio.h>
29#include <rtems/dosfs.h>
30#include <rtems/ramdisk.h>
31#include <rtems/libcsupport.h>
32#include "image.h"
33#include "image_bin_le_singlebyte.h"
34#include "image_bin_le_multibyte.h"
35#include "files.h"
36
37#include <errno.h>
38
39const char rtems_test_name[] = "FSDOSFSNAME 1";
40
41#define PRINT_DISK_IMAGE 0
42
43#define MOUNT_DIR "/mnt"
44#define MOUNT_DIR_SIZE 4
45#define START_DIR_SIZE 4
46#define RAMDISK_PATH "/dev/rda"
47#define BLOCK_NUM 47
48#define BLOCK_SIZE 512
49#define VOLUME_LABEL "MyDisk"
50
51#define NUMBER_OF_DIRECTORIES 8
52#define NUMBER_OF_FILES 13
53#define NUMBER_OF_DIRECTORIES_INVALID 25
54#define NUMBER_OF_DIRECTORIES_DUPLICATED 3
55#define NUMBER_OF_MULTIBYTE_NAMES_DUPLICATED 2
56#define NUMBER_OF_FILES_DUPLICATED 2
57#define NUMBER_OF_NAMES_MULTIBYTE 10
58#define MAX_NAME_LENGTH ( 255 + 1 )
59#define MAX_NAME_LENGTH_INVALID ( 255 + 2 )
60#define MAX_DUPLICATES_PER_NAME 3
61static const char UTF8_BOM[] = {0xEF, 0xBB, 0xBF};
62#define UTF8_BOM_SIZE 3 /* Size of the UTF-8 byte-order-mark */
63
64#define BLOCK_SIZE 512
65
66static rtems_resource_snapshot            before_mount;
67
68static const msdos_format_request_param_t rqdata = {
69  .OEMName             = "RTEMS",
70  .VolLabel            = VOLUME_LABEL,
71  .sectors_per_cluster = 2,
72  .fat_num             = 0,
73  .files_per_root_dir  = 0,
74  .media               = 0,
75  .quick_format        = true,
76  .skip_alignment      = 0,
77  .info_level          = 0
78};
79
80static const char                         DIRECTORY_NAMES[NUMBER_OF_DIRECTORIES]
81[MAX_NAME_LENGTH] = {
82  "a dir",
83  "Shortdir",
84  "shrtdir",
85  "shrt.dir",
86  "long_conventional_dir",
87  "long_conventional.dir",
88  "LongConventionalDir",
89  "This is a directory name with with 255 characters. The following numbers are aligned in that way, that the character 0 is the mentioned one. xxxxxx150xxxxxxx160xxxxxxx170xxxxxxx180xxxxxxx190xxxxxxx200xxxxxxx210xxxxxxx220xxxxxxx230xxxxxxx240xxxxxxx250xxxxx"
90};
91
92static const char DIRECTORY_NAMES_INVALID[
93  NUMBER_OF_DIRECTORIES_INVALID][MAX_NAME_LENGTH_INVALID] = {
94  "This is a directory name with with 256 characters. The following numbers are aligned in that way, that the character 0 is the mentioned one. xxxxxx150xxxxxxx160xxxxxxx170xxxxxxx180xxxxxxx190xxxxxxx200xxxxxxx210xxxxxxx220xxxxxxx230xxxxxxx240xxxxxxx250xxxxxx",
95  ".",
96  "..",
97  "...",
98  " ",
99  "... ...",
100  " ... ",
101  "",
102  "*",
103  "/",
104  ":",
105  "<",
106  ">",
107  "?",
108  "\\",
109  "|",
110  { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
111    10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
112    20, 21, 22, 23, 24, 25, 26, 17, 28, 29, 30, 31},
113  {127},
114  "э*_тП ЎлОММПе ОЌя",
115  "э:_тП ЎлОММПе ОЌя",
116  "э<_тП ЎлОММПе ОЌя",
117  "э>_тП ЎлОММПе ОЌя",
118  "э?_тП ЎлОММПе ОЌя",
119  "э|_тП ЎлОММПе ОЌя"
120};
121
122static const char NAMES_MULTIBYTE[
123  NUMBER_OF_NAMES_MULTIBYTE][MAX_NAME_LENGTH] = {
124  "đây là một tên tập tin dài",
125  "Bu uzun bir dosya adı",
126  "هذا هو اسم ملف طويل",
127  "αυτό είΜαι έΜα Όεγάλο όΜοΌα αρχείου",
128  "этП ЎлОММПе ОЌя",
129  "гэта ЎПўгае іЌя",
130  "тПва е ЎългП ОЌе Ма файла",
131  "这是䞀䞪长文件名",
132  "shrtname",
133  "long_conventional_name"
134};
135
136static const char NAMES_MULTIBYTE_IN_CODEPAGE_FORMAT[
137  NUMBER_OF_NAMES_MULTIBYTE][MAX_NAME_LENGTH] = {
138  "_\2030005~1._t",
139  "bu0008~1.bir",
140  "__000b~1.__",
141  "__000f~1.__",
142  "__0012~1.___",
143  "__0015~1.___",
144  "__0018~1.___",
145  "__001a~1",
146  "shrtname",
147  "long_conventional_name"
148};
149
150static const char FILE_NAMES[NUMBER_OF_FILES][
151  MAX_NAME_LENGTH] = {
152  "a file",
153  "shrtfile",
154  "ShrtFle",
155  "The quick brown.fox",
156  "long_conventional_file",
157  "This is a filename with with 255 characters. The following numbers are aligned in that way, that the character 0 is the mentioned one. xx140xxxxxxx150xxxxxxx160xxxxxxx170xxxxxxx180xxxxxxx190xxxxxxx200xxxxxxx210xxxxxxx220xxxxxxx230xxxxxxx240xxxxxxx250xxxxx",
158  "+",
159  ",",
160  "a.a",
161  ";",
162  "=",
163  "[",
164  "]"
165};
166
167typedef struct {
168  char name[MAX_NAME_LENGTH];
169  unsigned int number_of_duplicates;
170  char name_duplicates[MAX_DUPLICATES_PER_NAME][MAX_NAME_LENGTH];
171} name_duplicates;
172
173static const name_duplicates DIRECTORY_DUPLICATES[
174  NUMBER_OF_DIRECTORIES_DUPLICATED] = {
175  {
176    "shrtdir",
177    3,
178    {
179      "shrtdir",
180      "SHRTDIR",
181      "Shrtdir"
182    }
183  },
184  {
185    "Kurzdir",
186    3,
187    {
188      "kurzdir",
189      "KURZDIR",
190      "Kurzdir"
191    }
192  },
193  {
194    "long_conventional_dir",
195    3,
196    {
197      "long_conventional_dir",
198      "LONG_CONVENTIONAL_DIR",
199      "Long_conventional_dir"
200    }
201  }
202};
203
204static const name_duplicates MULTIBYTE_DUPLICATES[
205  NUMBER_OF_MULTIBYTE_NAMES_DUPLICATED] = {
206  {
207    /* The angstroem encoded differently. These encodings might become short entries */
208    {0xc3, 0x85}, /* '̊A' */
209    2,
210    {
211      {0xc3, 0x85}, /* '̊A' */
212      {0xe2, 0x84, 0xab} /* 'Å' */
213    }
214  },
215
216  /* Again the angstroem encoded differently,
217   * but this time with additional characters in order to enforce a long entry. */
218  {
219    {'1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', 0xc3,
220     0x85},
221    2,
222    {
223      {'1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', 0xc3,
224       0x85},
225      {'1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', 0xe2,
226       0x84, 0xab}
227    }
228  }
229};
230
231
232static const name_duplicates FILES_DUPLICATES[NUMBER_OF_FILES_DUPLICATED] = {
233  {
234    "shrtfile",
235    3,
236    {
237      "shrtfile",
238      "SHRTFILE",
239      "Shrtfile"
240    }
241  },
242  {
243    "long_conventional_file",
244    3,
245    {
246      "long_conventional_file",
247      "LONG_CONVENTIONAL_FILE",
248      "Long_conventional_file"
249    }
250  }
251};
252
253static int path_is_directory( const char *path )
254{
255  struct stat s_buf;
256
257
258  if ( stat( path, &s_buf ) )
259    return 0;
260
261  return S_ISDIR( s_buf.st_mode );
262}
263
264static void delete_folder_tree( const char *directory_name )
265{
266  DIR           *dp;
267  struct dirent *ep;
268  char           p_buf[1024] = {0};
269  int            rc          = 0;
270
271
272  dp = opendir( directory_name );
273  rtems_test_assert( dp != NULL );
274
275  while ( ( ep = readdir( dp ) ) != NULL && rc == 0 ) {
276    if ( 0 != strcmp( ".", ep->d_name )
277         && 0 != strcmp( "..", ep->d_name ) ) {
278      snprintf( p_buf, sizeof( p_buf ), "%s/%s", directory_name, ep->d_name );
279
280      if ( path_is_directory( p_buf ) ) {
281        delete_folder_tree( p_buf );
282        rc = rmdir( p_buf );
283        rtems_test_assert( rc == 0 );
284        rewinddir( dp );
285      } else {
286        rc = unlink( p_buf );
287        rtems_test_assert( rc == 0 );
288        rewinddir( dp );
289      }
290    }
291  }
292
293  rc = closedir( dp );
294  rtems_test_assert( rc == 0 );
295}
296
297static void mount_device( const char *start_dir,
298  const rtems_dosfs_mount_options    *mount_opts )
299{
300  int rc;
301
302  rc = mount(
303    RAMDISK_PATH,
304    MOUNT_DIR,
305    "dosfs",
306    RTEMS_FILESYSTEM_READ_WRITE,
307    mount_opts );
308  rtems_test_assert( rc == 0 );
309
310  rc = mkdir( start_dir, S_IRWXU | S_IRWXG | S_IRWXO );
311  rtems_test_assert( rc == 0 || ( rc == -1 && errno == EEXIST ) );
312}
313
314static void mount_device_with_defaults( const char *start_dir )
315{
316  int rc;
317
318
319  rc = msdos_format( RAMDISK_PATH, &rqdata );
320  rtems_test_assert( rc == 0 );
321
322  rtems_resource_snapshot_take( &before_mount );
323
324  mount_device( start_dir, NULL );
325}
326
327static void mount_device_with_iconv(
328  const char                *start_dir,
329  rtems_dosfs_mount_options *mount_opts
330)
331{
332  int                       rc;
333
334  rc = msdos_format( RAMDISK_PATH, &rqdata );
335  rtems_test_assert( rc == 0 );
336
337  rtems_resource_snapshot_take( &before_mount );
338
339  mount_opts->converter = rtems_dosfs_create_utf8_converter( "CP850" );
340  rtems_test_assert( mount_opts->converter != NULL );
341
342  mount_device( start_dir, mount_opts );
343}
344
345static void unmount_and_close_device( void )
346{
347  int                     rc;
348  rtems_resource_snapshot now;
349  bool                    are_resources_freed;
350
351
352  delete_folder_tree( MOUNT_DIR );
353
354  rc = unmount( MOUNT_DIR );
355  rtems_test_assert( rc == 0 );
356
357  are_resources_freed = rtems_resource_snapshot_check( &before_mount );
358
359  if ( !are_resources_freed )
360    rtems_resource_snapshot_take( &now );
361
362  rtems_test_assert( are_resources_freed );
363}
364
365/*
366 * Simply create a few directories. These tests should all succeed
367 */
368static void test_creating_directories(
369  const char        *start_dir,
370  const char        *directories,
371  const unsigned int number_of_directories )
372{
373  unsigned int   index;
374  int            rc;
375  char           dirname[MAX_NAME_LENGTH + strlen( start_dir ) + 1];
376  DIR           *dirp;
377  struct dirent *dp;
378
379
380  for ( index = 0; index < number_of_directories; ++index ) {
381    snprintf( dirname, sizeof( dirname ), "%s/%s", start_dir, directories
382              + ( index * MAX_NAME_LENGTH ) );
383    rc = mkdir( dirname, S_IRWXU | S_IRWXG | S_IRWXO );
384    rtems_test_assert( rc == 0 );
385  }
386
387  dirp = opendir( start_dir );
388  rtems_test_assert( NULL != dirp );
389
390  index = 0;
391  dp    = readdir( dirp );
392  rtems_test_assert( dp != NULL );
393  rtems_test_assert( 0 == strcmp( ".", dp->d_name ) );
394
395  dp = readdir( dirp );
396  rtems_test_assert( dp != NULL );
397  rtems_test_assert( 0 == strcmp( "..", dp->d_name ) );
398
399  dp = readdir( dirp );
400  rtems_test_assert( dp != NULL );
401
402  while ( dp != NULL ) {
403    rtems_test_assert( 0
404                       == strcmp( directories + ( index * MAX_NAME_LENGTH ),
405                                  dp->d_name ) );
406    ++index;
407    dp = readdir( dirp );
408  }
409
410  rtems_test_assert( number_of_directories == index );
411
412  rc = closedir( dirp );
413  rtems_test_assert( rc == 0 );
414}
415
416/*
417 * Try creating directories with invalid names.
418 */
419static void test_creating_invalid_directories( void )
420{
421  unsigned int index;
422  int          rc;
423  char         dirname[MAX_NAME_LENGTH_INVALID + MOUNT_DIR_SIZE + 1];
424
425
426  for ( index = 0; index < NUMBER_OF_DIRECTORIES_INVALID; ++index ) {
427    snprintf( dirname,
428              sizeof( dirname ),
429              "%s/%s",
430              MOUNT_DIR,
431              DIRECTORY_NAMES_INVALID[index] );
432    rc = mkdir( dirname, S_IRWXU | S_IRWXG | S_IRWXO );
433    rtems_test_assert( rc == -1 );
434  }
435}
436
437/*
438 * Try creating directories which do already exist
439 * (although names may have different capitalization/encoding)
440 */
441static void test_creating_duplicate_directories(
442  const char            *start_dir,
443  const name_duplicates *duplicates,
444  const unsigned int     number_of_duplicates )
445{
446  unsigned int index_dir;
447  unsigned int index_duplicate;
448  int          rc;
449  char         dirname[MAX_NAME_LENGTH + MOUNT_DIR_SIZE + START_DIR_SIZE + 2];
450
451
452  for ( index_dir = 0; index_dir < number_of_duplicates; ++index_dir ) {
453    snprintf( dirname, sizeof( dirname ), "%s/%s", start_dir,
454              duplicates[index_dir].name );
455    rc = mkdir( dirname, S_IRWXU | S_IRWXG | S_IRWXO );
456    rtems_test_assert( rc == 0 );
457
458    for ( index_duplicate = 0;
459          index_duplicate < duplicates[index_dir].number_of_duplicates;
460          ++index_duplicate ) {
461      snprintf( dirname, sizeof( dirname ), "%s/%s", start_dir,
462                duplicates[index_dir].name_duplicates[index_duplicate] );
463      errno = 0;
464      rc = mkdir( dirname, S_IRWXU | S_IRWXG | S_IRWXO );
465      rtems_test_assert( rc == -1 );
466      rtems_test_assert( errno == EEXIST );
467    }
468  }
469}
470
471/*
472 * Try creating and opening files with valid names
473 */
474static void test_handling_files(
475  const char        *dirname,
476  const char        *file_names,
477  const unsigned int number_of_files )
478{
479  unsigned int index;
480  int          rc;
481  char         filename[MAX_NAME_LENGTH * 2 + MOUNT_DIR_SIZE + START_DIR_SIZE
482                        + 4];
483  int          fd;
484
485
486  for ( index = 0; index < number_of_files; ++index ) {
487    snprintf(
488      filename,
489      sizeof( filename ) - 1,
490      "%s/%s",
491      dirname,
492      file_names + index * MAX_NAME_LENGTH );
493    fd = open( filename,
494               O_RDWR | O_CREAT,
495               S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH );
496    rtems_test_assert( fd >= 0 );
497
498    rc = close( fd );
499    rtems_test_assert( rc == 0 );
500
501    /* See if the file still exists and can be found */
502    fd = open( filename, O_RDWR );
503    rtems_test_assert( fd >= 0 );
504
505    rc = close( fd );
506    rtems_test_assert( rc == 0 );
507  }
508}
509
510/*
511 * Try to find (and open) all of the file names from an
512 * array in a given directory
513 */
514static void test_finding_files(
515  const char        *dirname,
516  const char        *file_names,
517  const unsigned int number_of_files )
518{
519  int            rc;
520  DIR           *dir_stream;
521  struct dirent *dp;
522  int            fd;
523  unsigned int   index_file;
524  char           filename[MAX_NAME_LENGTH * 2 + MOUNT_DIR_SIZE
525                          + START_DIR_SIZE + 4];
526
527
528  dir_stream = opendir( dirname );
529  rtems_test_assert( dir_stream != NULL );
530
531  dp = readdir( dir_stream );
532  rtems_test_assert( dp != NULL );
533  rtems_test_assert( 0 == strcmp( ".", dp->d_name ) );
534
535  dp = readdir( dir_stream );
536  rtems_test_assert( dp != NULL );
537  rtems_test_assert( 0 == strcmp( "..", dp->d_name ) );
538
539  dp         = readdir( dir_stream );
540  rtems_test_assert( dp != NULL );
541  index_file = 0;
542
543  while ( dp != NULL ) {
544    rtems_test_assert( 0 == strcmp(
545                         file_names + index_file * MAX_NAME_LENGTH,
546                         dp->d_name ) );
547
548    snprintf(
549      filename,
550      sizeof( filename ) - 1,
551      "%s/%s",
552      dirname,
553      file_names + index_file * MAX_NAME_LENGTH );
554
555    /* See if the file still exists and can be found */
556    fd = open( filename, O_RDWR );
557    rtems_test_assert( fd >= 0 );
558
559    rc = close( fd );
560    rtems_test_assert( rc == 0 );
561
562    ++index_file;
563    dp = readdir( dir_stream );
564  }
565
566  rtems_test_assert( number_of_files == index_file );
567
568  rc = closedir( dir_stream );
569  rtems_test_assert( rc == 0 );
570}
571
572/*
573 * Try opening files which do already exist (with different capitalization in their names)
574 */
575static void test_duplicated_files( const char *dirname,
576  const name_duplicates                       *files_duplicated,
577  const unsigned int                           number_of_files_duplicated )
578{
579  unsigned int index_file;
580  unsigned int index_duplicate;
581  int          rc;
582  char         filename[MAX_NAME_LENGTH + strlen( dirname ) + 1];
583  int          fd;
584
585
586  for ( index_file = 0; index_file < number_of_files_duplicated;
587        ++index_file ) {
588    snprintf( filename,
589              sizeof( filename ) - 1,
590              "%s/%s",
591              dirname,
592              files_duplicated[index_file].name );
593    fd = open( filename,
594               O_RDWR | O_CREAT,
595               S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH );
596    rtems_test_assert( fd >= 0 );
597
598    rc = close( fd );
599    rtems_test_assert( rc == 0 );
600
601    for ( index_duplicate = 0;
602          index_duplicate < files_duplicated[index_file].number_of_duplicates;
603          ++index_duplicate ) {
604      snprintf( filename,
605                sizeof( filename ) - 1,
606                "%s/%s",
607                dirname,
608                files_duplicated[index_file].name_duplicates[index_duplicate] );
609      fd = open( filename, O_RDWR );
610      rtems_test_assert( fd >= 0 );
611
612      rc = close( fd );
613      rtems_test_assert( rc == 0 );
614
615      errno = 0;
616      fd = open( filename, O_RDWR | O_CREAT | O_EXCL );
617      rtems_test_assert( fd == -1 );
618      rtems_test_assert( errno == EEXIST );
619    }
620
621    rc = remove( filename );
622    rtems_test_assert( rc == 0 );
623  }
624}
625
626/*
627 * Open and read existing valid directories
628 */
629static void test_handling_directories(
630  const char        *start_dir,
631  const char        *directory_names,
632  const unsigned int number_of_directories,
633  const char        *file_names,
634  const unsigned int number_of_files )
635{
636  unsigned int   index_directory;
637  unsigned int   index_file;
638  int            rc;
639  DIR           *dir_stream;
640  char           dirname[MAX_NAME_LENGTH * 2];
641  struct dirent *dp;
642
643
644  for ( index_directory = 0;
645        index_directory < number_of_directories;
646        ++index_directory ) {
647    snprintf(
648      dirname,
649      sizeof( dirname ) - 1,
650      "%s/%s",
651      start_dir,
652      directory_names + index_directory * MAX_NAME_LENGTH );
653
654    test_handling_files(
655      dirname,
656      file_names,
657      number_of_files );
658
659    dir_stream = opendir( dirname );
660    rtems_test_assert( dir_stream != NULL );
661
662    dp = readdir( dir_stream );
663    rtems_test_assert( dp != NULL );
664    rtems_test_assert( 0 == strcmp( ".", dp->d_name ) );
665
666    dp = readdir( dir_stream );
667    rtems_test_assert( dp != NULL );
668    rtems_test_assert( 0 == strcmp( "..", dp->d_name ) );
669
670    dp         = readdir( dir_stream );
671    rtems_test_assert( dp != NULL );
672    index_file = 0;
673
674    while ( dp != NULL ) {
675      rtems_test_assert( 0 == strcmp(
676                           file_names + index_file * MAX_NAME_LENGTH,
677                           dp->d_name ) );
678      ++index_file;
679      dp = readdir( dir_stream );
680    }
681
682    rtems_test_assert( number_of_files == index_file );
683
684    rc = closedir( dir_stream );
685    rtems_test_assert( rc == 0 );
686  }
687}
688
689/*
690 * Try to find all sub-directories from an array
691 * in a given start directory.
692 * In addition try to find and open files
693 * in these sub-directories.
694 */
695static void test_finding_directories(
696  const char        *start_dir,
697  const char        *directory_names,
698  const unsigned int number_of_directories,
699  const char        *file_names,
700  const unsigned int number_of_files )
701{
702  unsigned int   index_directory;
703  int            rc;
704  DIR           *dir_stream;
705  struct dirent *dp;
706  char           dirname[MAX_NAME_LENGTH * 2];
707
708
709  dir_stream = opendir( start_dir );
710  rtems_test_assert( dir_stream != NULL );
711
712  dp = readdir( dir_stream );
713  rtems_test_assert( dp != NULL );
714  rtems_test_assert( 0 == strcmp( ".", dp->d_name ) );
715
716  dp = readdir( dir_stream );
717  rtems_test_assert( dp != NULL );
718  rtems_test_assert( 0 == strcmp( "..", dp->d_name ) );
719
720  dp              = readdir( dir_stream );
721  rtems_test_assert( dp != NULL );
722  index_directory = 0;
723
724  while ( dp != NULL ) {
725    rtems_test_assert( 0 == strcmp(
726                         directory_names + index_directory * MAX_NAME_LENGTH,
727                         dp->d_name ) );
728
729    snprintf(
730      dirname,
731      sizeof( dirname ) - 1,
732      "%s/%s",
733      start_dir,
734      directory_names + index_directory * MAX_NAME_LENGTH );
735
736    test_finding_files(
737      dirname,
738      file_names,
739      number_of_files );
740
741    ++index_directory;
742    dp = readdir( dir_stream );
743  }
744
745  rtems_test_assert( number_of_directories == index_directory );
746
747  rc = closedir( dir_stream );
748  rtems_test_assert( rc == 0 );
749}
750
751#if (PRINT_DISK_IMAGE != 0)
752static void print_image(
753  const char* include_guard,
754  const char* image_name
755)
756{
757  #define                   BYTES_PER_ROW     8
758  int                       rc;
759  int                       fd;
760  ssize_t                   bytes_read;
761  uint8_t                   buf[BLOCK_SIZE];
762  unsigned int              index_block;
763  unsigned int              index_row;
764  unsigned int              index_column;
765  unsigned int              index_buf;
766#ifdef SHOW_LINE_NUMBERS
767  size_t                    index_row_start = 1;
768#endif /* SWOW_LINE_NUMBERS */
769  size_t                    bytes_written   = 0;
770  const size_t              DISK_SIZE       = BLOCK_SIZE * BLOCK_NUM;
771  const unsigned int        ROWS_PER_BLOCK  = BLOCK_SIZE / BYTES_PER_ROW;
772
773  printf ("/*\n"
774          " *  Declarations for C structure representing a disk image\n"
775          " *\n"
776          " *  WARNING: Automatically generated by init.c -- do not edit!\n"
777          " */\n"
778          "#ifndef %s\n"
779          "#define %s\n"
780          "\n"
781          "#include <sys/types.h>\n"
782          "\n"
783          "#ifdef __cplusplus\n"
784          "extern \"C\" {\n"
785          "#endif /* __cplusplus */\n"
786          "\n"
787          "static unsigned char %s[] = {\n",
788          include_guard,
789          include_guard,
790          image_name);
791  fd = open( RAMDISK_PATH, O_RDWR );
792  rtems_test_assert( fd >= 0 );
793
794  for ( index_block = 0; index_block < BLOCK_NUM; ++index_block )
795  {
796    bytes_read = read( fd, &buf[0], BLOCK_SIZE );
797    rtems_test_assert( bytes_read = BLOCK_SIZE );
798
799    index_buf = 0;
800
801    for ( index_row = 0; index_row < ROWS_PER_BLOCK; ++index_row )
802    {
803      printf( "  " );
804      for ( index_column = 0;
805            index_column < BYTES_PER_ROW;
806            ++index_column ) {
807        printf("0x%02x", buf[index_buf]);
808        ++bytes_written;
809        ++index_buf;
810        if ( bytes_written < DISK_SIZE ) {
811          printf (", ");
812        } else {
813          printf ("  ");
814        }
815      }
816#ifdef SHOW_LINE_NUMBERS
817      printf( "/* %6u - %6u */", index_row_start, bytes_written );
818      index_row_start = bytes_written + 1;
819#endif /* SWOW_LINE_NUMBERS */
820      printf( "\n" );
821    }
822  }
823
824  rc = close( fd );
825  rtems_test_assert( rc == 0 );
826
827  printf ("};\n"
828          "#ifdef __cplusplus\n"
829          "}\n"
830          "#endif /* __cplusplus */\n"
831          "\n"
832          "#endif /* %s */\n",
833          include_guard);
834}
835#else /* PRINT_DISK_IMAGE */
836static void print_image(
837  const char* include_guard,
838  const char* image_name
839)
840{
841  /* Nothing to be done */
842}
843#endif /* PRINT_DISK_IMAGE */
844
845
846static void compare_files(
847  const char *file0,
848  const char *file1
849)
850{
851  struct stat  stat_buf[2];
852  int          fd[2];
853  unsigned int index;
854  uint8_t      buf[2];
855  ssize_t      bytes_read;
856  int          rc;
857
858  rc = stat( file0 , &stat_buf[0] );
859  rtems_test_assert( rc == 0 );
860  rc = stat( file1 , &stat_buf[1] );
861  rtems_test_assert( rc == 0 );
862
863  rtems_test_assert( stat_buf[0].st_size == stat_buf[1].st_size );
864
865  fd[0] = open( file0, O_RDONLY );
866  rtems_test_assert( fd[0] > 0 );
867  fd[1] = open( file1, O_RDONLY );
868  rtems_test_assert( fd[1] > 0 );
869
870  for ( index = 0; index < stat_buf[0].st_size; ++index ) {
871    bytes_read = read( fd[0], &buf[0], 1 );
872    rtems_test_assert( bytes_read == 1 );
873    bytes_read = read( fd[1], &buf[1], 1 );
874    rtems_test_assert( bytes_read == 1 );
875    rtems_test_assert( buf[0] == buf[1] );
876  }
877  rc = close( fd[0] );
878  rtems_test_assert( rc == 0 );
879  rc = close( fd[1] );
880  rtems_test_assert( rc == 0 );
881}
882
883static void compare_directories(
884  const char *dir0,
885  const char *dir1)
886{
887  int                       rc;
888  DIR                      *dir_stream[2];
889  struct dirent            *dp;
890  struct stat               stat_buf[2];
891  char                     *path[2];
892  const unsigned int        PATH_LENGTH = 1024;
893
894  path[0] = calloc( PATH_LENGTH, sizeof(char) );
895  rtems_test_assert( path[0] != NULL );
896  path[1] = calloc( PATH_LENGTH, sizeof(char) );
897  rtems_test_assert( path[1] != NULL );
898
899  dir_stream[0] = opendir( dir0 );
900  rtems_test_assert( dir_stream[0] != NULL );
901
902  dir_stream[1] = opendir( dir1 );
903  rtems_test_assert( dir_stream[1] != NULL );
904
905  dp = readdir( dir_stream[0] );
906  rtems_test_assert( dp != NULL );
907
908  while ( dp != NULL ) {
909    rc = snprintf(path[0], PATH_LENGTH, "%s/%s", dir0, dp->d_name);
910    rtems_test_assert( rc < PATH_LENGTH );
911    rtems_test_assert( rc >= 0 );
912    rc = snprintf(path[1], PATH_LENGTH, "%s/%s", dir1, dp->d_name);
913    rtems_test_assert( rc < PATH_LENGTH );
914    rtems_test_assert( rc >= 0 );
915
916    rc = stat( path[0] , &stat_buf[0] );
917    rtems_test_assert( rc == 0 );
918
919    if (   ( strcmp( dp->d_name, "."  ) != 0)
920        && ( strcmp( dp->d_name, ".." ) != 0) ) {
921      if ( S_ISDIR( stat_buf[0].st_mode ) ) {
922        compare_directories( path[0], path[1] );
923      } else {
924        compare_files( path[0], path[1] );
925      }
926    }
927
928    dp = readdir( dir_stream[0] );
929
930  }
931  rc = closedir( dir_stream[0] );
932  rtems_test_assert( rc == 0 );
933
934  rc = closedir( dir_stream[1] );
935  rtems_test_assert( rc == 0 );
936
937  free (path[0]);
938  free (path[1]);
939}
940
941static void compare_image(
942  const char                      *mount_dir,
943  const char                      *dev,
944  const rtems_dosfs_mount_options *mount_opts )
945{
946  #define MOUNT_DIR2 "/mnt2"
947  int                       rc;
948
949  rc = mount_and_make_target_path(
950    dev,
951    MOUNT_DIR2,
952    RTEMS_FILESYSTEM_TYPE_DOSFS,
953    RTEMS_FILESYSTEM_READ_WRITE,
954    mount_opts );
955  rtems_test_assert( rc == 0 );
956
957  compare_directories(mount_dir, MOUNT_DIR2);
958
959  rc = unmount( MOUNT_DIR2 );
960  rtems_test_assert( rc == 0 );
961
962  rc = rmdir( MOUNT_DIR2 );
963  rtems_test_assert( rc == 0 );
964
965}
966/*
967 * Test the compatibility with a genuine MS Windows FAT file system.
968 */
969static void test_compatibility( void )
970{
971  int                       rc;
972  char                      diskpath[] = "/dev/rdd";
973  rtems_dosfs_mount_options mount_opts;
974  FILE                     *fp;
975  int                       buffer;
976  unsigned int              index_file = 0;
977  unsigned int              index_char;
978  unsigned int              offset;
979  char                      content_buf[MAX_NAME_LENGTH + strlen( MOUNT_DIR )
980                                        + 1];
981  char                      file_path[MAX_NAME_LENGTH + strlen( MOUNT_DIR )
982                                      + 1];
983  DIR                      *dir_stream;
984  struct dirent            *dp;
985
986
987  mount_opts.converter = rtems_dosfs_create_utf8_converter( "CP850" );
988  rtems_test_assert( mount_opts.converter != NULL );
989
990  rc = mount_and_make_target_path(
991    diskpath,
992    MOUNT_DIR,
993    RTEMS_FILESYSTEM_TYPE_DOSFS,
994    RTEMS_FILESYSTEM_READ_WRITE,
995    &mount_opts );
996  rtems_test_assert( rc == 0 );
997
998  dir_stream = opendir( MOUNT_DIR );
999  rtems_test_assert( dir_stream != NULL );
1000
1001  dp = readdir( dir_stream );
1002  rtems_test_assert( dp != NULL );
1003
1004  while ( dp != NULL ) {
1005    index_char = 0;
1006
1007    size_t len = strlen( filenames[index_file] );
1008
1009    if ( filenames[index_file][len - 1] == '.' )
1010      rtems_test_assert( ( len - 1 ) == dp->d_namlen );
1011    else
1012      rtems_test_assert( len == dp->d_namlen );
1013
1014    rtems_test_assert( 0
1015                       == memcmp( &filenames[index_file][0], &dp->d_name[0],
1016                                  dp->d_namlen ) );
1017
1018    snprintf( file_path, sizeof( file_path ), "%s/%s", MOUNT_DIR,
1019              filenames[index_file] );
1020    fp = fopen( file_path, "r" );
1021    rtems_test_assert( fp != NULL );
1022
1023    /* These files should contain their own file names. */
1024    while ( ( buffer = fgetc( fp ) ) != EOF ) {
1025      content_buf[index_char] = buffer;
1026      ++index_char;
1027    }
1028
1029    if ( 0 == strncmp( content_buf, UTF8_BOM, UTF8_BOM_SIZE ) )
1030      offset = UTF8_BOM_SIZE;
1031    else
1032      offset = 0;
1033
1034    rtems_test_assert( 0
1035                       == memcmp( filenames[index_file],
1036                                  &content_buf[offset],
1037                                  index_char - offset ) );
1038
1039    rc = fclose( fp );
1040    rtems_test_assert( rc == 0 );
1041
1042    ++index_file;
1043    dp = readdir( dir_stream );
1044  }
1045
1046  rtems_test_assert( index_file == FILES_FILENAMES_NUMBER_OF );
1047
1048  rc = closedir( dir_stream );
1049  rtems_test_assert( rc == 0 );
1050
1051  rc = unmount( MOUNT_DIR );
1052  rtems_test_assert( rc == 0 );
1053}
1054
1055static void test_end_of_string_matches( void )
1056{
1057  int rc;
1058
1059  rc = mkdir( MOUNT_DIR "/lib.beam", S_IRWXU | S_IRWXG | S_IRWXO );
1060  rtems_test_assert( rc == 0 );
1061
1062  errno = 0;
1063  rc = unlink( MOUNT_DIR "/proc_lib.beam" );
1064  rtems_test_assert( rc == -1 );
1065  rtems_test_assert( errno == ENOENT );
1066
1067  rc = unlink( MOUNT_DIR "/lib.beam" );
1068  rtems_test_assert( rc == 0 );
1069}
1070
1071static void test_end_of_string_matches_2( void )
1072{
1073  int rc;
1074  int fd;
1075
1076  fd = open( MOUNT_DIR "/ets.beam", O_RDWR | O_CREAT,
1077             S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH );
1078  rtems_test_assert( fd >= 0 );
1079  rc = close( fd );
1080  rtems_test_assert( rc == 0 );
1081
1082  fd = open( MOUNT_DIR "/sets.beam", O_RDWR | O_CREAT,
1083             S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH );
1084  rtems_test_assert( fd >= 0 );
1085  rc = close( fd );
1086  rtems_test_assert( rc == 0 );
1087
1088  rc = unlink( MOUNT_DIR "/sets.beam" );
1089  rtems_test_assert( rc == 0 );
1090
1091  rc = unlink( MOUNT_DIR "/ets.beam" );
1092  rtems_test_assert( rc == 0 );
1093}
1094
1095static void test_full_8_3_name( void )
1096{
1097  int rc;
1098
1099  rc = mkdir( MOUNT_DIR "/txtvsbin.txt", S_IRWXU | S_IRWXG | S_IRWXO );
1100  rtems_test_assert( rc == 0 );
1101
1102  rc = unlink( MOUNT_DIR "/txtvsbin.txt" );
1103  rtems_test_assert( rc == 0 );
1104}
1105
1106static void test_dir_with_same_name_as_volume_label( void )
1107{
1108  int  rc;
1109  DIR *dirp;
1110
1111  rc = mkdir( MOUNT_DIR "/" VOLUME_LABEL, S_IRWXU | S_IRWXG | S_IRWXO );
1112  rtems_test_assert( rc == 0 );
1113
1114  dirp = opendir( MOUNT_DIR "/" VOLUME_LABEL );
1115  rtems_test_assert( NULL != dirp );
1116
1117  rc = closedir( dirp );
1118  rtems_test_assert( rc == 0 );
1119
1120  rc = unlink( MOUNT_DIR "/" VOLUME_LABEL );
1121  rtems_test_assert( rc == 0 );
1122}
1123
1124static void test_file_with_same_name_as_volume_label( void )
1125{
1126  int rc;
1127  int fd;
1128
1129  fd = open( MOUNT_DIR "/" VOLUME_LABEL, O_RDWR | O_CREAT,
1130             S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH );
1131  rtems_test_assert( fd >= 0 );
1132
1133  rc = close( fd );
1134  rtems_test_assert( rc == 0 );
1135
1136  fd = open( MOUNT_DIR "/" VOLUME_LABEL, O_RDWR );
1137  rtems_test_assert( fd >= 0 );
1138
1139  rc = close( fd );
1140  rtems_test_assert( rc == 0 );
1141
1142  rc = unlink( MOUNT_DIR "/" VOLUME_LABEL );
1143  rtems_test_assert( rc == 0 );
1144}
1145
1146static void test_special_cases( void )
1147{
1148  test_end_of_string_matches();
1149  test_end_of_string_matches_2();
1150  test_full_8_3_name();
1151  test_file_with_same_name_as_volume_label();
1152  test_dir_with_same_name_as_volume_label();
1153}
1154
1155/*
1156 * Main test method
1157 */
1158static void test( void )
1159{
1160  int  rc;
1161  char start_dir[MOUNT_DIR_SIZE + START_DIR_SIZE + 2];
1162  rtems_dosfs_mount_options mount_opts[2];
1163
1164  rc = mkdir( MOUNT_DIR, S_IRWXU | S_IRWXG | S_IRWXO );
1165  rtems_test_assert( rc == 0 );
1166
1167  snprintf( start_dir, sizeof( start_dir ), "%s/%s", MOUNT_DIR, "strt" );
1168
1169  /*
1170   * Tests with code page 850 compatible directory and file names
1171   * and the code page 850 backwards compatible default mode mode of the
1172   * FAT file system
1173   */
1174  mount_device_with_defaults( start_dir );
1175
1176  test_creating_duplicate_directories(
1177    &start_dir[0],
1178    &DIRECTORY_DUPLICATES[0],
1179    NUMBER_OF_DIRECTORIES_DUPLICATED );
1180
1181  unmount_and_close_device();
1182
1183  mount_device_with_defaults( start_dir );
1184
1185  test_duplicated_files(
1186    MOUNT_DIR,
1187    FILES_DUPLICATES,
1188    NUMBER_OF_FILES_DUPLICATED );
1189
1190  unmount_and_close_device();
1191
1192  mount_device_with_defaults( start_dir );
1193
1194  test_creating_invalid_directories();
1195
1196  test_creating_directories(
1197    &start_dir[0],
1198    &DIRECTORY_NAMES[0][0],
1199    NUMBER_OF_DIRECTORIES );
1200
1201  test_handling_directories(
1202    &start_dir[0],
1203    &DIRECTORY_NAMES[0][0],
1204    NUMBER_OF_DIRECTORIES,
1205    &FILE_NAMES[0][0],
1206    NUMBER_OF_FILES );
1207
1208  compare_image(
1209    MOUNT_DIR,
1210    "/dev/rdb",
1211    NULL);
1212
1213  test_special_cases();
1214
1215  rc = unmount( MOUNT_DIR );
1216  rtems_test_assert( rc == 0 );
1217
1218  /*
1219   * Again tests with code page 850 compatible directory and file names
1220   * but with multibyte string compatible conversion methods which use
1221   * iconv and utf8proc
1222   */
1223  mount_opts[0].converter = rtems_dosfs_create_utf8_converter( "CP850" );
1224  rtems_test_assert( mount_opts[0].converter != NULL );
1225
1226  rc                     = mount(
1227    RAMDISK_PATH,
1228    MOUNT_DIR,
1229    "dosfs",
1230    RTEMS_FILESYSTEM_READ_WRITE,
1231    &mount_opts );
1232  rtems_test_assert( rc == 0 );
1233
1234  test_finding_directories(
1235    &start_dir[0],
1236    &DIRECTORY_NAMES[0][0],
1237    NUMBER_OF_DIRECTORIES,
1238    &FILE_NAMES[0][0],
1239    NUMBER_OF_FILES );
1240  unmount_and_close_device();
1241
1242  mount_device_with_iconv( start_dir, &mount_opts[0] );
1243  test_creating_invalid_directories();
1244
1245  test_creating_duplicate_directories(
1246    &start_dir[0],
1247    &DIRECTORY_DUPLICATES[0],
1248    NUMBER_OF_DIRECTORIES_DUPLICATED );
1249
1250  unmount_and_close_device();
1251
1252  mount_device_with_iconv( start_dir, &mount_opts[0] );
1253
1254  test_duplicated_files(
1255    MOUNT_DIR,
1256    FILES_DUPLICATES,
1257    NUMBER_OF_FILES_DUPLICATED );
1258
1259  unmount_and_close_device();
1260
1261  mount_device_with_iconv( start_dir, &mount_opts[0] );
1262
1263  test_creating_directories(
1264    &start_dir[0],
1265    &DIRECTORY_NAMES[0][0],
1266    NUMBER_OF_DIRECTORIES );
1267
1268  test_handling_directories(
1269    &start_dir[0],
1270    &DIRECTORY_NAMES[0][0],
1271    NUMBER_OF_DIRECTORIES,
1272    &FILE_NAMES[0][0],
1273    NUMBER_OF_FILES );
1274
1275  mount_opts[1].converter = rtems_dosfs_create_utf8_converter( "CP850" );
1276  rtems_test_assert( mount_opts[1].converter != NULL );
1277
1278  compare_image(
1279    MOUNT_DIR,
1280    "/dev/rdb",
1281    &mount_opts[1]);
1282
1283  test_special_cases();
1284
1285  rc = unmount( MOUNT_DIR );
1286  rtems_test_assert( rc == 0 );
1287
1288  print_image(
1289      "IMAGE_BIN_LE_SINGLEBYTE_H_",
1290      "IMAGE_BIN_LE_SINGLEBYTE");
1291
1292  rc = mount(
1293    RAMDISK_PATH,
1294    MOUNT_DIR,
1295    "dosfs",
1296    RTEMS_FILESYSTEM_READ_WRITE,
1297    NULL );
1298  rtems_test_assert( rc == 0 );
1299
1300  unmount_and_close_device();
1301
1302
1303  /*
1304   * Tests with multibyte directory and file names and
1305   * with multibyte string compatible conversion methods which use
1306   * iconv and utf8proc
1307   */
1308  mount_device_with_iconv( start_dir, &mount_opts[0] );
1309
1310  test_creating_duplicate_directories(
1311    &start_dir[0],
1312    &MULTIBYTE_DUPLICATES[0],
1313    NUMBER_OF_MULTIBYTE_NAMES_DUPLICATED );
1314
1315  unmount_and_close_device();
1316
1317  mount_device_with_iconv( start_dir, &mount_opts[0] );
1318
1319  test_duplicated_files(
1320    MOUNT_DIR,
1321    &MULTIBYTE_DUPLICATES[0],
1322    NUMBER_OF_MULTIBYTE_NAMES_DUPLICATED );
1323
1324  unmount_and_close_device();
1325
1326  mount_device_with_iconv( start_dir, &mount_opts[0] );
1327
1328  test_creating_directories(
1329    &start_dir[0],
1330    &NAMES_MULTIBYTE[0][0],
1331    NUMBER_OF_NAMES_MULTIBYTE );
1332
1333  test_handling_directories(
1334    &start_dir[0],
1335    &NAMES_MULTIBYTE[0][0],
1336    NUMBER_OF_NAMES_MULTIBYTE,
1337    &NAMES_MULTIBYTE[0][0],
1338    NUMBER_OF_NAMES_MULTIBYTE );
1339
1340  mount_opts[1].converter = rtems_dosfs_create_utf8_converter( "CP850" );
1341  rtems_test_assert( mount_opts[1].converter != NULL );
1342
1343  compare_image(
1344    MOUNT_DIR,
1345    "/dev/rdc",
1346    &mount_opts[1]);
1347
1348  test_special_cases();
1349
1350  rc = unmount( MOUNT_DIR );
1351  rtems_test_assert( rc == 0 );
1352
1353  print_image(
1354    "IMAGE_BIN_LE_MULTIBYTE_H_",
1355    "IMAGE_BIN_LE_MULTIBYTE");
1356
1357  rc = mount(
1358    RAMDISK_PATH,
1359    MOUNT_DIR,
1360    "dosfs",
1361    RTEMS_FILESYSTEM_READ_WRITE,
1362    NULL );
1363  rtems_test_assert( rc == 0 );
1364
1365  test_finding_directories(
1366    &start_dir[0],
1367    &NAMES_MULTIBYTE_IN_CODEPAGE_FORMAT[0][0],
1368    NUMBER_OF_NAMES_MULTIBYTE,
1369    &NAMES_MULTIBYTE_IN_CODEPAGE_FORMAT[0][0],
1370    NUMBER_OF_NAMES_MULTIBYTE );
1371
1372  unmount_and_close_device();
1373
1374  test_compatibility();
1375}
1376
1377static void Init( rtems_task_argument arg )
1378{
1379  TEST_BEGIN();
1380
1381  test();
1382
1383  TEST_END();
1384  rtems_test_exit( 0 );
1385}
1386
1387rtems_ramdisk_config rtems_ramdisk_configuration [] = {
1388  { .block_size = BLOCK_SIZE, .block_num = BLOCK_NUM },
1389  { .block_size = BLOCK_SIZE, .block_num = BLOCK_NUM, .location = &IMAGE_BIN_LE_SINGLEBYTE[0] },
1390  { .block_size = BLOCK_SIZE, .block_num = BLOCK_NUM, .location = &IMAGE_BIN_LE_MULTIBYTE[0] },
1391  { .block_size = BLOCK_SIZE, .block_num = sizeof( image_bin ) / BLOCK_SIZE, .location = image_bin }
1392};
1393
1394size_t rtems_ramdisk_configuration_size = RTEMS_ARRAY_SIZE(rtems_ramdisk_configuration);
1395
1396#define CONFIGURE_INIT_TASK_STACK_SIZE ( 1024 * 64 )
1397#define CONFIGURE_APPLICATION_DOES_NOT_NEED_CLOCK_DRIVER
1398#define CONFIGURE_APPLICATION_NEEDS_SIMPLE_CONSOLE_DRIVER
1399#define CONFIGURE_MAXIMUM_SEMAPHORES (2 * RTEMS_DOSFS_SEMAPHORES_PER_INSTANCE)
1400#define CONFIGURE_APPLICATION_EXTRA_DRIVERS RAMDISK_DRIVER_TABLE_ENTRY
1401
1402#define CONFIGURE_APPLICATION_NEEDS_LIBBLOCK
1403
1404#define CONFIGURE_FILESYSTEM_DOSFS
1405
1406/* 2 RAM disk device files + 2 mount_dir + stdin + stdout + stderr +
1407 * 2 for open directories/files  + 4 * 2 for recursive tree compares*/
1408#define CONFIGURE_LIBIO_MAXIMUM_FILE_DESCRIPTORS ( 7 + 2 + ( 4 * 2 ) )
1409
1410#define CONFIGURE_MAXIMUM_TASKS 1
1411
1412#define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION
1413
1414#define CONFIGURE_RTEMS_INIT_TASKS_TABLE
1415
1416#define CONFIGURE_INIT_TASK_ATTRIBUTES RTEMS_FLOATING_POINT
1417
1418#define CONFIGURE_INIT
1419
1420#include <rtems/confdefs.h>
Note: See TracBrowser for help on using the repository browser.