1

#define _GNU_SOURCE

     2

#include <sys/types.h>

     3

#include <unistd.h>

     4

#include <sys/mman.h>

     5

#include <sys/stat.h>

     6

#include <stdlib.h>

     7

#include <sys/param.h>

     8

#include <stdio.h>

     9

#include <fcntl.h>

    10

#include <errno.h>

    11

#include <assert.h>

    12

    13

#include "../../cache.h"

    14

#include "../cache.h"

    15

#include "../engine.h"

    16

#include "../op.h"

    17

#include "../../common.h"

    18

    19

#define FS_PAGE_SIZE (4096)

    20

#define FS_INITIAL_SIZE (1 * FS_PAGE_SIZE)

    21

#define FS_PAGE_GROW_FACTOR (2)

    22

    23

struct cache_engine_fs {

    24

    struct cache_engine base;

    25

    26

    // custom stuff

    27

    const char *cache_dir;

    28

};

    29

    30

struct cache_fs {

    31

    struct cache base;

    32

    33

    // custom stuff?

    34

};

    35

    36

struct cache_op_fs {

    37

    struct cache_op base;

    38

    39

    // custom

    40

    int fd;

    41

    42

    /*

    43

     * Either contains the final size of the cache entry, or zero.

    44

     */

    45

    off_t size;

    46

    47

    /*

    48

     * Contains the size of the currently mmap'd region

    49

     */

    50

    off_t mmap_size;

    51

    52

    void *mmap;

    53

    54

    off_t write_offset;

    55

};

    56

    57

/*

    58

 * if new_size is equal to op->mmap_size, nothing will be changed

    59

 */

    60

static int _fs_mmap (struct cache_op_fs *op, size_t new_size) {

    61

    off_t old_size = op->mmap_size;

    62

    63

    assert(new_size > 0);

    64

    65

    if (new_size != old_size) {

    66

        // calc new size

    67

        op->mmap_size = new_size;

    68

    69

        // and ftruncate

    70

        if (ftruncate(op->fd, op->mmap_size))

    71

            PERROR("ftruncate");

    72

    }

    73

    74

    if (op->mmap) {

    75

        assert(old_size > 0);

    76

    77

        // XXX: test

    78

        if ((op->mmap = mremap(op->mmap, old_size, op->mmap_size, MREMAP_MAYMOVE)) == MAP_FAILED)

    79

            PERROR("mremap");

    80

    81

    } else {

    82

        if ((op->mmap = mmap(NULL, op->mmap_size, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_POPULATE, op->fd, 0)) == MAP_FAILED)

    83

            PERROR("mmap");

    84

    85

    }

    86

    87

    return 0;

    88

    89

error:

    90

    return -1;

    91

}

    92

    93

/*

    94

 * reuturn a pointer to a static buf containing the path to the key in the given op

    95

 */

    96

static const char *_fs_path (struct cache_engine_fs *engine, struct cache_op_fs *op) {

    97

    static char path[PATH_MAX];

    98

    99

    struct cache_key *key = op->base.key;

   100

   101

    // construct the path to the appropriate file

   102

    if (snprintf(path, PATH_MAX, "%s/%*s", engine->cache_dir, (int) key->length - 1, key->buf) >= PATH_MAX)

   103

        ERROR("path too long: %s/%*s", engine->cache_dir, (int) key->length - 1, key->buf);

   104

   105

    return path;

   106

   107

error:

   108

    return NULL;

   109

}

   110

   111

/*

   112

 * Grow the file if needed so that it fits the given amount of bytes

   113

 */

   114

static int _fs_grow (struct cache_op_fs *op, size_t new_size_hint) {

   115

    if (op->mmap_size >= new_size_hint)

   116

        return 0;

   117

   118

    // XXX: need some math.ceil

   119

    size_t new_size = ((op->mmap_size / FS_PAGE_SIZE) + 1) * FS_PAGE_SIZE;

   120

   121

    while (new_size < new_size_hint) {

   122

        new_size *= FS_PAGE_GROW_FACTOR;

   123

    }

   124

   125

    return _fs_mmap(op, new_size);

   126

}

   127

   128

