/*

* Simple hash filesystem (SHFS)

*

* Authors: Simon Kuenzer <simon.kuenzer@neclab.eu>

*

*

* Copyright (c) 2013-2017, NEC Europe Ltd., NEC Corporation All rights reserved.

*

* 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 copyright holder 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 COPYRIGHT HOLDERS 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 COPYRIGHT HOLDER 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.

*

*/

#include <target/sys.h>

#include "likely.h"

#include "shfs_fio.h"

#include "shfs.h"

#include "shfs_btable.h"

#include "shfs_cache.h"

#ifdef SHFS_STATS

#include "shfs_stats.h"

#endif

/*

* Register open on bentry and return it on success

*/

static inline SHFS_FD _shfs_fio_open_bentry(struct shfs_bentry *bentry)

{

#ifdef SHFS_STATS

struct shfs_el_stats *estats;

#endif

if (bentry->update) {

/* entry update in progress */

#ifdef SHFS_STATS

++shfs_vol.mstats.e;

#endif

errno = EBUSY;

return NULL;

}

++shfs_nb_open;

if (bentry->refcount == 0) {

trydown(&bentry->updatelock); /* lock file for updates */

shfs_fio_clear_cookie(bentry);

}

++bentry->refcount;

#ifdef SHFS_STATS

estats = shfs_stats_from_bentry(bentry);

estats->laccess = gettimestamp_s();

++estats->h;

#endif

return (SHFS_FD) bentry;

}

static inline __attribute__((always_inline))

struct shfs_bentry *_shfs_lookup_bentry_by_hash(hash512_t h)

{

struct shfs_bentry *bentry;

#ifdef SHFS_STATS

struct shfs_el_stats *estats;

#endif

bentry = shfs_btable_lookup(shfs_vol.bt, h);

#ifdef SHFS_STATS

if (unlikely(!bentry)) {

estats = shfs_stats_from_mstats(h);

if (likely(estats != NULL)) {

estats->laccess = gettimestamp_s();

++estats->m;

}

}

#endif

return bentry;

}

/*

* As long as we do not any operation that might call

* schedule() (e.g., printf()), we do not need to

* down/up the shfs_mount_lock semaphore -> coop.

* scheduler

*

* Note: This function should never be called from interrupt context

*/

SHFS_FD shfs_fio_open(const char *path)

{

hash512_t h;

struct shfs_bentry *bentry;

if (unlikely(!shfs_mounted)) {

errno = ENODEV;

return NULL;

}

/* lookup bentry (either by name or hash) */

if ((path[0] == SHFS_HASH_INDICATOR_PREFIX) &&

(path[1] != '\0')) {

if (hash_parse(path + 1, h, shfs_vol.hlen) < 0) {

#ifdef SHFS_STATS

++shfs_vol.mstats.i;

#endif

return NULL;

}

bentry = _shfs_lookup_bentry_by_hash(h);

} else {

if ((path[0] == '\0') ||

(path[0] == SHFS_HASH_INDICATOR_PREFIX && path[1] == '\0')) {

/* empty filename -> use default file */

bentry = shfs_vol.def_bentry;

#ifdef SHFS_STATS

if (!bentry)

++shfs_vol.mstats.i;

#endif

} else {

#ifdef SHFS_OPENBYNAME

bentry = shfs_btable_lookup_byname(shfs_vol.bt, shfs_vol.htable_chunk_cache, path);

#else

bentry = NULL;

#ifdef SHFS_STATS

if (unlikely(!bentry))

++shfs_vol.mstats.i;

#endif

#endif

}

}

if (!bentry) {

errno = ENOENT;

return NULL;

}

return _shfs_fio_open_bentry(bentry);

}

SHFS_FD shfs_fio_openh(hash512_t h)

{

struct shfs_bentry *bentry;

bentry = _shfs_lookup_bentry_by_hash(h);

if (!bentry) {

errno = ENOENT;

return NULL;

}

return _shfs_fio_open_bentry(bentry);

}

/*

* Opens a clone of an already opened file descriptor

* This clone has to be closed by shfs_fio_close(), too.

*/

SHFS_FD shfs_fio_openf(SHFS_FD f)

