zircon/system/utest/fs/test-random-op.c

// Copyright 2017 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <sched.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <threads.h>
#include <time.h>
#include <unistd.h>
#include <zircon/compiler.h>
#include <zircon/listnode.h>
#include <zircon/types.h>

#include "filesystems.h"

#define FAIL -1
#define DONE 0

#define BLKSIZE 8192
#define FBUFSIZE 65536

typedef struct worker worker_t;
typedef struct random_op random_op_t;

typedef struct env {
  worker_t* all_workers;

  mtx_t log_timer_lock;
  cnd_t log_timer_cnd;

  random_op_t* ops;
  unsigned n_ops;

  bool tests_finished;

  list_node_t threads;

  bool debug;
} env_t;

typedef struct worker {
  worker_t* next;

  env_t* env;

  int fd;
  ssize_t size;

  char name[PATH_MAX];
  unsigned seed;

  unsigned opcnt;
} worker_t;

static bool init_environment(env_t*);
static void add_random_ops(env_t* env);

typedef struct thread_list {
  list_node_t node;
  thrd_t t;
} thread_list_t;

static bool worker_new(env_t* env, const char* fn, uint32_t size) {
  worker_t* w = calloc(1, sizeof(worker_t));
  ASSERT_NE(w, NULL, "");

  // per-thread random seed
  struct timespec ts;
  clock_gettime(CLOCK_REALTIME, &ts);
  w->seed = (int)ts.tv_nsec;

  w->env = env;

  snprintf(w->name, sizeof(w->name), "%s", fn);
  w->size = size;
  w->fd = -1;

  w->opcnt = 0;

  w->next = env->all_workers;
  env->all_workers = w;

  return true;
}

static void free_workers(env_t* env) {
  worker_t* all_workers = env->all_workers;
  for (worker_t* w = all_workers; w != NULL;) {
    worker_t* next = w->next;
    free(w);
    w = next;
  }
}

#define KB(n) ((n)*1024)
#define MB(n) ((n)*1024 * 1024)

static struct {
  const char* name;
  uint32_t size;
} WORK[] = {
    // one thread per work entry
    {"thd0000", KB(5)},   {"thd0001", MB(10)}, {"thd0002", KB(512)}, {"thd0003", KB(512)},
    {"thd0004", KB(512)}, {"thd0005", MB(20)}, {"thd0006", KB(512)}, {"thd0007", KB(512)},
};

static bool init_environment(env_t* env) {
  // tests are run repeatedly, so reinitialize each time
  env->all_workers = NULL;

  list_initialize(&env->threads);

  mtx_init(&env->log_timer_lock, mtx_plain);
  cnd_init(&env->log_timer_cnd);

  env->tests_finished = false;
  env->debug = false;

  add_random_ops(env);

  // assemble the work
  for (unsigned n = 0; n < countof(WORK); n++) {
    ASSERT_TRUE(worker_new(env, WORK[n].name, WORK[n].size), "");
  }

  return true;
}

// wait until test finishes or timer suggests we may be hung
static const unsigned TEST_MAX_RUNTIME = 120;  // 120 sec max
static int log_timer(void* arg) {
  env_t* env = arg;
  struct timespec ts;
  clock_gettime(CLOCK_REALTIME, &ts);
  ts.tv_sec += TEST_MAX_RUNTIME;

  mtx_lock(&env->log_timer_lock);
  cnd_timedwait(&env->log_timer_cnd, &env->log_timer_lock, &ts);
  if (!env->tests_finished) {
    exit(1);  // causes remaining threads to abort
  }
  mtx_unlock(&env->log_timer_lock);
  return 0;
}

static void task_debug_op(worker_t* w, const char* fn) {
  env_t* env = w->env;

  w->opcnt++;
  if (env->debug) {
    fprintf(stderr, "%s[%d] %s\n", w->name, w->opcnt, fn);
  }
}

static void task_error(worker_t* w, const char* fn, const char* msg) {
  int errnum = errno;
  char buf[128];
  strerror_r(errnum, buf, sizeof(buf));
  fprintf(stderr, "%s ERROR %s(%s): %s(%d)\n", w->name, fn, msg, buf, errnum);
}

