path: root/apps/examples/configdata/configdata_main.c

/****************************************************************************
 * examples/configdata/configdata_main.c
 *
 *   Copyright (C) 2013 Ken Pettit. All rights reserved.
 *   Author: Ken Pettit <pettitkd@gmail.com>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 3. Neither the name NuttX nor the names of its contributors may be
 *    used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 ****************************************************************************/

/****************************************************************************
 * Included Files
 ****************************************************************************/

#include <nuttx/config.h>

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
#include <crc32.h>
#include <debug.h>

#include <nuttx/mtd/mtd.h>
#include <nuttx/configdata.h>
#include <nuttx/fs/ioctl.h>
#include <sys/ioctl.h>

/****************************************************************************
 * Definitions
 ****************************************************************************/
/* Configuration ************************************************************/
/* The default is to use the RAM MTD device at drivers/mtd/rammtd.c.  But
 * an architecture-specific MTD driver can be used instead by defining
 * CONFIG_EXAMPLES_CONFIGDATA_ARCHINIT.  In this case, the initialization logic
 * will call configdata_archinitialize() to obtain the MTD driver instance.
 */

#ifndef CONFIG_EXAMPLES_CONFIGDATA_ARCHINIT

/* This must exactly match the default configuration in drivers/mtd/rammtd.c */

#  ifndef CONFIG_RAMMTD_ERASESIZE
#    define CONFIG_RAMMTD_ERASESIZE 4096
#  endif

#  ifndef CONFIG_EXAMPLES_CONFIGDATA_NEBLOCKS
#    define CONFIG_EXAMPLES_CONFIGDATA_NEBLOCKS (256)
#  endif

#  define EXAMPLES_CONFIGDATA_BUFSIZE \
  (CONFIG_RAMMTD_ERASESIZE * CONFIG_EXAMPLES_CONFIGDATA_NEBLOCKS)
#endif

#ifndef CONFIG_EXAMPLES_CONFIGDATA_MAXSIZE
#  define CONFIG_EXAMPLES_CONFIGDATA_MAXSIZE 512
#endif

#ifndef CONFIG_EXAMPLES_CONFIGDATA_MAXENTRIES
#  define CONFIG_EXAMPLES_CONFIGDATA_MAXENTRIES 3000
#endif

#ifndef CONFIG_EXAMPLES_CONFIGDATA_NLOOPS
#  define CONFIG_EXAMPLES_CONFIGDATA_NLOOPS 100
#endif

#define EXAMPLES_CONFIGDATA_REPORT  (CONFIG_EXAMPLES_CONFIGDATA_NLOOPS / 20)
#if EXAMPLES_CONFIGDATA_REPORT == 0
#  undef EXAMPLES_CONFIGDATA_REPORT
#  define EXAMPLES_CONFIGDATA_REPORT 1
#endif

#ifndef CONFIG_EXAMPLES_CONFIGDATA_VERBOSE
#  define CONFIG_EXAMPLES_CONFIGDATA_VERBOSE 0
#endif

/****************************************************************************
 * Private Types
 ****************************************************************************/

struct configdata_entrydesc_s
{
  uint16_t id;
  uint8_t  instance;
  uint16_t len;
  uint32_t crc;
  uint8_t  deleted;
  uint8_t  changed;
};

/****************************************************************************
 * Private Data
 ****************************************************************************/
/* Pre-allocated simulated flash */

#ifndef CONFIG_EXAMPLES_CONFIGDATA_ARCHINIT
static uint8_t g_simflash[EXAMPLES_CONFIGDATA_BUFSIZE<<1];
#endif

static uint8_t g_entryimage[CONFIG_EXAMPLES_CONFIGDATA_MAXSIZE];
static struct configdata_entrydesc_s g_entries[CONFIG_EXAMPLES_CONFIGDATA_MAXENTRIES];
static int g_nentries;
static int g_ndeleted;
static int g_fd;
static int g_ntests, g_nverified;
static int g_ntotalalloc, g_ntotaldelete;

static struct mallinfo g_mmbefore;
static struct mallinfo g_mmprevious;
static struct mallinfo g_mmafter;

/****************************************************************************
 * External Functions
 ****************************************************************************/

#ifdef CONFIG_EXAMPLES_CONFIGDATA_ARCHINIT
extern FAR struct mtd_dev_s *configdata_archinitialize(void);
#endif

/****************************************************************************
 * Private Functions
 ****************************************************************************/

