Changeset 771803b in rtems


Ignore:
Timestamp:
May 26, 2011, 11:37:16 PM (9 years ago)
Author:
Chris Johns <chrisj@…>
Branches:
4.10
Children:
880f01b
Parents:
f74c529
Message:

2011-05-27 Chris Johns <chrisj@…>

  • samples/fileio/init.c, samples/fileio/system.h: Add support for create a RAM disk from the shell to aid bug testing on the 4.10 branch.
Location:
testsuites
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • testsuites/ChangeLog

    rf74c529 r771803b  
     12011-05-27      Chris Johns <chrisj@rtems.org>
     2
     3        * samples/fileio/init.c, samples/fileio/system.h: Add support for
     4        create a RAM disk from the shell to aid bug testing on the 4.10
     5        branch.
     6       
    172011-02-08      Ralf Corsépius <ralf.corsepius@rtems.org>
    28
  • testsuites/samples/fileio/init.c

    rf74c529 r771803b  
    3030#include <rtems.h>
    3131#include <fcntl.h>
     32#include <inttypes.h>
    3233#include <rtems/error.h>
    3334#include <rtems/dosfs.h>
     
    3637#include <rtems/libcsupport.h>
    3738#include <rtems/fsmount.h>
     39#include <rtems/ramdisk.h>
     40#include <rtems/nvdisk.h>
     41#include <rtems/nvdisk-sram.h>
    3842
    3943#if FILEIO_BUILD
     44
     45/**
     46 * Let the IO system allocation the next available major number.
     47 */
     48#define RTEMS_DRIVER_AUTO_MAJOR (0)
     49
     50/*
     51 * RAM disk driver so you can create a RAM disk from the shell prompt.
     52 */
     53/**
     54 * The RAM Disk configuration.
     55 */
     56rtems_ramdisk_config rtems_ramdisk_configuration[] =
     57{
     58  {
     59    block_size: 512,
     60    block_num:  1024,
     61    location:   NULL
     62  }
     63};
     64
     65/**
     66 * The number of RAM Disk configurations.
     67 */
     68size_t rtems_ramdisk_configuration_size = 1;
     69
     70/**
     71 * Create the RAM Disk Driver entry.
     72 */
     73rtems_driver_address_table rtems_ramdisk_io_ops = {
     74  initialization_entry: ramdisk_initialize,
     75  open_entry:           rtems_blkdev_generic_open,
     76  close_entry:          rtems_blkdev_generic_close,
     77  read_entry:           rtems_blkdev_generic_read,
     78  write_entry:          rtems_blkdev_generic_write,
     79  control_entry:        rtems_blkdev_generic_ioctl
     80};
     81
     82/**
     83 * The NV Device descriptor. For this test it is just DRAM.
     84 */
     85rtems_nvdisk_device_desc rtems_nv_heap_device_descriptor[] =
     86{
     87  {
     88    flags:  0,
     89    base:   0,
     90    size:   1 * 1024 * 1024,
     91    nv_ops: &rtems_nvdisk_sram_handlers
     92  }
     93};
     94
     95/**
     96 * The NV Disk configuration.
     97 */
     98const rtems_nvdisk_config rtems_nvdisk_configuration[] =
     99{
     100  {
     101    block_size:         512,
     102    device_count:       1,
     103    devices:            &rtems_nv_heap_device_descriptor[0],
     104    flags:              0,
     105    info_level:         0
     106  }
     107};
     108
     109/**
     110 * The number of NV Disk configurations.
     111 */
     112uint32_t rtems_nvdisk_configuration_size = 1;
     113
     114/**
     115 * Create the NV Disk Driver entry.
     116 */
     117rtems_driver_address_table rtems_nvdisk_io_ops = {
     118  initialization_entry: rtems_nvdisk_initialize,
     119  open_entry:           rtems_blkdev_generic_open,
     120  close_entry:          rtems_blkdev_generic_close,
     121  read_entry:           rtems_blkdev_generic_read,
     122  write_entry:          rtems_blkdev_generic_write,
     123  control_entry:        rtems_blkdev_generic_ioctl
     124};
     125
     126int
     127setup_nvdisk (const char* mntpath)
     128{
     129  rtems_device_major_number major;
     130  rtems_status_code         sc;
     131
     132  /*
     133   * For our test we do not have any static RAM or EEPROM devices so
     134   * we allocate the memory from the heap.
     135   */
     136  rtems_nv_heap_device_descriptor[0].base =
     137    malloc (rtems_nv_heap_device_descriptor[0].size);
     138
     139  if (!rtems_nv_heap_device_descriptor[0].base)
     140  {
     141    printf ("error: no memory for NV disk\n");
     142    return 1;
     143  }
     144 
     145  /*
     146   * Register the NV Disk driver.
     147   */
     148  printf ("Register NV Disk Driver: ");
     149  sc = rtems_io_register_driver (RTEMS_DRIVER_AUTO_MAJOR,
     150                                 &rtems_nvdisk_io_ops,
     151                                 &major);
     152  if (sc != RTEMS_SUCCESSFUL)
     153  {
     154    printf ("error: nvdisk driver not initialised: %s\n",
     155            rtems_status_text (sc));
     156    return 1;
     157  }
     158 
     159  printf ("successful\n");
     160
     161  return 0;
     162}
     163
    40164/*
    41165 * Table of FAT file systems that will be mounted
     
    100224#ifdef USE_SHELL
    101225#include <rtems/shell.h>
     226
     227int
     228shell_nvdisk_trace (int argc, char* argv[])
     229{
     230  const char* driver;
     231  int         level;
     232
     233  if (argc != 3)
     234  {
     235    printf ("error: invalid number of options\n");
     236    return 1;
     237  }
     238
     239  driver = argv[1];
     240  level  = strtoul (argv[2], 0, 0);
     241 
     242  int fd = open (driver, O_WRONLY, 0);
     243  if (fd < 0)
     244  {
     245    printf ("error: driver open failed: %s\n", strerror (errno));
     246    return 1;
     247  }
     248 
     249  if (ioctl (fd, RTEMS_NVDISK_IOCTL_INFO_LEVEL, level) < 0)
     250  {
     251    printf ("error: driver set level failed: %s\n", strerror (errno));
     252    return 1;
     253  }
     254 
     255  close (fd);
     256 
     257  return 0;
     258}
     259
     260int
     261shell_nvdisk_erase (int argc, char* argv[])
     262{
     263  const char* driver = NULL;
     264  int         arg;
     265  int         fd;
     266 
     267  for (arg = 1; arg < argc; arg++)
     268  {
     269    if (argv[arg][0] == '-')
     270    {
     271      printf ("error: invalid option: %s\n", argv[arg]);
     272      return 1;
     273    }
     274    else
     275    {
     276      if (!driver)
     277        driver = argv[arg];
     278      else
     279      {
     280        printf ("error: only one driver name allowed: %s\n", argv[arg]);
     281        return 1;
     282      }
     283    }
     284  }
     285 
     286  printf ("erase nv disk: %s\n", driver);
     287 
     288  fd = open (driver, O_WRONLY, 0);
     289  if (fd < 0)
     290  {
     291    printf ("error: nvdisk driver open failed: %s\n", strerror (errno));
     292    return 1;
     293  }
     294 
     295  if (ioctl (fd, RTEMS_NVDISK_IOCTL_ERASE_DISK) < 0)
     296  {
     297    printf ("error: nvdisk driver erase failed: %s\n", strerror (errno));
     298    return 1;
     299  }
     300 
     301  close (fd);
     302 
     303  printf ("nvdisk erased successful\n");
     304
     305  return 0;
     306}
     307
     308int
     309shell_bdbuf_trace (int argc, char* argv[])
     310{
     311#if RTEMS_BDBUF_TRACE
     312  extern bool rtems_bdbuf_tracer;
     313  rtems_bdbuf_tracer = !rtems_bdbuf_tracer;
     314  printf ("bdbuf trace: %d\n", rtems_bdbuf_tracer);
     315#else
     316  printf ("bdbuf trace disabled. Rebuild with enabled.\n");
     317#endif
     318  return 0;
     319}
     320
     321int
     322disk_test_set_block_size (dev_t dev, size_t size)
     323{
     324  rtems_disk_device* dd;
     325  int                rc;
     326 
     327  dd = rtems_disk_obtain (dev);
     328  if (!dd)
     329  {
     330    printf ("error: cannot obtain disk\n");
     331    return 1;
     332  }
     333 
     334  rc = dd->ioctl (dd, RTEMS_BLKIO_SETBLKSIZE, &size);
     335
     336  rtems_disk_release (dd);
     337
     338  return rc;
     339}
     340
     341int
     342disk_test_write_blocks (dev_t dev, int start, int count, size_t size)
     343{
     344  int                 block;
     345  uint32_t*           ip;
     346  uint32_t            value = 0;
     347  int                 i;
     348  rtems_bdbuf_buffer* bd;
     349  rtems_status_code   sc;
     350 
     351  if (disk_test_set_block_size (dev, size) < 0)
     352  {
     353    printf ("error: set block size failed: %s\n", strerror (errno));
     354    return 1;
     355  }
     356
     357  for (block = start; block < (start + count); block++)
     358  {
     359    sc = rtems_bdbuf_read (dev, block, &bd);
     360    if (sc != RTEMS_SUCCESSFUL)
     361    {
     362      printf ("error: get block %d bd failed: %s\n",
     363              block, rtems_status_text (sc));
     364      return 1;
     365    }
     366
     367    ip = (uint32_t*) bd->buffer;
     368    for (i = 0; i < (size / sizeof (uint32_t)); i++, ip++, value++)
     369      *ip = (size << 16) | value;
     370
     371    sc = rtems_bdbuf_release_modified (bd);
     372    if (sc != RTEMS_SUCCESSFUL)
     373    {
     374      printf ("error: release block %d bd failed: %s\n",
     375              block, rtems_status_text (sc));
     376      return 1;
     377    }
     378  }
     379
     380  return 0;
     381}
     382
     383int
     384disk_test_block_sizes (int argc, char *argv[])
     385{
     386  struct stat st;
     387  char*       name;
     388  int         start;
     389  int         count;
     390  int         size;
     391 
     392  if (argc != (4 + 1))
     393  {
     394    printf ("error: need to supply a device path, start, block and size\n");
     395    return 1;
     396  }
     397
     398  name = argv[1];
     399 
     400  if (stat (name, &st) < 0)
     401  {
     402    printf ("error: stat '%s' failed: %s\n", name, strerror (errno));
     403    return 1;
     404  }
     405
     406  start = strtoul (argv[2], 0, 0);
     407  count = strtoul (argv[3], 0, 0);
     408  size  = strtoul (argv[4], 0, 0);
     409 
     410  return disk_test_write_blocks (st.st_rdev, start, count, size);
     411}
     412
     413size_t
     414parse_size_arg (const char* arg)
     415{
     416  size_t size;
     417  size_t scalar = 1;
     418 
     419  size = strtoul (arg, 0, 0);
     420  switch (arg[strlen (arg) - 1])
     421  {
     422    case 'M':
     423      scalar = 1000 * 1024;
     424      break;
     425    case 'm':
     426      scalar = 1000000;
     427      break;
     428    case 'K':
     429      scalar = 1024;
     430      break;
     431    case 'k':
     432      scalar = 1000;
     433      break;
     434    default:
     435      printf ("error: invalid scalar (M/m/K/k): %c\n", arg[strlen (arg) - 1]);
     436      return 0;
     437  }
     438  return size * scalar;
     439 }
     440
     441int
     442create_ramdisk (int argc, char *argv[])
     443{
     444  rtems_device_major_number major;
     445  rtems_status_code         sc;
     446  int                       arg;
     447  size_t                    size = 0;
     448  size_t                    block_size = 0;
     449
     450  for (arg = 0; arg < argc; ++arg)
     451  {
     452    if (argv[arg][0] == '-')
     453    {
     454      switch (argv[arg][0])
     455      {
     456        case 's':
     457          ++arg;
     458          if (arg == argc)
     459          {
     460            printf ("error: -s needs a size\n");
     461            return 1;
     462          }
     463          size = parse_size_arg (argv[arg]);
     464          if (size == 0)
     465            return 1;
     466          break;
     467        case 'b':
     468          ++arg;
     469          if (arg == argc)
     470          {
     471            printf ("error: -b needs a size\n");
     472            return 1;
     473          }
     474          block_size = parse_size_arg (argv[arg]);
     475          if (size == 0)
     476            return 1;
     477          break;
     478        default:
     479          printf ("error: invalid option: %s\n", argv[arg]);
     480          return 1;
     481      }
     482    }
     483  }
     484
     485  if (block_size)
     486    rtems_ramdisk_configuration[0].block_size = block_size;
     487  if (size)
     488    rtems_ramdisk_configuration[0].block_num =
     489      size / rtems_ramdisk_configuration[0].block_size;
     490   
     491  /*
     492   * Register the RAM Disk driver.
     493   */
     494  printf ("Register RAM Disk Driver [blocks=%" PRIu32 \
     495          " block-size=%" PRIu32"]:",
     496          rtems_ramdisk_configuration[0].block_num,
     497          rtems_ramdisk_configuration[0].block_size);
     498 
     499  sc = rtems_io_register_driver (RTEMS_DRIVER_AUTO_MAJOR,
     500                                 &rtems_ramdisk_io_ops,
     501                                 &major);
     502  if (sc != RTEMS_SUCCESSFUL)
     503  {
     504    printf ("error: ramdisk driver not initialised: %s\n",
     505            rtems_status_text (sc));
     506    return 1;
     507  }
     508 
     509  printf ("successful\n");
     510
     511  return 0;
     512}
     513
     514int
     515create_nvdisk (int argc, char *argv[])
     516{
     517  rtems_device_major_number major;
     518  rtems_status_code         sc;
     519  int                       arg;
     520  size_t                    size = 0;
     521#if ADD_WHEN_NVDISK_HAS_CHANGED
     522  size_t                    block_size = 0;
     523#endif
     524 
     525  for (arg = 0; arg < argc; ++arg)
     526  {
     527    if (argv[arg][0] == '-')
     528    {
     529      switch (argv[arg][0])
     530      {
     531        case 's':
     532          ++arg;
     533          if (arg == argc)
     534          {
     535            printf ("error: -s needs a size\n");
     536            return 1;
     537          }
     538          size = parse_size_arg (argv[arg]);
     539          if (size == 0)
     540            return 1;
     541          break;
     542#if ADD_WHEN_NVDISK_HAS_CHANGED
     543        case 'b':
     544          ++arg;
     545          if (arg == argc)
     546          {
     547            printf ("error: -b needs a size\n");
     548            return 1;
     549          }
     550          block_size = parse_size_arg (argv[arg]);
     551          if (size == 0)
     552            return 1;
     553          break;
     554#endif
     555        default:
     556          printf ("error: invalid option: %s\n", argv[arg]);
     557          return 1;
     558      }
     559    }
     560  }
     561
     562#if ADD_WHEN_NVDISK_HAS_CHANGED
     563  if (block_size)
     564    rtems_nvdisk_configuration[0].block_size = block_size;
     565#endif
     566  if (size)
     567    rtems_nv_heap_device_descriptor[0].size = size;
     568   
     569  /*
     570   * For our test we do not have any static RAM or EEPROM devices so
     571   * we allocate the memory from the heap.
     572   */
     573  rtems_nv_heap_device_descriptor[0].base =
     574    malloc (rtems_nv_heap_device_descriptor[0].size);
     575
     576  if (!rtems_nv_heap_device_descriptor[0].base)
     577  {
     578    printf ("error: no memory for NV disk\n");
     579    return 1;
     580  }
     581 
     582  /*
     583   * Register the RAM Disk driver.
     584   */
     585  printf ("Register NV Disk Driver [size=%" PRIu32 \
     586          " block-size=%" PRIu32"]:",
     587          rtems_nv_heap_device_descriptor[0].size,
     588          rtems_nvdisk_configuration[0].block_size);
     589 
     590  sc = rtems_io_register_driver (RTEMS_DRIVER_AUTO_MAJOR,
     591                                 &rtems_nvdisk_io_ops,
     592                                 &major);
     593  if (sc != RTEMS_SUCCESSFUL)
     594  {
     595    printf ("error: nvdisk driver not initialised: %s\n",
     596            rtems_status_text (sc));
     597    return 1;
     598  }
     599 
     600  printf ("successful\n");
     601
     602  return 0;
     603}
    102604
    103605static void writeFile(
     
    183685  );
    184686
    185   printf(" =========================\n");
     687  rtems_shell_add_cmd ("mkrd", "files",
     688                       "Create a RAM disk driver", create_ramdisk);
     689  rtems_shell_add_cmd ("mknvd", "files",
     690                       "Create a NV disk driver", create_nvdisk);
     691  rtems_shell_add_cmd ("nverase", "misc",
     692                       "nverase driver", shell_nvdisk_erase);
     693  rtems_shell_add_cmd ("nvtrace", "misc",
     694                       "nvtrace driver level", shell_nvdisk_trace);
     695  rtems_shell_add_cmd ("bdbuftrace", "files",
     696                       "bdbuf trace toggle", shell_bdbuf_trace);
     697  rtems_shell_add_cmd ("td", "files",
     698                       "Test disk", disk_test_block_sizes);
     699#if RTEMS_RFS_TRACE
     700  rtems_shell_add_cmd ("rfs", "files",
     701                       "RFS trace",
     702                       rtems_rfs_trace_shell_command);
     703#endif
     704#if RTEMS_RFS_RTEMS_TRACE
     705  rtems_shell_add_cmd ("rrfs", "files",
     706                       "RTEMS RFS trace",
     707                       rtems_rfs_rtems_trace_shell_command);
     708#endif
     709
     710  printf("\n =========================\n");
    186711  printf(" starting shell\n");
    187712  printf(" =========================\n");
     
    193718    false,                           /* forever */
    194719    true,                            /* wait */
    195     rtems_shell_login_check          /* login */
     720    NULL                             /* login */
    196721  );
    197722}
  • testsuites/samples/fileio/system.h

    rf74c529 r771803b  
    3939#endif
    4040
     41#define CONFIGURE_MAXIMUM_DRIVERS           4
    4142#define CONFIGURE_APPLICATION_NEEDS_CONSOLE_DRIVER
    4243#define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
    4344#ifdef RTEMS_BSP_HAS_IDE_DRIVER
    4445#define CONFIGURE_APPLICATION_NEEDS_IDE_DRIVER
     46#define CONFIGURE_APPLICATION_NEEDS_ATA_DRIVER
     47#define CONFIGURE_ATA_DRIVER_TASK_PRIORITY  14
    4548#endif
    4649#define CONFIGURE_APPLICATION_NEEDS_LIBBLOCK
     50#define CONFIGURE_BDBUF_MAX_READ_AHEAD_BLOCKS  2
     51#define CONFIGURE_BDBUF_MAX_WRITE_BLOCKS       8
     52#define CONFIGURE_SWAPOUT_TASK_PRIORITY        15
    4753#define CONFIGURE_USE_IMFS_AS_BASE_FILESYSTEM
     54#define CONFIGURE_FILESYSTEM_RFS
     55#define CONFIGURE_FILESYSTEM_DOSFS
    4856
    4957/*
Note: See TracChangeset for help on using the changeset viewer.