fat_cache.c

Go to the documentation of this file.

#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <stdint.h>
#include <fcntl.h>
#include <unistd.h>
#include <pthread.h>
#include <errno.h>

#include <fat_cache.h>

struct fat_cache {
        int handle;
        int offset;
        char *buffer;
        int size;
        pthread_mutex_t mutex;
};

struct fat_cache *create_fat_cache(const char *node, int size)
{
        struct fat_cache *cache;

        cache = malloc(sizeof(*cache));
        if (!cache) {
                return NULL;
        }

        cache->handle = open(node, O_RDWR);
        if (cache->handle < 0) {
                free(cache);
                return NULL;
        }

        cache->buffer = malloc(size);
        if (!cache->buffer) {
                close(cache->handle);
                free(cache);
                return NULL;
        }

        cache->size = size;
        cache->offset = ~0; /* This is not valid offset */
        pthread_mutex_init(&cache->mutex, NULL);
        return cache;
}

void destroy_fat_cache(struct fat_cache *cache)
{
        pthread_mutex_destroy(&cache->mutex);
        free(cache->buffer);
        close(cache->handle);
        free(cache);
}

int update_fat_cache(struct fat_cache *cache, off_t offset)
{
        int ret = 0;

        if (cache->size == 0) {
                printf("Invalid cache size\n");
                ret = -EINVAL;
                goto out;
        }

        offset = (offset / cache->size) * cache->size;

        if (cache->offset == offset) {
                goto out;
        }

        ret = lseek(cache->handle, offset, SEEK_SET);
        if (ret < 0) {
                goto out;
        }

        ret = read(cache->handle, cache->buffer, cache->size);
        if (ret < 0) {
                goto out;
        }

        cache->offset = offset;

out:
        return ret;
}

void *fat_cache(struct fat_cache *cache)
{
        return cache->buffer;
}

int fat_cache_size(struct fat_cache *cache)
{
        return cache->size;
}

void fat_cache_lock(struct fat_cache *cache)
{
        pthread_mutex_lock(&cache->mutex);
}

void fat_cache_unlock(struct fat_cache *cache)
{
        pthread_mutex_unlock(&cache->mutex);
}

/* End of a file */