/****************************************************************************
 * Name: configdata_memusage
 ****************************************************************************/

static void configdata_showmemusage(struct mallinfo *mmbefore,
                               struct mallinfo *mmafter)
{
  printf("VARIABLE  BEFORE   AFTER\n");
  printf("======== ======== ========\n");
  printf("arena    %8x %8x\n", mmbefore->arena,    mmafter->arena);
  printf("ordblks  %8d %8d\n", mmbefore->ordblks,  mmafter->ordblks);
  printf("mxordblk %8x %8x\n", mmbefore->mxordblk, mmafter->mxordblk);
  printf("uordblks %8x %8x\n", mmbefore->uordblks, mmafter->uordblks);
  printf("fordblks %8x %8x\n", mmbefore->fordblks, mmafter->fordblks);
}

/****************************************************************************
 * Name: configdata_loopmemusage
 ****************************************************************************/

static void configdata_loopmemusage(void)
{
  /* Get the current memory usage */

#ifdef CONFIG_CAN_PASS_STRUCTS
  g_mmafter = mallinfo();
#else
  (void)mallinfo(&g_mmafter);
#endif

  /* Show the change from the previous loop */

  printf("\nEnd of loop memory usage:\n");
  configdata_showmemusage(&g_mmprevious, &g_mmafter);

  /* Set up for the next test */

#ifdef CONFIG_CAN_PASS_STRUCTS
  g_mmprevious = g_mmafter;
#else
  memcpy(&g_mmprevious, &g_mmafter, sizeof(struct mallinfo));
#endif
}

/****************************************************************************
 * Name: configdata_endmemusage
 ****************************************************************************/

static void configdata_endmemusage(void)
{
#ifdef CONFIG_CAN_PASS_STRUCTS
  g_mmafter = mallinfo();
#else
  (void)mallinfo(&g_mmafter);
#endif
  printf("\nFinal memory usage:\n");
  configdata_showmemusage(&g_mmbefore, &g_mmafter);

  printf("\nTotal adds: %d  Total deletes : %d\n",
         g_ntotalalloc, g_ntotaldelete);
  printf("Total tests: %d  Number passed: %d  Failed: %d\n",
         g_ntests, g_nverified, g_ntests - g_nverified);
}

/****************************************************************************
 * Name: configdata_randid
 ****************************************************************************/

static inline uint16_t configdata_randid(void)
{
  int x;
  int value;

retry:
  value = rand() & 0x7FFF;
  if (value == 0)
    {
      value = 100;
    }

  /* Ensure we don't have a duplicate id */

  for (x = 0; x < g_nentries; x++)
    {
      if (value == g_entries[x].id)
        {
          goto retry;
        }
    }

  return value;
}

/****************************************************************************
 * Name: configdata_randlen
 ****************************************************************************/

static inline uint16_t configdata_randlen(void)
{
  int value = rand() % CONFIG_EXAMPLES_CONFIGDATA_MAXSIZE;

  if (value == 0)
    {
      return 1;
    }

  return value;
}

/****************************************************************************
 * Name: configdata_randinstance
 ****************************************************************************/

static inline uint8_t configdata_randinstance(void)
{
  return rand() & 0xff;
}

/****************************************************************************
 * Name: configdata_freefile
 ****************************************************************************/

static void configdata_freeentry(FAR struct configdata_entrydesc_s *entry)
{
  memset(entry, 0, sizeof(struct configdata_entrydesc_s));
}

/****************************************************************************
 * Name: configdata_wrentry
 ****************************************************************************/

static inline int configdata_wrentry(FAR struct configdata_entrydesc_s *entry)
{
  size_t x;
  int ret;
  struct config_data_s  config;

  /* Create a random entry */

  entry->id = configdata_randid();
  entry->instance = configdata_randinstance();
  entry->len = configdata_randlen();

  /* Write some random data to the entry */

  for (x = 0; x < entry->len; x++)
    {
      g_entryimage[x] = rand() & 0xFF;
    }

  /* Calculate the crc32 for the data */

  entry->crc = crc32(g_entryimage, entry->len);

  /* Write the entry to the /dev/config device */

  config.id = entry->id;
  config.instance = entry->instance;
  config.len = entry->len;
  config.configdata = g_entryimage;
  ret = ioctl(g_fd, CFGDIOC_SETCONFIG, (unsigned long) &config);
  if (ret < 0)
    {
      entry->id = 0;
      entry->len = 0;
      return ERROR;
    }

  return OK;
}

