1

#include <stdlib.h>

     2

#include <sys/queue.h>

     3

#include <string.h>

     4

#include <assert.h>

     5

     6

#include "../cache.h"

     7

#include "cache.h"

     8

#include "op.h"

     9

#include "req.h"

    10

#include "engine.h"

    11

#include "../common.h"

    12

    13

void _cache_op_free (struct cache_op *op) {

    14

    // check we have no reqs listed

    15

    assert(op->req_list.lh_first == NULL);

    16

    17

    // remove it from the engine op_list

    18

    LIST_REMOVE(op, node);

    19

    20

    // tell the engine to close/free the op

    21

    if (op->cache->engine->fn_op_close(op))

    22

        WARNING("fn_op_close failed");

    23

}

    24

    25

int _cache_op_init (struct cache_op *op, struct cache *cache, struct cache_key *key) {

    26

    op->cache = cache;

    27

    op->key = key;

    28

    op->state = OP_STATE_INVALID;

    29

    30

    LIST_INIT(&op->req_list);

    31

    32

    // add this to the cache's list of ops

    33

    LIST_INSERT_HEAD(&cache->op_list, op, node);

    34

    35

    return 0;

    36

}

    37

    38

struct cache_op *cache_op_find (struct cache *cache, struct cache_key *key) {

    39

    struct cache_op *op;

    40

    41

    for (op = cache->op_list.lh_first; op != NULL; op = op->node.le_next) {

    42

        if (op->key->length == key->length && memcmp(op->key->buf, key->buf, key->length) == 0)

    43

            break;

    44

    }

    45

    46

    return op;

    47

}

    48

    49

int cache_op_register (struct cache_op *op, struct cache_req *req) {

    50

    LIST_INSERT_HEAD(&op->req_list, req, node);

    51

    52

    return 0;

    53

}

    54

    55

int cache_op_deregister (struct cache_op *op, struct cache_req *req) {

    56

    // XXX: check that the req is in our list of ops?

    57

    58

    LIST_REMOVE(req, node);

    59

    60

    if (op->req_list.lh_first == NULL) {

    61

        // the op is now unused

    62

        _cache_op_free(op);

    63

    }

    64

    65

    return 0;

    66

}

    67

    68

static int _cache_op_notify (struct cache_op *op) {

    69

    struct cache_req *req;

    70

    71

    for (req = op->req_list.lh_first; req != NULL; req = req->node.le_next) {

    72

        if (cache_req_notify(req))

    73

            goto error;

    74

    }

    75

    76

    return 0;

    77

    78

error:

    79

    return -1;

    80

}

    81

    82

int cache_op_available (struct cache_op *op, size_t *size, size_t *offset) {

    83

    return op->cache->engine->fn_op_available(op, size, offset);

    84

}

    85

    86

int cache_op_begin_read (struct cache_op *op) {

    87

    assert(op->state == OP_STATE_HIT);

    88

    89

    op->state = OP_STATE_OPEN_READ;

    90

    91

    return op->cache->engine->fn_op_begin_read(op);

    92

}

    93

    94

int cache_op_begin_write (struct cache_op *op, size_t size_hint) {

    95

    assert(op->state == OP_STATE_MISS);

    96

    97

    op->state = OP_STATE_OPEN_WRITE;

    98

    99

    return op->cache->engine->fn_op_begin_write(op, size_hint);

   100

}

   101

   102

int cache_op_push (struct cache_op *op, int fd, size_t *size) {

   103

    assert(op->state == OP_STATE_WRITE);

   104

   105

    return op->cache->engine->fn_op_push(op, fd, size);

   106

}

   107

   108

int cache_op_pull (struct cache_op *op, int fd, size_t *offset, size_t *size) {

   109

    assert(op->state == OP_STATE_READ || op->state == OP_STATE_WRITE);

   110

   111

    return op->cache->engine->fn_op_pull(op, fd, offset, size);

   112

}

   113

   114

int cache_op_done (struct cache_op *op) {

   115

    assert(op->state == OP_STATE_WRITE);

   116

   117

    return op->cache->engine->fn_op_done(op);

   118

}

   119

   120

int _cache_op_lookup_done (struct cache_op *op, int found) {

   121

    // modify state

   122

    op->state = found ? OP_STATE_HIT : OP_STATE_MISS;

   123

   124

    // notify waiting reqs

   125

    return _cache_op_notify(op);

   126

}

   127

   128

int _cache_op_read_ready (struct cache_op *op) {

   129

    // modify state

   130

    op->state = OP_STATE_READ;

   131

   132

    // notify waiting reqs

   133

    return _cache_op_notify(op);

   134

}

   135

   136

int _cache_op_write_ready (struct cache_op *op) {

   137

    // modify state

   138

    op->state = OP_STATE_WRITE;

   139

   140

    // notify waiting reqs

   141

    return _cache_op_notify(op);

   142

}

   143

   144

int _cache_op_data_available (struct cache_op *op) {

   145

    // notify waiting reqs

   146

    return _cache_op_notify(op);

   147

}

   148

   149

int _cache_op_write_done (struct cache_op *op) {

   150

    op->state = OP_STATE_READ;

   151

   152

    // notify waiting reqs

   153

    return _cache_op_notify(op);

   154

}

   155