gistfile1.txt

#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <lfs.h>
#include <lfs1.h>

#define FS_SIZE 256 * 1024

static bool log_reads = true, log_writes = true, log_erases = true;
static int opr = 0, opw = 0, ope = 0;

static int mem_lfs_read(const struct lfs_config *c, lfs_block_t block,
                        lfs_off_t off, void *buffer, lfs_size_t size) {
  if (log_reads) {
    fprintf(stderr, "R   #%04d %d @ %d+%d\n", opr, (int) size, (int) block,
            (int) off);
  }
  char *image = (char *) c->context;
  memcpy(buffer, image + (block * c->block_size) + off, size);
  opr++;
  return LFS_ERR_OK;
}

static int mem_lfs_prog(const struct lfs_config *c, lfs_block_t block,
                        lfs_off_t off, const void *buffer, lfs_size_t size) {
  if (log_writes) {
    fprintf(stderr, " W  #%04d %d @ %d+%d\n", opw, (int) size, (int) block,
            (int) off);
  }
  char *image = (char *) c->context;
  memcpy(image + block * c->block_size + off, buffer, size);
  opw++;
  return LFS_ERR_OK;
}

static int mem_lfs_erase(const struct lfs_config *c, lfs_block_t block) {
  if (log_erases) {
    fprintf(stderr, "  E #%04d %d @ %d\n", ope, (int) c->block_size,
            (int) block);
  }
  char *image = (char *) c->context;
  memset(image + block * c->block_size, 0xff, c->block_size);
  ope++;
  return LFS_ERR_OK;
}

static int mem_lfs_sync(const struct lfs_config *c) {
  (void) c;
  return LFS_ERR_OK;
}

void create1(char *image, int fs_size) {
  int r;
  lfs1_t fs1;
  lfs1_file_t f1;
  struct lfs1_config cfg = {
    .context = image,
    .read = (void *) mem_lfs_read,
    .prog = (void *) mem_lfs_prog,
    .erase = (void *) mem_lfs_erase,
    .sync = (void *) mem_lfs_sync,

    .read_size = 64,
    .prog_size = 64,
    .block_size = 4096,
    .block_count = fs_size / 4096,
    .lookahead = 1024,
  };
  r = lfs1_format(&fs1, &cfg);
  fprintf(stderr, "lfs1_format: %d\n", r);
  r = lfs1_file_open(&fs1, &f1, "test.txt", LFS1_O_CREAT | LFS1_O_TRUNC | LFS1_O_RDWR);
  fprintf(stderr, "lfs1_file_open: %d\n", r);
  r = lfs1_file_write(&fs1, &f1, "test", 4);
  fprintf(stderr, "lfs1_file_write: %d\n", r);
  r = lfs1_file_close(&fs1, &f1);
  fprintf(stderr, "lfs1_file_close: %d\n", r);
  r = lfs1_unmount(&fs1);
  fprintf(stderr, "lfs1_unmount: %d\n", r);
}

void mount2(char *image, int fs_size) {
  int r;
  lfs_t fs;
  struct lfs_config cfg = {
    .context = image,
    .read = mem_lfs_read,
    .prog = mem_lfs_prog,
    .erase = mem_lfs_erase,
    .sync = mem_lfs_sync,

    .read_size = 64,
    .prog_size = 64,
    .block_size = 4096,
    .block_count = fs_size / 4096,
    .lookahead_size = 1024,
    .cache_size = 256,
  };
  r = lfs_mount(&fs, &cfg);
  fprintf(stderr, "lfs_mount: %d\n", r);
}

void migrate(char *image, int fs_size) {
  int r;
  lfs_t fs;
  struct lfs_config cfg = {
    .context = image,
    .read = mem_lfs_read,
    .prog = mem_lfs_prog,
    .erase = mem_lfs_erase,
    .sync = mem_lfs_sync,

    .read_size = 64,
    .prog_size = 64,
    .block_size = 4096,
    .block_count = fs_size / 4096,
    .lookahead_size = 1024,
    .cache_size = 256,
  };
  r = lfs_migrate(&fs, &cfg);
  fprintf(stderr, "lfs_migrate: %d\n", r);
}
int main(void) {
  char *image = (char *) malloc(FS_SIZE);
  create1(image, FS_SIZE);

  fprintf(stderr, "\n");
  opr = opw = ope = 0;
  mount2(image, FS_SIZE);

  fprintf(stderr, "\n");
  opr = opw = ope = 0;
  migrate(image, FS_SIZE);

  fprintf(stderr, "\n");
  opr = opw = ope = 0;
  mount2(image, FS_SIZE);

  return 0;
}