[fio.git] / filehash.c

#include <stdlib.h>
#include <assert.h>

#include "fio.h"
#include "flist.h"
#include "hash.h"
#include "filehash.h"

#define HASH_BUCKETS	512
#define HASH_MASK	(HASH_BUCKETS - 1)

unsigned int file_hash_size = HASH_BUCKETS * sizeof(struct flist_head);

static struct flist_head *file_hash;
static struct fio_mutex *hash_lock;

static unsigned short hash(const char *name)
{
	return jhash(name, strlen(name), 0) & HASH_MASK;
}

void fio_file_hash_lock(void)
{
	if (hash_lock)
		fio_mutex_down(hash_lock);
}

void fio_file_hash_unlock(void)
{
	if (hash_lock)
		fio_mutex_up(hash_lock);
}

void remove_file_hash(struct fio_file *f)
{
	fio_mutex_down(hash_lock);

	if (fio_file_hashed(f)) {
		assert(!flist_empty(&f->hash_list));
		flist_del_init(&f->hash_list);
		fio_file_clear_hashed(f);
	}

	fio_mutex_up(hash_lock);
}

static struct fio_file *__lookup_file_hash(const char *name)
{
	struct flist_head *bucket = &file_hash[hash(name)];
	struct flist_head *n;

	flist_for_each(n, bucket) {
		struct fio_file *f = flist_entry(n, struct fio_file, hash_list);

		if (!f->file_name)
			continue;

		if (!strcmp(f->file_name, name)) {
			assert(f->fd != -1);
			return f;
		}
	}

	return NULL;
}

struct fio_file *lookup_file_hash(const char *name)
{
	struct fio_file *f;

	fio_mutex_down(hash_lock);
	f = __lookup_file_hash(name);
	fio_mutex_up(hash_lock);
	return f;
}

struct fio_file *add_file_hash(struct fio_file *f)
{
	struct fio_file *alias;

	if (fio_file_hashed(f))
		return NULL;

	INIT_FLIST_HEAD(&f->hash_list);

	fio_mutex_down(hash_lock);

	alias = __lookup_file_hash(f->file_name);
	if (!alias) {
		fio_file_set_hashed(f);
		flist_add_tail(&f->hash_list, &file_hash[hash(f->file_name)]);
	}

	fio_mutex_up(hash_lock);
	return alias;
}

void file_hash_exit(void)
{
	unsigned int i, has_entries = 0;

	fio_mutex_down(hash_lock);
	for (i = 0; i < HASH_BUCKETS; i++)
		has_entries += !flist_empty(&file_hash[i]);
	fio_mutex_up(hash_lock);

	if (has_entries)
		log_err("fio: file hash not empty on exit\n");

	file_hash = NULL;
	fio_mutex_remove(hash_lock);
	hash_lock = NULL;
}

void file_hash_init(void *ptr)
{
	unsigned int i;

	file_hash = ptr;
	for (i = 0; i < HASH_BUCKETS; i++)
		INIT_FLIST_HEAD(&file_hash[i]);

	hash_lock = fio_mutex_init(FIO_MUTEX_UNLOCKED);
}
Commit	Line	Data
380065aa JA	1	#include <stdlib.h>
	2	#include <assert.h>
	3
	4	#include "fio.h"
01743ee1	5	#include "flist.h"
dadf66c5	6	#include "hash.h"
10aa136b	7	#include "filehash.h"
380065aa JA	8
	9	#define HASH_BUCKETS 512
	10	#define HASH_MASK (HASH_BUCKETS - 1)
	11