static int task_create_a(worker_t* w) {
  // put a page of data into ::/a
  task_debug_op(w, "t: create_a");
  int fd = open("::/a", O_RDWR + O_CREAT, 0666);
  if (fd < 0) {
    // errno may be one of EEXIST
    if (errno != EEXIST) {
      task_error(w, "t: create_a", "open");
      return FAIL;
    }
  } else {
    char buf[BLKSIZE];
    memset(buf, 0xab, sizeof(buf));
    ssize_t len = write(fd, buf, sizeof(buf));
    if (len < 0) {
      task_error(w, "t: create_a", "write");
      return FAIL;
    }
    assert(len == sizeof(buf));
    EXPECT_EQ(close(fd), 0, "");
  }
  return DONE;
}

static int task_create_b(worker_t* w) {
  // put a page of data into ::/b
  task_debug_op(w, "t: create_b");
  int fd = open("::/b", O_RDWR + O_CREAT, 0666);
  if (fd < 0) {
    // errno may be one of EEXIST
    if (errno != EEXIST) {
      task_error(w, "t: create_b", "open");
      return FAIL;
    }
  } else {
    char buf[BLKSIZE];
    memset(buf, 0xba, sizeof(buf));
    ssize_t len = write(fd, buf, sizeof(buf));
    if (len < 0) {
      task_error(w, "t: create_a", "write");
      return FAIL;
    }
    assert(len == sizeof(buf));
    EXPECT_EQ(close(fd), 0, "");
  }
  return DONE;
}

static int task_rename_ab(worker_t* w) {
  // rename ::/a -> ::/b
  task_debug_op(w, "t: rename_ab");
  int rc = rename("::/a", "::/b");
  if (rc < 0) {
    // errno may be one of ENOENT
    if (errno != ENOENT) {
      task_error(w, "t: rename_ab", "rename");
      return FAIL;
    }
  }
  return DONE;
}

static int task_rename_ba(worker_t* w) {
  // rename ::/b -> ::/a
  task_debug_op(w, "t: rename_ba");
  int rc = rename("::/b", "::/a");
  if (rc < 0) {
    // errno may be one of ENOENT
    if (errno != ENOENT) {
      task_error(w, "t: rename_ba", "rename");
      return FAIL;
    }
  }
  return DONE;
}

static int task_make_private_dir(worker_t* w) {
  // mkdir ::/threadname
  task_debug_op(w, "t: make_private_dir");
  char fname[PATH_MAX];
  snprintf(fname, sizeof(fname), "::/%s", w->name);
  int rc = mkdir(fname, 0755);
  if (rc < 0) {
    // errno may be one of EEXIST, ENOENT
    if (errno != ENOENT && errno != EEXIST) {
      task_error(w, "t: make_private_dir", "mkdir");
      return FAIL;
    }
  }
  return DONE;
}

static int task_rmdir_private_dir(worker_t* w) {
  // unlink ::/threadname
  task_debug_op(w, "t: remove_private_dir");
  char fname[PATH_MAX];
  snprintf(fname, sizeof(fname), "::/%s", w->name);
  int rc = rmdir(fname);
  if (rc < 0) {
    // errno may be one of ENOENT, ENOTEMPTY,
    if (errno != ENOENT && errno != ENOTEMPTY) {
      task_error(w, "t: remove_private_dir", "rmdir");
      return FAIL;
    }
  }
  return DONE;
}

static int task_unlink_a(worker_t* w) {
  // unlink ::/a
  task_debug_op(w, "t: unlink_a");
  int rc = unlink("::/a");
  if (rc < 0) {
    // errno may be one of ENOENT
    if (errno != ENOENT) {
      task_error(w, "t: unlink_a", "unlink");
      return FAIL;
    }
  }
  return DONE;
}

static int task_unlink_b(worker_t* w) {
  // unlink ::/b
  task_debug_op(w, "t: unlink_b");
  int rc = unlink("::/b");
  if (rc < 0) {
    // errno may be one of ENOENT
    if (errno != ENOENT) {
      task_error(w, "t: unlink_b", "unlink");
      return FAIL;
    }
  }
  return DONE;
}

static int task_mkdir_private_b(worker_t* w) {
  // mkdir ::/threadname/b
  task_debug_op(w, "t: mkdir_private_b");
  char fname[PATH_MAX];
  snprintf(fname, sizeof(fname), "::/%s/b", w->name);
  int rc = mkdir(fname, 0755);
  if (rc < 0) {
    // errno may be one of EEXIST, ENOENT, ENOTDIR
    if (errno != ENOENT && errno != ENOENT && errno != ENOTDIR) {
      task_error(w, "t: mkdir_private_b", "mkdir");
      return FAIL;
    }
  }
  return DONE;
}