static int _fs_do_init (struct cache_engine *engine, struct cache **cache_ptr) {

   129

    struct cache_engine_fs *ctx = (struct cache_engine_fs *) engine;

   130

    struct cache_fs *cache = NULL;

   131

   132

   133

    if ((cache = calloc(1, sizeof(*cache))) == NULL)

   134

        ERROR("calloc");

   135

   136

    if (cache_init(&cache->base, &ctx->base))

   137

        goto error;

   138

   139

    *cache_ptr = &cache->base;

   140

   141

    return 0;

   142

   143

error:

   144

    free(cache);

   145

   146

    return -1;

   147

}

   148

   149

static int _fs_do_op_start (struct cache *cache, struct cache_op **op_ptr, struct cache_key *key) {

   150

    struct cache_engine_fs *engine = (struct cache_engine_fs *) cache->engine;

   151

    struct cache_op_fs *op = NULL;

   152

    struct stat stat_info;

   153

    int found = 0;

   154

    const char *path;

   155

   156

    // allocate it

   157

    if ((op = calloc(1, sizeof(*op))) == NULL)

   158

        ERROR("calloc");

   159

   160

    // init it

   161

    if (cache_op_init(&op->base, cache, key))

   162

        goto error;

   163

   164

    // mark it as being in the lookup state...

   165

    op->base.state = OP_STATE_LOOKUP;

   166

   167

    // fetch the path

   168

    if ((path = _fs_path(engine, op)) == NULL)

   169

        goto error;

   170

   171

    // stat

   172

    if (stat(path, &stat_info)) {

   173

        if (errno == ENOENT) {

   174

            found = 0;

   175

            // op->size remains 0

   176

        } else

   177

            PERROR("stat: %s", path);

   178

    } else {

   179

        found = 1;

   180

        op->size = stat_info.st_size;

   181

    }

   182

   183

    // indicate that the key was found/not found

   184

    if (cache_op_lookup_done(&op->base, found))

   185

        goto error;

   186

   187

    *op_ptr = &op->base;

   188

   189

    // done!

   190

    return 0;

   191

   192

error:

   193

    free(op);

   194

   195

    return -1;

   196

   197

}

   198

   199

int _fs_do_op_available (struct cache_op *op_base, size_t *size, size_t *offset) {

   200

    struct cache_op_fs *op = (struct cache_op_fs *) op_base;

   201

   202

    // this is easy, it's only known if a HIT, or after op_done, so it's the same as...

   203

    *size = op->size;

   204

   205

    // op->size if nonzero, write_offset otherwise

   206

    *offset = op->size ? op->size : op->write_offset;

   207

   208

    return 0;

   209

}

   210

   211

int _fs_do_op_begin_write (struct cache_op *op_base, size_t size_hint) {

   212

    struct cache_op_fs *op = (struct cache_op_fs *) op_base;

   213

    struct cache_engine_fs *engine = (struct cache_engine_fs *) op->base.cache->engine;

   214

   215

    const char *path;

   216

   217

    assert(size_hint >= 0);

   218

   219

    // should be unknown (0) for HITs that we then write to

   220

    assert(op->size == 0);

   221

   222

    // fetch the path

   223

    if ((path = _fs_path(engine, op)) == NULL)

   224

        goto error;

   225

   226

    // create the appropriate file for read-write, exclusively

   227

    if ((op->fd = open(path, O_CREAT | O_RDWR | O_EXCL, 0644)) == -1)

   228

        PERROR("open: %s", path);

   229

   230

    // ftruncate, and then mmap

   231

    if (_fs_mmap(op, size_hint ? size_hint : FS_INITIAL_SIZE))

   232

        goto error;

   233

   234

    // great

   235

    if (cache_op_write_ready(&op->base))

   236

        goto error;

   237

   238

    // done

   239

    return 0;

   240

   241

error:

   242

    return -1;

   243

}

   244

   245