/****************************************************************************
 * Name: configdata_fillconfig
 ****************************************************************************/

static int configdata_fillconfig(void)
{
  FAR struct configdata_entrydesc_s *entry;
  int ret;
  int i;

  /* Create a file for each unused file structure */

  for (i = 0; i < CONFIG_EXAMPLES_CONFIGDATA_MAXENTRIES; i++)
    {
      entry = &g_entries[i];
      if (entry->id == 0)
        {
          ret = configdata_wrentry(entry);
          if (ret < 0)
            {
#if CONFIG_EXAMPLES_CONFIGDATA_VERBOSE != 0
              printf("  /dev/config full\n");
#endif
              return ERROR;
            }

#if CONFIG_EXAMPLES_CONFIGDATA_VERBOSE != 0
         printf("  Created entry %04X, %d  Len=%d\n",
                entry->id, entry->instance, entry->len);
#endif
         g_nentries++;
         g_ntotalalloc++;
        }
    }

  return OK;
}

/****************************************************************************
 * Name: configdata_rdentry
 ****************************************************************************/

static inline int configdata_rdentry(FAR struct configdata_entrydesc_s *entry)
{
  struct config_data_s config;
  uint32_t crc;
  int ret;

  /* Read the config entry from /dev/config */

  config.id = entry->id;
  config.instance = entry->instance;
  config.len = entry->len;
  config.configdata = g_entryimage;
  ret = ioctl(g_fd, CFGDIOC_GETCONFIG, (unsigned long) &config);
  if (ret < 0)
    {
      return ERROR;
    }

  /* Verify the file image CRC */

  crc = crc32(g_entryimage, entry->len);
  if (crc != entry->crc)
    {
      printf("ERROR: Bad CRC: %d vs %d\n", crc, entry->crc);
      printf("  Entry id:   %04X\n", entry->id);
      printf("  Entry size: %d\n", entry->len);
      return ERROR;
    }

  return OK;
}

/****************************************************************************
 * Name: configdata_verifyconfig
 ****************************************************************************/

static int configdata_verifyconfig(void)
{
  FAR struct configdata_entrydesc_s *entry;
  int ret;
  int err = OK;
  int i;
  static int iteration = 0;

  /* Create a file for each unused file structure */

  iteration++;
  for (i = 0; i < CONFIG_EXAMPLES_CONFIGDATA_MAXENTRIES; i++)
    {
      entry = &g_entries[i];
      if (entry->id != 0)
        {
          g_ntests++;
          ret = configdata_rdentry(entry);
          if (ret < 0)
            {
              /* Check if this entry has been deleted */

              if (entry->deleted)
                {
                  /* Good, it wasn't found (as it shouldn't be) */

                  g_nverified++;
#if CONFIG_EXAMPLES_CONFIGDATA_VERBOSE != 0
                  printf("  Verified delete %04X, %d\n", entry->id,
                         entry->instance);
#endif
                }
              else
                {
                  printf("ERROR: Failed to read an entry: %d\n", i);
                  printf("  Entry id:   %04X\n", entry->id);
                  printf("  Entry size: %d\n", entry->len);
                  err = ERROR;
                }
            }
          else
            {
              /* Check if this entry has been deleted and should report an error */

              if (entry->deleted)
                {
                  printf("ERROR: Succesffully read a deleted entry\n");
                  printf("  Entry id:   %04X\n", entry->id);
                  printf("  Entry size: %d\n", entry->len);
                  err = ERROR;
                }
              else
                {
                  g_nverified++;
#if CONFIG_EXAMPLES_CONFIGDATA_VERBOSE != 0
                  printf("  Verifed entry %04X, %d\n", entry->id, entry->instance);
#endif
                }
            }
        }
    }

  return err;
}

/****************************************************************************
 * Name: configdata_delentries
 ****************************************************************************/

