os161-assignments/userland/testbin/dirconc/dirconc.c

/*
 * Copyright (c) 2000, 2001, 2002, 2003, 2004, 2005, 2008, 2009
 *	The President and Fellows of Harvard College.
 *
 * 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 of the University 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 UNIVERSITY 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 UNIVERSITY 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.
 */

/*
 * Concurrent directory operations test.
 *
 * Your system should survive this (without leaving a corrupted file
 * system behind) once the file system assignment is complete.
 */

#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>

#define NTRIES 100 /* loop count */
#define NPROCS 5   /* actually totals 4x this +1 processes */

#define TESTDIR "dirconc"
#define NNAMES 4
#define NAMESIZE 32

////////////////////////////////////////////////////////////

static const char *const names[NNAMES] = {
    "aaaa",
    "bbbb",
    "cccc",
    "dddd",
};

static void choose_name(char *buf, size_t len) {
  const char *a, *b, *c;

  a = names[random() % NNAMES];
  if (random() % 2 == 0) {
    snprintf(buf, len, "%s", a);
    return;
  }
  b = names[random() % NNAMES];
  if (random() % 2 == 0) {
    snprintf(buf, len, "%s/%s", a, b);
    return;
  }
  c = names[random() % NNAMES];
  snprintf(buf, len, "%s/%s/%s", a, b, c);
}

////////////////////////////////////////////////////////////

/*
 * The purpose of this is to be atomic. In our world, straight
 * printf tends not to be.
 */
static void
#ifdef __GNUC__
    __attribute__((__format__(__printf__, 1, 2)))
#endif
    say(const char *fmt, ...) {
  char buf[512];
  va_list ap;
  va_start(ap, fmt);
  vsnprintf(buf, sizeof(buf), fmt, ap);
  va_end(ap);
  write(STDOUT_FILENO, buf, strlen(buf));
}

////////////////////////////////////////////////////////////

static void dorename(const char *name1, const char *name2) {
  if (rename(name1, name2) < 0) {
    switch (errno) {
    case ENOENT:
    case ENOTEMPTY:
    case EINVAL:
      break;
    default:
      say("pid %d: rename %s -> %s: %s\n", getpid(), name1, name2,
          strerror(errno));
      break;
    }
  }
}

static void domkdir(const char *name) {
  if (mkdir(name, 0775) < 0) {
    switch (errno) {
    case ENOENT:
    case EEXIST:
      break;
    default:
      say("pid %d: mkdir %s: %s\n", getpid(), name, strerror(errno));
      break;
    }
  }
}

static void dormdir(const char *name) {
  if (rmdir(name) < 0) {
    switch (errno) {
    case ENOENT:
    case ENOTEMPTY:
      break;
    default:
      say("pid %d: rmdir %s: %s\n", getpid(), name, strerror(errno));
      break;
    }
  }
}

static void cleanup_rmdir(const char *name) {
  if (rmdir(name) < 0) {
    switch (errno) {
    case ENOENT:
      break;
    default:
      say("cleanup (pid %d): rmdir %s: %s\n", getpid(), name, strerror(errno));
      break;
    }
  }
}

////////////////////////////////////////////////////////////

static void rename_proc(void) {
  char name1[NAMESIZE], name2[NAMESIZE];
  int ct;

  for (ct = 0; ct < NTRIES; ct++) {
    choose_name(name1, sizeof(name1));
    choose_name(name2, sizeof(name2));
    say("pid %2d: rename %s -> %s\n", (int)getpid(), name1, name2);
    dorename(name1, name2);
  }
}

static void mkdir_proc(void) {
  char name[NAMESIZE];
  int ct;

  for (ct = 0; ct < NTRIES; ct++) {
    choose_name(name, sizeof(name));
    say("pid %2d: mkdir  %s\n", (int)getpid(), name);
    domkdir(name);
  }
}

static void rmdir_proc(void) {
  char name[NAMESIZE];
  int ct;

  for (ct = 0; ct < NTRIES; ct++) {
    choose_name(name, sizeof(name));
    say("pid %2d: rmdir  %s\n", (int)getpid(), name);
    dormdir(name);
  }
}

////////////////////////////////////////////////////////////

static pid_t dofork(void (*func)(void)) {
  pid_t pid;

  pid = fork();
  if (pid < 0) {
    say("fork: %s\n", strerror(errno));
    return -1;
  }
  if (pid == 0) {
    /* child */
    func();
    exit(0);
  }
  return pid;
}

static void run(void) {
  pid_t pids[NPROCS * 4], wp;
  int i, status;

  for (i = 0; i < NPROCS; i++) {
    pids[i * 4] = dofork(mkdir_proc);
    pids[i * 4 + 1] = dofork(mkdir_proc);
    pids[i * 4 + 2] = dofork(rename_proc);
    pids[i * 4 + 3] = dofork(rmdir_proc);
  }

  for (i = 0; i < NPROCS * 4; i++) {
    if (pids[i] >= 0) {
      wp = waitpid(pids[i], &status, 0);
      if (wp < 0) {
        say("waitpid %d: %s\n", (int)pids[i], strerror(errno));
      } else if (WIFSIGNALED(status)) {
        say("pid %d: signal %d\n", (int)pids[i], WTERMSIG(status));
      } else if (WIFEXITED(status) && WEXITSTATUS(status) != 0) {
        say("pid %d: exit %d\n", (int)pids[i], WEXITSTATUS(status));
      }
    }
  }
}

////////////////////////////////////////////////////////////

static void setup(const char *fs) {
  if (chdir(fs) < 0) {
    say("chdir: %s: %s\n", fs, strerror(errno));
    exit(1);
  }
  if (mkdir(TESTDIR, 0775) < 0) {
    say("mkdir: %s: %s\n", TESTDIR, strerror(errno));
    exit(1);
  }
  if (chdir(TESTDIR) < 0) {
    say("chdir: %s: %s\n", TESTDIR, strerror(errno));
    exit(1);
  }
}

static void recursive_cleanup(const char *sofar, int depth) {
  char buf[NAMESIZE * 32];
  int i;

  for (i = 0; i < NNAMES; i++) {
    snprintf(buf, sizeof(buf), "%s/%s", sofar, names[i]);
    if (rmdir(buf) < 0) {
      if (errno == ENOTEMPTY) {
        recursive_cleanup(buf, depth + 1);
        cleanup_rmdir(buf);
      } else if (errno != ENOENT) {
        say("cleanup (pid %d): rmdir %s: %s\n", getpid(), buf, strerror(errno));
      }
    }
  }
}

static void cleanup(void) {
  recursive_cleanup(".", 0);

  chdir("..");
  cleanup_rmdir(TESTDIR);
}

////////////////////////////////////////////////////////////

int main(int argc, char *argv[]) {
  const char *fs;
  long seed = 0;

  say("Concurrent directory ops test\n");

  if (argc == 0 || argv == NULL) {
    say("Warning: argc is 0 - assuming you mean to run on lhd1: "
        "with seed 0\n");
    fs = "lhd1:";
  } else if (argc == 2) {
    fs = argv[1];
  } else if (argc == 3) {
    fs = argv[1];
    seed = atoi(argv[2]);
  } else {
    say("Usage: dirconc filesystem [random-seed]\n");
    exit(1);
  }

  srandom(seed);
  setup(fs);
  say("Starting in %s/%s\n", fs, TESTDIR);

  run();

  say("Cleaning up\n");
  cleanup();

  return 0;
}