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_write (struct cache_op *op, size_t size_hint) {

    87

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

    88

}

    89

    90

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

    91

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

    92

}

    93

    94

int cache_op_done (struct cache_op *op) {

    95

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

    96

}

    97

    98

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

    99

    // modify state

   100

    op->state = found ? OP_STATE_HIT : OP_STATE_MISS;

   101

   102

    // notify waiting reqs

   103

    return _cache_op_notify(op);

   104

}

   105

   106

int cache_op_write_ready (struct cache_op *op) {

   107

    // modify state

   108

    op->state = OP_STATE_WRITE;

   109

   110

    // notify waiting reqs

   111

    return _cache_op_notify(op);

   112

}

   113

   114

int cache_op_data_available (struct cache_op *op) {

   115

    // notify waiting reqs

   116

    return _cache_op_notify(op);

   117

}

   118

   119

int cache_op_write_done (struct cache_op *op) {

   120

    op->state = OP_STATE_READ;

   121

   122

    // notify waiting reqs

   123

    return _cache_op_notify(op);

   124

}

   125