Changeset 7032a458 in rtems


Ignore:
Timestamp:
Jul 4, 2011, 12:34:00 AM (8 years ago)
Author:
Chris Johns <chrisj@…>
Branches:
4.11, master
Children:
542d350e
Parents:
acb92e3
Message:

2011-07-04 Chris Johns <chrisj@…>

  • fileio/init.c, fileio/system.h: Add commands to create ram disks from the shell prompt. Helps testing.
Location:
testsuites/samples
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • testsuites/samples/ChangeLog

    racb92e3 r7032a458  
     12011-07-04      Chris Johns <chrisj@rtems.org>
     2
     3        * fileio/init.c, fileio/system.h: Add commands to
     4        create ram disks from the shell prompt. Helps testing.
     5
    162011-06-20      Ralf Corsépius <ralf.corsepius@rtems.org>
    27
  • testsuites/samples/fileio/init.c

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

    racb92e3 r7032a458  
    4040#endif
    4141
     42#define CONFIGURE_MAXIMUM_DRIVERS           4
    4243#define CONFIGURE_APPLICATION_NEEDS_CONSOLE_DRIVER
    4344#define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
    4445#ifdef RTEMS_BSP_HAS_IDE_DRIVER
    4546#define CONFIGURE_APPLICATION_NEEDS_IDE_DRIVER
     47#define CONFIGURE_APPLICATION_NEEDS_ATA_DRIVER
     48#define CONFIGURE_ATA_DRIVER_TASK_PRIORITY  14
    4649#endif
    4750#define CONFIGURE_APPLICATION_NEEDS_LIBBLOCK
     51#define CONFIGURE_BDBUF_MAX_READ_AHEAD_BLOCKS  2
     52#define CONFIGURE_BDBUF_MAX_WRITE_BLOCKS       8
     53#define CONFIGURE_SWAPOUT_TASK_PRIORITY        15
    4854#define CONFIGURE_USE_IMFS_AS_BASE_FILESYSTEM
     55#define CONFIGURE_FILESYSTEM_RFS
     56#define CONFIGURE_FILESYSTEM_DOSFS
    4957
    5058/*
Note: See TracChangeset for help on using the changeset viewer.