1

#include <stdlib.h>

     2

#include <string.h>

     3

#include <assert.h>

     4

     5

#include "../cache.h"

     6

#include "cache.h"

     7

#include "req.h"

     8

#include "op.h"

     9

#include "engine.h"

    10

#include "../common.h"

    11

    12

void _cache_req_free (struct cache_req *req) {

    13

    assert(req->op == NULL);

    14

    15

    free(req->key_copy.buf);

    16

    free(req);

    17

}

    18

    19

struct cache_req *cache_req (struct cache *cache, const struct cache_key *key, cache_callback cb_func, void *cb_data) {

    20

    struct cache_req *req = NULL;

    21

    22

    // calloc the req info

    23

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

    24

        ERROR("calloc");

    25

    26

    // set up basic state

    27

    req->cb_func = cb_func;

    28

    req->cb_data = cb_data;

    29

    req->is_write = 0;

    30

    31

    // copy the key

    32

    if (key->length == 0)

    33

        req->key_copy.length = strlen(key->buf) + 1;

    34

    else

    35

        req->key_copy.length = key->length;

    36

    37

    if (req->key_copy.length == 0)

    38

        ERROR("zero-length key");

    39

    40

    if ((req->key_copy.buf = malloc(req->key_copy.length)) == NULL)

    41

        ERROR("malloc");

    42

    43

    memcpy(req->key_copy.buf, key->buf, req->key_copy.length);

    44

    45

    req->key = &req->key_copy;

    46

    47

    // look for an existing cache_op for this key

    48

    if ((req->op = cache_op_find(cache, req->key)) == NULL) {

    49

    50

        // none available, start a new cache op

    51

        if (cache->engine->fn_op_start(cache, &req->op, req->key))

    52

            goto error;

    53

    54

        // since we were the one that created it, we take care of writing it if needed

    55

        req->is_write = 1;

    56

    57

    } else {

    58

        // we found an existing cache_op, we can just use that

    59

    60

    }

    61

    62

    // engine may forget to update the op_ptr

    63

    assert(req->op);

    64

    65

    // register

    66

    if (cache_op_register(req->op, req))

    67

        goto error;

    68

    69

    // hurray, we now have an active cache_op \o/

    70

    return req;

    71

    72

error:

    73

    // we are not associated with any op

    74

    req->op = NULL;

    75

    76

    _cache_req_free(req);

    77

    78

    return NULL;

    79

}

    80

    81

/*int _cache_req_notify (struct cache_req *req, enum cache_req_event event) { */

    82

int _cache_req_notify (struct cache_req *req) {

    83

    if (req->cb_func(req, req->cb_data)) {

    84

        // XXX: handle errors

    85

        assert(0);

    86

    }

    87

    88

    return 0;

    89

}

    90

    91

int cache_req_notify (struct cache_req *req) {

    92

/*

    93

    switch (req->op->state) {

    94

        case OP_STATE_INVALID:

    95

        case OP_STATE_LOOKUP:

    96

            assert(0);

    97

    98

            break;

    99

   100

        case OP_STATE_HIT:

   101

            if (_cache_req_notify(req, CACHE_EVENT_HIT))

   102

                goto error;

   103

   104

            break;

   105

   106

        case OP_STATE_MISS:

   107

            if (_cache_req_notify(req, CACHE_EVENT_MISS))

   108

                goto error;

   109

   110

            break;

   111

   112

        case OP_STATE_WRITE:

   113

            if (_cache_req_notify(req, req->is_write ? CACHE_EVENT_BEGIN_WRITE : CACHE_EVENT_BEGIN_READ))

   114

                goto error;

   115

   116

            break;

   117

   118

        default:

   119

            assert(0);

   120

   121

            break;

   122

    }

   123

   124

    return 0;

   125

   126

error:

   127

    return -1;

   128

*/

   129

   130

    return _cache_req_notify(req);

   131

}

   132

   133

enum cache_req_state cache_req_state (struct cache_req *req) {

   134