{

if (!f) {

errno = EINVAL;

return NULL;

}

if (!shfs_mounted) {

errno = ENODEV;

return NULL;

}

++f->refcount;

++shfs_nb_open;

return f;

}

/*

* Note: This function should never be called from interrupt context

*/

void shfs_fio_close(SHFS_FD f)

{

struct shfs_bentry *bentry = (struct shfs_bentry *) f;

--bentry->refcount;

if (bentry->refcount == 0) /* unlock file for updates */

up(&bentry->updatelock);

--shfs_nb_open;

}

void shfs_fio_name(SHFS_FD f, char *out, size_t outlen)

{

struct shfs_bentry *bentry = (struct shfs_bentry *) f;

struct shfs_hentry *hentry = bentry->hentry;

outlen = min(outlen, sizeof(hentry->name) + 1);

strncpy(out, hentry->name, outlen - 1);

out[outlen - 1] = '\0';

}

void shfs_fio_mime(SHFS_FD f, char *out, size_t outlen)

{

struct shfs_bentry *bentry = (struct shfs_bentry *) f;

struct shfs_hentry *hentry = bentry->hentry;

outlen = min(outlen, sizeof(hentry->f_attr.mime) + 1);

strncpy(out, hentry->f_attr.mime, outlen - 1);

out[outlen - 1] = '\0';

}

void shfs_fio_size(SHFS_FD f, uint64_t *out)

{

struct shfs_bentry *bentry = (struct shfs_bentry *) f;

struct shfs_hentry *hentry = bentry->hentry;

*out = SHFS_HENTRY_ISLINK(hentry) ? 0 : hentry->f_attr.len;

}

void shfs_fio_hash(SHFS_FD f, hash512_t out)

{

struct shfs_bentry *bentry = (struct shfs_bentry *) f;

struct shfs_hentry *hentry = bentry->hentry;

hash_copy(out, hentry->hash, shfs_vol.hlen);

}

void shfs_fio_link_rpath(SHFS_FD f, char *out, size_t outlen)

{

struct shfs_bentry *bentry = (struct shfs_bentry *) f;

struct shfs_hentry *hentry = bentry->hentry;

outlen = min(outlen, sizeof(hentry->l_attr.rpath) + 1);

strncpy(out, hentry->l_attr.rpath, outlen - 1);

out[outlen - 1] = '\0';

}

/*

* Slow sync I/O file read functions

* Warning: These functions are using busy-waiting

*/

int shfs_fio_read(SHFS_FD f, uint64_t offset, void *buf, uint64_t len)

{

struct shfs_bentry *bentry = (struct shfs_bentry *) f;

struct shfs_hentry *hentry = bentry->hentry;

void *chk_buf;

chk_t chk_off;

uint64_t byt_off;

uint64_t buf_off;

uint64_t left;

uint64_t rlen;

int ret = 0;

/* check if entry is link to remote file */

if (SHFS_HENTRY_ISLINK(hentry))

return -EINVAL;

/* check boundaries */

if ((offset > hentry->f_attr.len) ||

((offset + len) > hentry->f_attr.len))

return -EINVAL;

/* pick chunk I/O buffer from pool */

chk_buf = target_malloc(shfs_vol.ioalign, shfs_vol.chunksize);

if (!chk_buf)

return -ENOMEM;

/* perform the I/O chunk-wise */

chk_off = shfs_volchk_foff(f, offset);

byt_off = shfs_volchkoff_foff(f, offset);

left = len;

buf_off = 0;

while (left) {

ret = shfs_read_chunk(chk_off, 1, chk_buf);

if (ret < 0)

goto out;

rlen = min(shfs_vol.chunksize - byt_off, left);

shfs_memcpy((uint8_t *) buf + buf_off,

(uint8_t *) chk_buf + byt_off,

rlen);

left -= rlen;

++chk_off; /* go to next chunk */

byt_off = 0; /* byte offset is set on the first chunk only */

buf_off += rlen;

}

out:

target_free(chk_buf);

return ret;

}

int shfs_fio_read_nosched(SHFS_FD f, uint64_t offset, void *buf, uint64_t len)