static int task_rmdir_private_b(worker_t* w) {
  // unlink ::/threadname/b
  task_debug_op(w, "t: rmdir_private_b");
  char fname[PATH_MAX];
  snprintf(fname, sizeof(fname), "::/%s/b", w->name);
  int rc = rmdir(fname);
  if (rc < 0) {
    // errno may be one of ENOENT, ENOTDIR, ENOTEMPTY
    if (errno != ENOENT && errno != ENOTDIR && errno != ENOTDIR) {
      task_error(w, "t: rmdir_private_b", "rmdir");
      return FAIL;
    }
  }
  return DONE;
}

static int task_move_a_to_private(worker_t* w) {
  // mv ::/a -> ::/threadname/a
  task_debug_op(w, "t: mv_a_to__private");
  char fname[PATH_MAX];
  snprintf(fname, sizeof(fname), "::/%s/a", w->name);
  int rc = rename("::/a", fname);
  if (rc < 0) {
    // errno may be one of EEXIST, ENOENT, ENOTDIR
    if (errno != EEXIST && errno != ENOENT && errno != ENOTDIR) {
      task_error(w, "t: mv_a_to__private", "rename");
      return FAIL;
    }
  }
  return DONE;
}

static int task_write_private_b(worker_t* w) {
  // put a page of data into ::/threadname/b
  task_debug_op(w, "t: write_private_b");
  char fname[PATH_MAX];
  snprintf(fname, sizeof(fname), "::/%s/b", w->name);
  int fd = open(fname, O_RDWR + O_EXCL + O_CREAT, 0666);
  if (fd < 0) {
    // errno may be one of ENOENT, EISDIR, ENOTDIR, EEXIST
    if (errno != ENOENT && errno != EISDIR && errno != ENOTDIR && errno != EEXIST) {
      task_error(w, "t: write_private_b", "open");
      return FAIL;
    }
  } else {
    char buf[BLKSIZE];
    memset(buf, 0xba, sizeof(buf));
    ssize_t len = write(fd, buf, sizeof(buf));
    if (len < 0) {
      task_error(w, "t: write_private_b", "write");
      return FAIL;
    }
    assert(len == sizeof(buf));
    EXPECT_EQ(close(fd), 0, "");
  }
  return DONE;
}

static int task_rename_private_ba(worker_t* w) {
  // move ::/threadname/b -> ::/a
  task_debug_op(w, "t: rename_private_ba");
  char fname[PATH_MAX];
  snprintf(fname, sizeof(fname), "::/%s/b", w->name);
  int rc = rename(fname, "::/a");
  if (rc < 0) {
    // errno may be one of EEXIST, ENOENT
    if (errno != EEXIST && errno != ENOENT) {
      task_error(w, "t: rename_private_ba", "rename");
      return FAIL;
    }
  }
  return DONE;
}

static int task_rename_private_ab(worker_t* w) {
  // move ::/threadname/a -> ::/b
  task_debug_op(w, "t: rename_private_ab");
  char fname[PATH_MAX];
  snprintf(fname, sizeof(fname), "::/%s/a", w->name);
  int rc = rename(fname, "::/b");
  if (rc < 0) {
    // errno may be one of EEXIST, ENOENT
    if (errno != EEXIST && errno != ENOENT) {
      task_error(w, "t: rename_private_ab", "rename");
      return FAIL;
    }
  }
  return DONE;
}

static int task_open_private_a(worker_t* w) {
  // close(fd); fd <- open("::/threadhame/a")
  task_debug_op(w, "t: open_private_a");
  if (w->fd >= 0) {
    EXPECT_EQ(close(w->fd), 0, "");
  }
  char fname[PATH_MAX];
  snprintf(fname, sizeof(fname), "::/%s/a", w->name);
  w->fd = open(fname, O_RDWR + O_CREAT + O_EXCL, 0666);
  if (w->fd < 0) {
    if (errno == EEXIST) {
      w->fd = open(fname, O_RDWR + O_EXCL);
      if (w->fd < 0) {
        task_error(w, "t: open_private_a", "open-existing");
        return FAIL;
      }
    } else {
      // errno may be one of EEXIST, ENOENT
      if (errno != ENOENT) {
        task_error(w, "t: open_private_a", "open");
        return FAIL;
      }
    }
  }
  return DONE;
}

