1

     2

#include "dbfs.h"

     3

     4

void _dbfs_interrupt_reply (evutil_socket_t _unused1, short _unused2, void *req_ptr) {

     5

    struct fuse_req *req = req_ptr;

     6

    err_t err;

     7

     8

    // error the req

     9

    if ((err = -fuse_reply_err(req, EINTR)))

    10

        EWARNING(err, "fuse_reply_err");

    11

}

    12

    13

void dbfs_interrupt_query (struct fuse_req *req, void *query_ptr) {

    14

    struct dbfs *ctx = fuse_req_userdata(req);

    15

    struct evsql_query *query = query_ptr;

    16

    struct timeval tv;

    17

    err_t err;

    18

    19

    // abort query

    20

    evsql_query_abort(NULL, query);

    21

    22

    // error the req

    23

    if ((err = -fuse_reply_err(req, EINTR)))

    24

        EWARNING(err, "fuse_reply_err");

    25

    26

    /*

    27

     * Due to a locking bug in libfuse (at least 2.7.4), we can't call fuse_reply_err from the interrupt function, so we must

    28

     * schedule after this function returns.

    29

     * /

    30

    tv.tv_sec = 0;

    31

    tv.tv_usec = 0;

    32

    if (event_base_once(ctx->ev_base, -1, EV_TIMEOUT, _dbfs_interrupt_reply, req, &tv))

    33

        PWARNING("event_base_once failed, dropping req reply: %p", req);

    34

        */

    35

}

    36

    37

void _dbfs_interrupt_ctx (struct fuse_req *req, void *ctx_ptr) {

    38

    // dereference ctx

    39

    struct dbfs_interrupt_ctx *ctx = ctx_ptr;

    40

    41

    // just cancel query if pending

    42

    if (ctx->query) {

    43

        evsql_query_abort(NULL, ctx->query);

    44

        ctx->query = NULL;

    45

    }

    46

    47

    // mark as interrupted

    48

    ctx->interrupted = 1;

    49

}

    50

    51

int dbfs_interrupt_register (struct fuse_req *req, struct dbfs_interrupt_ctx *ctx) {

    52

    // initialize

    53

    ctx->query = NULL;

    54

    ctx->interrupted = 0;

    55

    56

    // just pass over to fuse_req_interrupt_func

    57

    fuse_req_interrupt_func(req, _dbfs_interrupt_ctx, ctx);

    58

}