     switch (req->op->state) {

   135

        case OP_STATE_INVALID:

   136

            return CACHE_STATE_INVALID;

   137

   138

        case OP_STATE_LOOKUP:

   139

            return CACHE_STATE_LOOKUP;

   140

   141

        case OP_STATE_HIT:

   142

            return CACHE_STATE_HIT;

   143

   144

        case OP_STATE_MISS:

   145

            return req->is_write ? CACHE_STATE_MISS : CACHE_STATE_OPEN_READ;

   146

   147

        case OP_STATE_OPEN_READ:

   148

            return CACHE_STATE_OPEN_READ;

   149

   150

        case OP_STATE_OPEN_WRITE:

   151

            return req->is_write ? CACHE_STATE_OPEN_WRITE : CACHE_STATE_READ;

   152

   153

        case OP_STATE_READ:

   154

            return CACHE_STATE_READ;

   155

   156

        case OP_STATE_WRITE:

   157

            return req->is_write ? CACHE_STATE_WRITE : CACHE_STATE_READ;

   158

   159

        case OP_STATE_ERROR:

   160

            // XXX: error handling

   161

            assert(0);

   162

   163

        default:

   164

            assert(0);

   165

    }

   166

}

   167

   168

const struct cache_key *cache_req_key (struct cache_req *req) {

   169

    return req->key;

   170

}

   171

   172

int cache_req_available (struct cache_req *req, size_t *size, size_t *offset, size_t *available) {

   173

    if (req->op->state == OP_STATE_INVALID || req->op->state == OP_STATE_LOOKUP || req->op->state == OP_STATE_ERROR)

   174

        ERROR("req is not readable");

   175

   176

    if (cache_op_available(req->op, size, offset))

   177

        goto error;

   178

   179

    // this is based on our own read offset

   180

    *available = (*offset - req->read_offset);

   181

   182

    return 0;

   183

   184

error:

   185

    return -1;

   186

}

   187

   188

int cache_req_begin_write(struct cache_req *req, size_t hint) {

   189

    if (req->op->state != OP_STATE_MISS || !req->is_write)

   190

        ERROR("req not in pre-write mode");

   191

   192

    return cache_op_begin_write(req->op, hint);

   193

   194

error:

   195

    return -1;

   196

}

   197

   198

int cache_req_begin_read (struct cache_req *req) {

   199

    if (req->op->state == OP_STATE_HIT) {

   200

        // needs to be done

   201

        return cache_op_begin_read(req->op);

   202

   203

    } else if (req->op->state == OP_STATE_OPEN_READ || req->op->state == OP_STATE_READ) {

   204

        WARNING("req is already in OP_STATE_READ/OP_STATE_OPEN_READ");

   205

   206

    } else if (req->op->state == OP_STATE_OPEN_WRITE || req->op->state == OP_STATE_WRITE) {

   207

        WARNING("req is already in OP_STATE_WRITE/OP_STATE_OPEN_WRITE");

   208

   209

    } else {

   210

        ERROR("req is not readable");

   211

    }

   212

   213

    return 0;

   214

   215

error:

   216

    return -1;

   217

}

   218

   219

int cache_req_push (struct cache_req *req, int fd, size_t *size) {

   220

    if (req->op->state != OP_STATE_WRITE || !req->is_write)

   221

        ERROR("req not in write mode");

   222

   223

    return cache_op_push(req->op, fd, size); 

   224

   225

error:

   226

    return -1;

   227

}

   228

   229

int cache_req_pull (struct cache_req *req, int fd, size_t *size) {

   230

    if (req->op->state != OP_STATE_READ && req->op->state != OP_STATE_WRITE)

   231

        ERROR("req is not readable");

   232

   233

    return cache_op_pull(req->op, fd, &req->read_offset, size);

   234

   235

error:

   236

    return -1;

   237

}

   238

   239

int cache_req_done (struct cache_req *req) {

   240

    if (req->op->state != OP_STATE_WRITE || !req->is_write)

   241

        ERROR("req not in write mode");

   242

   243

    return cache_op_done(req->op); 

   244

   245

error:

   246

    return -1;

   247

}

   248

   249

void cache_req_release (struct cache_req *req) {

   250

    // unconditional deregister

   251

    cache_op_deregister(req->op, req);

   252

   253

    // we are not associated with any op anymore

   254

    req->op = NULL;

   255

   256

    // free

   257

    _cache_req_free(req);

   258

}

   259