{

struct shfs_bentry *bentry = (struct shfs_bentry *) f;

struct shfs_hentry *hentry = bentry->hentry;

void *chk_buf;

chk_t chk_off;

uint64_t byt_off;

uint64_t buf_off;

uint64_t left;

uint64_t rlen;

int ret = 0;

/* check if entry is link to remote file */

if (SHFS_HENTRY_ISLINK(hentry))

return -EINVAL;

/* check boundaries */

if ((offset > hentry->f_attr.len) ||

((offset + len) > hentry->f_attr.len))

return -EINVAL;

/* pick chunk I/O buffer from pool */

chk_buf = target_malloc(shfs_vol.ioalign, shfs_vol.chunksize);

if (!chk_buf)

return -ENOMEM;

/* perform the I/O chunk-wise */

chk_off = shfs_volchk_foff(f, offset);

byt_off = shfs_volchkoff_foff(f, offset);

left = len;

buf_off = 0;

while (left) {

ret = shfs_read_chunk_nosched(chk_off, 1, chk_buf);

if (ret < 0)

goto out;

rlen = min(shfs_vol.chunksize - byt_off, left);

shfs_memcpy((uint8_t *) buf + buf_off,

(uint8_t *) chk_buf + byt_off,

rlen);

left -= rlen;

++chk_off; /* go to next chunk */

byt_off = 0; /* byte offset is set on the first chunk only */

buf_off += rlen;

}

out:

target_free(chk_buf);

return ret;

}

int shfs_fio_cache_read(SHFS_FD f, uint64_t offset, void *buf, uint64_t len)

{

struct shfs_bentry *bentry = (struct shfs_bentry *) f;

struct shfs_hentry *hentry = bentry->hentry;

struct shfs_cache_entry *cce;

chk_t chk_off;

uint64_t byt_off;

uint64_t buf_off;

uint64_t left;

uint64_t rlen;

int ret = 0;

/* check if entry is link to remote file */

if (SHFS_HENTRY_ISLINK(hentry))

return -EINVAL;

/* check boundaries */

if ((offset > hentry->f_attr.len) ||

((offset + len) > hentry->f_attr.len))

return -EINVAL;

/* perform the I/O chunk-wise */

chk_off = shfs_volchk_foff(f, offset);

byt_off = shfs_volchkoff_foff(f, offset);

left = len;

buf_off = 0;

while (left) {

cce = shfs_cache_read(chk_off);

if (!cce) {

ret = -errno;

goto out;

}

rlen = min(shfs_vol.chunksize - byt_off, left);

shfs_memcpy((uint8_t *) buf + buf_off,

(uint8_t *) cce->buffer + byt_off,

rlen);

left -= rlen;

shfs_cache_release(cce);

++chk_off; /* go to next chunk */

byt_off = 0; /* byte offset is set on the first chunk only */

buf_off += rlen;

}

out:

return ret;

}

int shfs_fio_cache_read_nosched(SHFS_FD f, uint64_t offset, void *buf, uint64_t len)

{

struct shfs_bentry *bentry = (struct shfs_bentry *) f;

struct shfs_hentry *hentry = bentry->hentry;

struct shfs_cache_entry *cce;

chk_t chk_off;

uint64_t byt_off;

uint64_t buf_off;

uint64_t left;

uint64_t rlen;

int ret = 0;

/* check if entry is link to remote file */

if (SHFS_HENTRY_ISLINK(hentry))

return -EINVAL;

/* check boundaries */

if ((offset > hentry->f_attr.len) ||

((offset + len) > hentry->f_attr.len))

return -EINVAL;

/* perform the I/O chunk-wise */

chk_off = shfs_volchk_foff(f, offset);

byt_off = shfs_volchkoff_foff(f, offset);

left = len;

buf_off = 0;

while (left) {

cce = shfs_cache_read_nosched(chk_off);

if (!cce) {

ret = -errno;

goto out;

}

rlen = min(shfs_vol.chunksize - byt_off, left);

shfs_memcpy((uint8_t *) buf + buf_off,

(uint8_t *) cce->buffer + byt_off,

rlen);

left -= rlen;

shfs_cache_release(cce);

++chk_off; /* go to next chunk */

byt_off = 0; /* byte offset is set on the first chunk only */

buf_off += rlen;

}

out:

return ret;

}