static int configdata_delentries(void)
{
  FAR struct configdata_entrydesc_s *entry;
  struct config_data_s hdr;
  int ndel;
  int ret;
  int i;
  int j;

  /* Are there any files to be deleted? */

  int nentries = g_nentries - g_ndeleted;
  if (nentries < 1)
    {
      return 0;
    }

  /* Yes... How many files should we delete? */

  ndel = (rand() % nentries) + 1;

  /* Now pick which files to delete */

  for (i = 0; i < ndel; i++)
    {
      /* Guess a file index */

      int ndx = (rand() % (g_nentries - g_ndeleted));

      /* And delete the next undeleted file after that random index */

      for (j = ndx + 1; j != ndx;)
        {
          entry = &g_entries[j];
          if (entry->id && !entry->deleted)
            {
              hdr.id = entry->id;
              hdr.instance = entry->instance;
              hdr.len = 0;
              ret = ioctl(g_fd, CFGDIOC_SETCONFIG, (unsigned long) &hdr);
              if (ret < 0)
                {
                  printf("ERROR: Delete %d failed: %d\n", i+1, errno);
                  printf("  Entry id:    %04X\n", entry->id);
                  printf("  Entry size:  %d\n", entry->len);
                  printf("  Entry index: %d\n", j);
                }
              else
                {
#if CONFIG_EXAMPLES_CONFIGDATA_VERBOSE != 0
                  printf("  Deleted entry %04X\n", entry->id);
#endif
                  entry->deleted = true;
                  g_ndeleted++;
                  g_ntotaldelete++;
                  break;
                }
            }

          /* Increment the index and test for wrap-around */

          if (++j >= CONFIG_EXAMPLES_CONFIGDATA_MAXENTRIES)
            {
              j = 0;
            }
        }
    }

  return OK;
}

/****************************************************************************
 * Name: configdata_getnextdeleted
 ****************************************************************************/

static int configdata_getnextdeleted(void)
{
  int x;
  int nextdeleted = -1;

  /* Find next deleted entry */

  for (x = 0; x < CONFIG_EXAMPLES_CONFIGDATA_MAXENTRIES; x++)
    {
      if (g_entries[x].deleted)
        {
          nextdeleted = x;
          break;
        }
    }

  return nextdeleted;
}

/****************************************************************************
 * Name: configdata_cleardeleted
 ****************************************************************************/

static int configdata_cleardeleted(void)
{
  int nextdeleted;
  int x;

  while ((nextdeleted = configdata_getnextdeleted()) != -1)
    {
      /* Find next non-deleted entry after the deleted one */

      for (x = nextdeleted + 1; x < CONFIG_EXAMPLES_CONFIGDATA_MAXENTRIES; x++)
        {
          if (g_entries[x].id && !g_entries[x].deleted)
            {
              break;
            }
        }

      /* Test if an non-deleted entry found */

      if (x < CONFIG_EXAMPLES_CONFIGDATA_MAXENTRIES)
        {
          /* Move this entry to the deleted entry location */

#if CONFIG_EXAMPLES_CONFIGDATA_VERBOSE != 0
          printf("  Overwrite entry %d, OLD=%04X  NEW=%04X\n",
                 nextdeleted, g_entries[nextdeleted].id, g_entries[x].id);
#endif

          g_entries[nextdeleted] = g_entries[x];
          g_entries[x].id = 0;
        }
      else
        {
          /* Just remove the entry */
          g_entries[nextdeleted].id = 0;
          g_entries[nextdeleted].deleted = FALSE;
        }
    }

  g_nentries -= g_ndeleted;
  g_ndeleted = 0;
}

/****************************************************************************
 * Public Functions
 ****************************************************************************/

/****************************************************************************
 * Name: configdata_main
 ****************************************************************************/