01743ee1	12	unsigned int file_hash_size = HASH_BUCKETS * sizeof(struct flist_head);
380065aa	13
01743ee1	14	static struct flist_head *file_hash;
b950781e	15	static struct fio_mutex *hash_lock;
380065aa	16
380065aa JA	17	static unsigned short hash(const char *name)
380065aa JA	18	{
dadf66c5	19	return jhash(name, strlen(name), 0) & HASH_MASK;
380065aa JA	20	}
380065aa JA	21
90426237 JA	22	void fio_file_hash_lock(void)
90426237 JA	23	{
45aeca74 JA	24	if (hash_lock)
45aeca74 JA	25	fio_mutex_down(hash_lock);
90426237 JA	26	}
	27
	28	void fio_file_hash_unlock(void)
	29	{
45aeca74 JA	30	if (hash_lock)
45aeca74 JA	31	fio_mutex_up(hash_lock);
90426237 JA	32	}
90426237 JA	33
380065aa JA	34	void remove_file_hash(struct fio_file *f)
380065aa JA	35	{
b950781e	36	fio_mutex_down(hash_lock);
380065aa	37
d6aed795	38	if (fio_file_hashed(f)) {
01743ee1 JA	39	assert(!flist_empty(&f->hash_list));
01743ee1 JA	40	flist_del_init(&f->hash_list);
d6aed795	41	fio_file_clear_hashed(f);
380065aa JA	42	}
380065aa JA	43
b950781e	44	fio_mutex_up(hash_lock);
380065aa JA	45	}
	46
	47	static struct fio_file __lookup_file_hash(const char name)
	48	{
01743ee1 JA	49	struct flist_head *bucket = &file_hash[hash(name)];
01743ee1 JA	50	struct flist_head *n;
380065aa	51
01743ee1 JA	52	flist_for_each(n, bucket) {
01743ee1 JA	53	struct fio_file *f = flist_entry(n, struct fio_file, hash_list);
380065aa	54
89541106 JA	55	if (!f->file_name)
	56	continue;
	57
380065aa JA	58	if (!strcmp(f->file_name, name)) {
	59	assert(f->fd != -1);
	60	return f;
	61	}
	62	}
	63
380065aa JA	64	return NULL;
	65	}
	66
	67	struct fio_file lookup_file_hash(const char name)
	68	{
	69	struct fio_file *f;
	70
b950781e	71	fio_mutex_down(hash_lock);
380065aa	72	f = __lookup_file_hash(name);
b950781e	73	fio_mutex_up(hash_lock);
380065aa JA	74	return f;
	75	}
	76
	77	struct fio_file add_file_hash(struct fio_file f)
	78	{
	79	struct fio_file *alias;
	80
d6aed795	81	if (fio_file_hashed(f))
380065aa JA	82	return NULL;
380065aa JA	83
01743ee1	84	INIT_FLIST_HEAD(&f->hash_list);
380065aa	85
b950781e	86	fio_mutex_down(hash_lock);
380065aa JA	87
	88	alias = __lookup_file_hash(f->file_name);
	89	if (!alias) {
d6aed795	90	fio_file_set_hashed(f);
01743ee1	91	flist_add_tail(&f->hash_list, &file_hash[hash(f->file_name)]);
380065aa JA	92	}
380065aa JA	93
b950781e	94	fio_mutex_up(hash_lock);
380065aa JA	95	return alias;
	96	}
	97
5e1d306e JA	98	void file_hash_exit(void)
	99	{
	100	unsigned int i, has_entries = 0;
	101
b950781e	102	fio_mutex_down(hash_lock);
5e1d306e	103	for (i = 0; i < HASH_BUCKETS; i++)
01743ee1	104	has_entries += !flist_empty(&file_hash[i]);
b950781e	105	fio_mutex_up(hash_lock);
5e1d306e JA	106
	107	if (has_entries)
	108	log_err("fio: file hash not empty on exit\n");
	109
b950781e JA	110	file_hash = NULL;
b950781e JA	111	fio_mutex_remove(hash_lock);
5e1d306e JA	112	hash_lock = NULL;
	113	}
	114
380065aa JA	115	void file_hash_init(void *ptr)
	116	{
	117	unsigned int i;
	118
	119	file_hash = ptr;
	120	for (i = 0; i < HASH_BUCKETS; i++)
01743ee1	121	INIT_FLIST_HEAD(&file_hash[i]);
380065aa	122
521da527	123	hash_lock = fio_mutex_init(FIO_MUTEX_UNLOCKED);
380065aa	124	}