static int task_close_fd(worker_t* w) {
  // close(fd)
  task_debug_op(w, "t: close_fd");
  if (w->fd >= 0) {
    int rc = close(w->fd);
    if (rc < 0) {
      // errno may be one of ??
      task_error(w, "t: close_fd", "close");
      return FAIL;
    }
    w->fd = -1;
  }
  return DONE;
}

static int task_write_fd_big(worker_t* w) {
  // write(fd, big buffer, ...)
  task_debug_op(w, "t: write_fd_big");
  if (w->fd >= 0) {
    char buf[FBUFSIZE];
    memset(buf, 0xab, sizeof(buf));
    ssize_t len = write(w->fd, buf, sizeof(buf));
    if (len < 0) {
      // errno may be one of ??
      task_error(w, "t: write_fd_small", "write");
      return FAIL;
    } else {
      assert(len == sizeof(buf));
      off_t off = lseek(w->fd, 0, SEEK_CUR);
      assert(off >= 0);
      if (off >= w->size) {
        off = lseek(w->fd, 0, SEEK_SET);
        assert(off == 0);
      }
    }
  }
  return DONE;
}

static int task_write_fd_small(worker_t* w) {
  // write(fd, small buffer, ...)
  task_debug_op(w, "t: write_fd_small");
  if (w->fd >= 0) {
    char buf[BLKSIZE];
    memset(buf, 0xab, sizeof(buf));
    ssize_t len = write(w->fd, buf, sizeof(buf));
    if (len < 0) {
      // errno may be one of ??
      task_error(w, "t: write_fd_small", "write");
      return FAIL;
    } else {
      assert(len == sizeof(buf));
      off_t off = lseek(w->fd, 0, SEEK_CUR);
      assert(off >= 0);
      if (off >= w->size) {
        off = lseek(w->fd, 0, SEEK_SET);
        assert(off == 0);
      }
    }
  }
  return DONE;
}

static int task_truncate_fd(worker_t* w) {
  // ftruncate(fd)
  task_debug_op(w, "t: truncate_fd");
  if (w->fd >= 0) {
    int rc = ftruncate(w->fd, 0);
    if (rc < 0) {
      // errno may be one of ??
      task_error(w, "t: truncate_fd", "truncate");
      return FAIL;
    }
  }
  return DONE;
}

static int task_utime_fd(worker_t* w) {
  // utime(fd)
  task_debug_op(w, "t: utime_fd");
  if (w->fd >= 0) {
    struct timespec ts[2] = {
        {.tv_nsec = UTIME_OMIT},  // no atime
        {.tv_nsec = UTIME_NOW},   // mtime == now
    };
    int rc = futimens(w->fd, ts);
    if (rc < 0) {
      task_error(w, "t: utime_fd", "futimens");
      return FAIL;
    }
  }
  return DONE;
}

static int task_seek_fd_end(worker_t* w) {
  task_debug_op(w, "t: seek_fd_end");
  if (w->fd >= 0) {
    int rc = lseek(w->fd, 0, SEEK_END);
    if (rc < 0) {
      // errno may be one of ??
      task_error(w, "t: seek_fd_end", "lseek");
      return FAIL;
    }
  }
  return DONE;
}

static int task_seek_fd_start(worker_t* w) {
  // fseek(fd, SEEK_SET, 0)
  task_debug_op(w, "t: seek_fd_start");
  if (w->fd >= 0) {
    int rc = lseek(w->fd, 0, SEEK_SET);
    if (rc < 0) {
      // errno may be one of ??
      task_error(w, "t: seek_fd_start", "lseek");
      return FAIL;
    }
  }
  return DONE;
}

static int task_truncate_a(worker_t* w) {
  // truncate("::/a")
  int rc = truncate("::/a", 0);
  if (rc < 0) {
    // errno may be one of ENOENT
    if (errno != ENOENT) {
      task_error(w, "t: truncate_a", "truncate");
      return FAIL;
    }
  }
  return DONE;
}