#ifdef CONFIG_BUILD_KERNEL
int main(int argc, FAR char *argv[])
#else
int configdata_main(int argc, char *argv[])
#endif
{
  unsigned int i;
  int ret;
  FAR struct mtd_dev_s *mtd;

  /* Seed the random number generated */

  srand(0x93846);

  /* Create and initialize a RAM MTD device instance */

#ifdef CONFIG_EXAMPLES_CONFIGDATA_ARCHINIT
  mtd = configdata_archinitialize();
#else
#if CONFIG_EXAMPLES_CONFIGDATA_VERBOSE != 0
  printf("Creating %d byte RAM drive\n", EXAMPLES_CONFIGDATA_BUFSIZE);
#endif
  mtd = rammtd_initialize(g_simflash, EXAMPLES_CONFIGDATA_BUFSIZE);
#endif
  if (!mtd)
    {
      printf("ERROR: Failed to create RAM MTD instance\n");
      fflush(stdout);
      exit(1);
    }

  /* Initialize to provide CONFIGDATA on an MTD interface */

#if CONFIG_EXAMPLES_CONFIGDATA_VERBOSE != 0
  printf("Registering /dev/config device\n");
#endif
  MTD_IOCTL(mtd, MTDIOC_BULKERASE, 0);
  ret = mtdconfig_register(mtd);
  if (ret < 0)
    {
      printf("ERROR: /dev/config registration failed: %d\n", -ret);
      fflush(stdout);
      exit(2);
    }

  /* Zero out our entry array */

  memset(g_entries, 0, sizeof(g_entries));

  /* Open the /dev/config device */

  g_fd = open("/dev/config", O_RDOK);
  if (g_fd == -1)
    {
      printf("ERROR: Failed to open /dev/config %d\n", -errno);
      fflush(stdout);
      exit(2);
    }

  /* Initialize the before memory values */

#ifdef CONFIG_CAN_PASS_STRUCTS
  g_mmbefore = mallinfo();
#else
  (void)mallinfo(&g_mmbefore);
#endif

  /* Loop seveal times ... create some config data items, delete them
   * randomly, verify them randomly, add new config items.
   */

  g_ntests = g_nverified = 0;
  g_ntotaldelete = g_ntotalalloc = 0;

#if CONFIG_EXAMPLES_CONFIGDATA_NLOOPS == 0
  for (i = 0; ; i++)
#else
  for (i = 1; i <= CONFIG_EXAMPLES_CONFIGDATA_NLOOPS; i++)
#endif
    {
      /* Write config data to the /dev/config device until either (1) all of the
       * open file structures are utilized or until (2) CONFIGDATA reports an error
       * (hopefully that the /dev/config device is full)
       */

#ifndef CONFIG_EXAMPLES_CONFIGDATA_SILENT
      printf("\n=== FILLING %u =============================\n", i);
#endif
      (void)configdata_fillconfig();
#ifndef CONFIG_EXAMPLES_CONFIGDATA_SILENT
      printf("Filled /dev/config\n");
      printf("  Number of entries: %d\n", g_nentries);
#endif

      /* Verify all files entries to FLASH */

      ret = configdata_verifyconfig();
      if (ret < 0)
        {
          printf("ERROR: Failed to verify partition\n");
          printf("  Number of entries: %d\n", g_nentries);
        }
      else
        {
#ifndef CONFIG_EXAMPLES_CONFIGDATA_SILENT
#if CONFIG_EXAMPLES_CONFIGDATA_VERBOSE != 0
          printf("Verified!\n");
          printf("  Number of entries: %d\n", g_nentries);
#endif
#endif
        }

      /* Delete some entries */

#ifndef CONFIG_EXAMPLES_CONFIGDATA_SILENT
      printf("\n=== DELETING %u ============================\n", i);
#endif
      ret = configdata_delentries();
      if (ret < 0)
        {
          printf("ERROR: Failed to delete enries\n");
          printf("  Number of entries: %d\n", g_nentries);
          printf("  Number deleted:    %d\n", g_ndeleted);
        }
      else
        {
#ifndef CONFIG_EXAMPLES_CONFIGDATA_SILENT
          printf("Deleted some enries\n");
          printf("  Number of entries: %d\n", g_nentries);
          printf("  Number deleted:    %d\n", g_ndeleted);
#endif
        }

      /* Verify all files written to FLASH */

      ret = configdata_verifyconfig();
      if (ret < 0)
        {
          printf("ERROR: Failed to verify partition\n");
          printf("  Number of entries: %d\n", g_nentries);
          printf("  Number deleted:    %d\n", g_ndeleted);
        }
      else
        {
#ifndef CONFIG_EXAMPLES_CONFIGDATA_SILENT
#if CONFIG_EXAMPLES_CONFIGDATA_VERBOSE != 0
          printf("Verified!\n");
          printf("  Number of entries: %d\n", g_nentries);
          printf("  Number deleted:    %d\n", g_ndeleted);
#endif
#endif
        }

      /* Clear deleted entries */

      configdata_cleardeleted();

      /* Show memory usage */

#ifndef CONFIG_EXAMPLES_CONFIGDATA_SILENT
      configdata_loopmemusage();
      fflush(stdout);
#else
      if ((i % EXAMPLES_CONFIGDATA_REPORT) == 0)
        {
          printf("%u\n", i);
          fflush(stdout);
        }
#endif
    }

  /* Delete all files then show memory usage again */

  //configdata_delallfiles();
  configdata_endmemusage();
  fflush(stdout);
  return 0;
}