filelock.c

/*
 * Really simple exclusive file locking based on filename.
 * No hash indexing, just a list, so only works well for < 100 files or
 * so. But that's more than what fio needs, so should be fine.
 */
#include <inttypes.h>
#include <string.h>
#include <assert.h>

#include "flist.h"
#include "filelock.h"
#include "smalloc.h"
#include "mutex.h"
#include "hash.h"
#include "log.h"

struct fio_filelock {
	uint32_t hash;
	struct fio_mutex lock;
	struct flist_head list;
	unsigned int references;
};
	
static struct flist_head *filelock_list;
static struct fio_mutex *filelock_lock;

int fio_filelock_init(void)
{
	filelock_list = smalloc(sizeof(*filelock_list));
	if (!filelock_list)
		return 1;

	INIT_FLIST_HEAD(filelock_list);
	filelock_lock = fio_mutex_init(FIO_MUTEX_UNLOCKED);
	if (!filelock_lock) {
		sfree(filelock_list);
		return 1;
	}

	return 0;
}

void fio_filelock_exit(void)
{
	if (!filelock_list)
		return;

	assert(flist_empty(filelock_list));
	sfree(filelock_list);
	filelock_list = NULL;
	fio_mutex_remove(filelock_lock);
	filelock_lock = NULL;
}

static struct fio_filelock *fio_hash_find(uint32_t hash)
{
	struct flist_head *entry;
	struct fio_filelock *ff;

	flist_for_each(entry, filelock_list) {
		ff = flist_entry(entry, struct fio_filelock, list);
		if (ff->hash == hash)
			return ff;
	}

	return NULL;
}

static struct fio_filelock *fio_hash_get(uint32_t hash)
{
	struct fio_filelock *ff;

	ff = fio_hash_find(hash);
	if (!ff) {
		ff = smalloc(sizeof(*ff));
		ff->hash = hash;
		__fio_mutex_init(&ff->lock, FIO_MUTEX_UNLOCKED);
		ff->references = 0;
		flist_add(&ff->list, filelock_list);
	}

	return ff;
}

int fio_trylock_file(const char *fname)
{
	struct fio_filelock *ff;
	uint32_t hash;

	hash = jhash(fname, strlen(fname), 0);

	fio_mutex_down(filelock_lock);
	ff = fio_hash_get(hash);
	ff->references++;
	fio_mutex_up(filelock_lock);

	if (!fio_mutex_down_trylock(&ff->lock))
		return 0;

	fio_mutex_down(filelock_lock);

	/*
	 * If we raced and the only reference to the lock is us, we can
	 * grab it
	 */
	if (ff->references != 1) {
		ff->references--;
		ff = NULL;
	}

	fio_mutex_up(filelock_lock);

	if (ff) {
		fio_mutex_down(&ff->lock);
		return 0;
	}

	return 1;
}

void fio_lock_file(const char *fname)
{
	struct fio_filelock *ff;
	uint32_t hash;

	hash = jhash(fname, strlen(fname), 0);

	fio_mutex_down(filelock_lock);
	ff = fio_hash_get(hash);
	ff->references++;
	fio_mutex_up(filelock_lock);

	fio_mutex_down(&ff->lock);
}

void fio_unlock_file(const char *fname)
{
	struct fio_filelock *ff;
	uint32_t hash;

	hash = jhash(fname, strlen(fname), 0);

	fio_mutex_down(filelock_lock);

	ff = fio_hash_find(hash);
	if (ff) {
		ff->references--;
		fio_mutex_up(&ff->lock);
		if (!ff->references) {
			flist_del(&ff->list);
			sfree(ff);
		}
	} else
		log_err("fio: file not found for unlocking\n");

	fio_mutex_up(filelock_lock);
}