static struct random_op {
  const char* name;
  int (*fn)(worker_t*);
  unsigned weight;
} OPS[] = {
    {"task_create_a", task_create_a, 1},
    {"task_create_b", task_create_b, 1},
    {"task_rename_ab", task_rename_ab, 4},
    {"task_rename_ba", task_rename_ba, 4},
    {"task_make_private_dir", task_make_private_dir, 4},
    {"task_move_a_to_private", task_move_a_to_private, 1},
    {"task_write_private_b", task_write_private_b, 1},
    {"task_rename_private_ba", task_rename_private_ba, 1},
    {"task_rename_private_ab", task_rename_private_ab, 1},
    {"task_open_private_a", task_open_private_a, 5},
    {"task_close_fd", task_close_fd, 2},
    {"task_write_fd_big", task_write_fd_big, 20},
    {"task_write_fd_small", task_write_fd_small, 20},
    {"task_truncate_fd", task_truncate_fd, 2},
    {"task_utime_fd", task_utime_fd, 2},
    {"task_seek_fd", task_seek_fd_start, 2},
    {"task_seek_fd_end", task_seek_fd_end, 2},
    {"task_truncate_a", task_truncate_a, 1},
};

// create a weighted list of operations for each thread
static void add_random_ops(env_t* env) {
  // expand the list of n*countof(OPS) operations weighted appropriately
  int n_ops = 0;
  for (unsigned i = 0; i < countof(OPS); i++) {
    n_ops += OPS[i].weight;
  }
  random_op_t* ops_list = malloc(n_ops * sizeof(random_op_t));
  assert(ops_list != NULL);

  unsigned op = 0;
  for (unsigned i = 0; i < countof(OPS); i++) {
    unsigned n_op = OPS[i].weight;
    for (unsigned j = 0; j < n_op; j++) {
      ops_list[op++] = OPS[i];
    }
  }
  env->ops = ops_list;
  env->n_ops = n_ops;
}

static const unsigned N_SERIAL_OPS = 4;  // yield every 1/n ops

static const unsigned MAX_OPS = 1000;
static int do_random_ops(void* arg) {
  worker_t* w = arg;
  env_t* env = w->env;

  // for some big number of operations
  // do an operation and yield, repeat
  for (unsigned i = 0; i < MAX_OPS; i++) {
    unsigned idx = rand_r(&w->seed) % env->n_ops;
    random_op_t* op = env->ops + idx;

    if (op->fn(w) != DONE) {
      fprintf(stderr, "%s: op %s failed\n", w->name, op->name);
      exit(1);
    }
    if ((idx % N_SERIAL_OPS) != 0)
      thrd_yield();
  }

  // Close the worker's personal fd (if it is open) and
  // unlink the worker directory.
  fprintf(stderr, "work thread(%s) done\n", w->name);
  task_close_fd(w);
  unlink(w->name);

  // currently, threads either return DONE or exit the test
  return DONE;
}

bool test_random_op_multithreaded(void) {
  BEGIN_TEST;

  env_t env;
  ASSERT_TRUE(init_environment(&env), "");

  for (worker_t* w = env.all_workers; w != NULL; w = w->next) {
    // start the workers on separate threads
    thrd_t t;
    ASSERT_EQ(thrd_create(&t, do_random_ops, w), thrd_success, "");

    thread_list_t* thread = malloc(sizeof(thread_list_t));
    ASSERT_NE(thread, NULL, "");
    thread->t = t;
    list_add_tail(&env.threads, &thread->node);
  }

  thrd_t timer_thread;
  ASSERT_EQ(thrd_create(&timer_thread, log_timer, &env), thrd_success, "");

  thread_list_t* next;
  thread_list_t* prev = NULL;
  list_for_every_entry (&env.threads, next, thread_list_t, node) {
    int rc;
    ASSERT_EQ(thrd_join(next->t, &rc), thrd_success, "");
    ASSERT_EQ(rc, DONE, "Background thread joined, but failed");
    if (prev) {
      free(prev);
    }
    prev = next;
  }
  if (prev) {
    free(prev);
  }

  // signal to timer that all threads have finished
  mtx_lock(&env.log_timer_lock);
  env.tests_finished = true;
  mtx_unlock(&env.log_timer_lock);

  ASSERT_EQ(cnd_broadcast(&env.log_timer_cnd), thrd_success, "");

  int rc;
  ASSERT_EQ(thrd_join(timer_thread, &rc), thrd_success, "");
  ASSERT_EQ(rc, 0, "Timer thread failed");

  free(env.ops);
  free_workers(&env);

  END_TEST;
}

RUN_FOR_ALL_FILESYSTEMS(random_ops_tests, RUN_TEST_LARGE(test_random_op_multithreaded))