int _fs_do_op_push (struct cache_op *op_base, int fd, size_t *size_ptr) {

   246

    struct cache_op_fs *op = (struct cache_op_fs *) op_base;

   247

    struct cache_engine_fs *engine = (struct cache_engine_fs *) op->base.cache->engine;

   248

   249

    size_t ret, size;

   250

   251

    assert(op->fd > 0);

   252

   253

    // must have called begin_write first...

   254

    assert(op->mmap_size > 0);

   255

    assert(op->mmap != NULL);

   256

    assert(op->write_offset <= op->mmap_size);

   257

   258

    // default size if none specified

   259

    if (*size_ptr == 0)

   260

        size = FS_INITIAL_SIZE;

   261

    else

   262

        size = *size_ptr;

   263

   264

    // grow the file if needed

   265

    if (_fs_grow(op, op->write_offset + size))

   266

        goto error;

   267

   268

    // read the data into the mmap'd region

   269

    if ((ret = read(fd, op->mmap + op->write_offset, size)) == -1)

   270

        // XXX: EAGAIN

   271

        PERROR("read");

   272

   273

    // move the write offset along

   274

    op->write_offset += ret;

   275

   276

    // return something

   277

    *size_ptr = ret;

   278

   279

    // notify newly available data

   280

    if (cache_op_data_available(&op->base))

   281

        goto error;

   282

   283

    // great

   284

    return 0;

   285

   286

error:

   287

    return -1;

   288

}

   289

   290

int _fs_do_op_done (struct cache_op *op_base) {

   291

    struct cache_op_fs *op = (struct cache_op_fs *) op_base;

   292

    struct cache_engine_fs *engine = (struct cache_engine_fs *) op->base.cache->engine;

   293

   294

    assert(op->fd > 0);

   295

    assert(op->mmap != NULL);

   296

    assert(op->write_offset <= op->mmap_size);

   297

   298

    // empty cache entries are illegal

   299

    assert(op->write_offset > 0);

   300

   301

    // final size is now known

   302

    op->size = op->write_offset;

   303

   304

    // truncate to match data length

   305

    if (_fs_mmap(op, op->size))

   306

        goto error;

   307

   308

    // notify that data is complete

   309

    if (cache_op_write_done(&op->base))

   310

        goto error;

   311

   312

    // great

   313

    return 0;

   314

   315

error:

   316

    return -1;

   317

   318

}

   319

   320

int _fs_do_op_close (struct cache_op *op_base) {

   321

    struct cache_op_fs *op = (struct cache_op_fs *) op_base;

   322

   323

    // unmap

   324

    if (op->mmap)

   325

        if (munmap(op->mmap, op->mmap_size))

   326

            PWARNING("munmap");

   327

   328

    // close

   329

    if (op->fd > 0)

   330

        if (close(op->fd))

   331

            PWARNING("close");

   332

   333

    // XXX: delete if op->write_offset == 0?

   334

   335

    // free

   336

    free(op);

   337

   338

    return 0;

   339

}

   340

struct cache_engine *cache_engine_fs (const char *cache_dir) {

   341

    struct cache_engine_fs *ctx = NULL;

   342

   343

    if ((ctx = calloc(1, sizeof(*ctx))) == NULL)

   344

        ERROR("calloc");

   345

   346

    ctx->cache_dir = cache_dir;

   347

   348

    // set up the fn table

   349

    ctx->base.fn_init = &_fs_do_init;

   350

    ctx->base.fn_op_start = &_fs_do_op_start;

   351

    ctx->base.fn_op_available = &_fs_do_op_available;

   352

    ctx->base.fn_op_begin_write = &_fs_do_op_begin_write;

   353

    ctx->base.fn_op_push = &_fs_do_op_push;

   354

    ctx->base.fn_op_done = &_fs_do_op_done;

   355

    ctx->base.fn_op_close = &_fs_do_op_close;

   356

   357

    return &ctx->base;

   358

   359

error:

   360

    free(ctx);

   361

   362

    return NULL;

   363

}

   364