146 lines
4.6 KiB
C
146 lines
4.6 KiB
C
/* _,.---._ .-._ .--.-. ,--.--------.
|
|
* _,..---._ ,-.' , - `. /==/ \ .-._/==/ //==/, - , -\
|
|
* /==/, - \ /==/_, , - \|==|, \/ /, |==\ -\\==\.-. - ,-./
|
|
* |==| _ _\==| .=. |==|- \| | \==\- \`--`\==\- \
|
|
* |==| .=. |==|_ : ;=: - |==| , | -| `--`-' \==\_ \
|
|
* |==|,| | -|==| , '=' |==| - _ | |==|- |
|
|
* |==| '=' /\==\ - ,_ /|==| /\ , | |==|, |
|
|
* |==|-, _`/ '.='. - .' /==/, | |- | /==/ -/
|
|
* `-.`.____.' `--`--'' `--`./ `--` `--`--`
|
|
* _ __ ,---. .-._ .=-.-. _,.----.
|
|
* .-`.' ,`..--.' \ /==/ \ .-._ /==/_ /.' .' - \
|
|
* /==/, - \==\-/\ \ |==|, \/ /, /==|, |/==/ , ,-'
|
|
* |==| _ .=. /==/-|_\ | |==|- \| ||==| ||==|- | .
|
|
* |==| , '=',\==\, - \ |==| , | -||==|- ||==|_ `-' \
|
|
* |==|- '..'/==/ - ,| |==| - _ ||==| ,||==| _ , |
|
|
* |==|, | /==/- /\ - \|==| /\ , ||==|- |\==\. /
|
|
* /==/ - | \==\ _.\=\.-'/==/, | |- |/==/. / `-.`.___.-'
|
|
* `--`---' `--` `--`./ `--``--`-`
|
|
*
|
|
* @(#)Copyright (c) 2023, Nathan D. Fisher.
|
|
*
|
|
* This is free software. It comes with NO WARRANTY.
|
|
* Permission to use, modify and distribute this source code
|
|
* is granted subject to the following conditions.
|
|
* 1/ that the above copyright notice and this notice
|
|
* are preserved in all copies and that due credit be given
|
|
* to the author.
|
|
* 2/ that any changes to this code are clearly commented
|
|
* as such so that the author does not get blamed for bugs
|
|
* other than his own.
|
|
*/
|
|
|
|
#include "haggis.h"
|
|
#include "haggis_private.h"
|
|
|
|
#include <limits.h> // PATH_MAX
|
|
#include <stdio.h>
|
|
#include <stdlib.h> // calloc, free
|
|
#include <string.h> // strndup
|
|
|
|
#define FNV64_OFFSET_BASIS 14695981039346656037u
|
|
#define FNV64_PRIME 1099511628211u
|
|
|
|
uint64_t hash_fnv1a_64(uint8_t *key, size_t len) {
|
|
int i;
|
|
uint64_t hash = FNV64_OFFSET_BASIS;
|
|
|
|
for (i = 0; i < len; i++) {
|
|
hash = hash ^ *key;
|
|
hash = hash * FNV64_PRIME;
|
|
key++;
|
|
}
|
|
return hash;
|
|
}
|
|
|
|
uint64_t hash_str_fnv1a_64(char * s) {
|
|
uint64_t hash = FNV64_OFFSET_BASIS;
|
|
|
|
while (*s != '\0') {
|
|
hash = hash ^ *s;
|
|
hash = hash * FNV64_PRIME;
|
|
s++;
|
|
}
|
|
return hash;
|
|
}
|
|
|
|
haggis_linkmap* haggis_linkmap_init() {
|
|
haggis_linkmap *map;
|
|
|
|
map = calloc(1, sizeof(haggis_linkmap));
|
|
if (map == NULL)
|
|
return NULL;
|
|
map->buckets = calloc(HAGGIS_BUCKETS_BASE, sizeof(haggis_bucket));
|
|
if (map->buckets == NULL) {
|
|
free(map);
|
|
return NULL;
|
|
}
|
|
map->capacity = HAGGIS_BUCKETS_BASE;
|
|
return map;
|
|
}
|
|
|
|
void haggis_linkmap_deinit(haggis_linkmap *self) {
|
|
free(self->buckets);
|
|
free(self);
|
|
}
|
|
|
|
int haggis_linkmap_expand(haggis_linkmap *self) {
|
|
haggis_bucket *buckets_new;
|
|
haggis_bucket *buckets_old;
|
|
size_t i, idx;
|
|
|
|
buckets_new = calloc(self->capacity + HAGGIS_BUCKETS_BASE, sizeof(haggis_bucket));
|
|
if (buckets_new == NULL)
|
|
return 2;
|
|
for (i = 0; i < self->capacity + HAGGIS_BUCKETS_BASE; i++) {
|
|
self->buckets[i].path = NULL;
|
|
}
|
|
for (i = 0; i < self->capacity; i++) {
|
|
if (self->buckets[i].key != 0) {
|
|
self ->capacity += HAGGIS_BUCKETS_BASE;
|
|
idx = self->capacity % self->buckets[i].hash;
|
|
buckets_new[idx] = self->buckets[i];
|
|
}
|
|
}
|
|
buckets_old = self->buckets;
|
|
self->buckets = buckets_new;
|
|
free(buckets_old);
|
|
self->capacity += HAGGIS_BUCKETS_BASE;
|
|
return 0;
|
|
}
|
|
|
|
char* haggis_linkmap_get_or_add(haggis_linkmap *self, ino_t inode, char *path) {
|
|
union {
|
|
ino_t val;
|
|
u8 bytes[sizeof(ino_t)];
|
|
} key;
|
|
char * target = NULL;
|
|
size_t idx, hash, i;
|
|
haggis_bucket *bucket;
|
|
|
|
pthread_mutex_lock(&self->mutex);
|
|
if (self->len >= self->capacity)
|
|
haggis_linkmap_expand(self);
|
|
key.val = inode;
|
|
hash = hash_fnv1a_64(key.bytes, sizeof(ino_t));
|
|
idx = hash % self->capacity;
|
|
for (i = 0; i < self->capacity; i++) {
|
|
bucket = &self->buckets[idx];
|
|
if (bucket->key == inode) {
|
|
target = strndup(bucket->path, PATH_MAX - 1);
|
|
break;
|
|
} else if (bucket->key == 0) {
|
|
bucket->path = path;
|
|
bucket->key = inode;
|
|
bucket->hash = hash;
|
|
self->len++;
|
|
break;
|
|
} else {
|
|
idx++;
|
|
if (idx == self->capacity)
|
|
idx = 0;
|
|
}
|
|
}
|
|
pthread_mutex_unlock(&self->mutex);
|
|
return target;
|
|
}
|