1 

     2 #include <stdlib.h>

     3 #include <assert.h>

     4 

     5 #include "trans.h"

     6 #include "../lib/log.h"

     7 

     8 void dbfs_trans_free (struct dbfs_trans *ctx) {

     9     assert(!ctx->req);

    10     assert(!ctx->trans);

    11     

    12     if (ctx->free_fn)

    13         ctx->free_fn(ctx);

    14 

    15     free(ctx);

    16 }

    17 

    18 void dbfs_trans_fail (struct dbfs_trans *ctx, int err) {

    19     if (ctx->req) {

    20         if ((err = fuse_reply_err(ctx->req, err)))

    21             EWARNING(err, "fuse_reply_err: request hangs");

    22 

    23         ctx->req = NULL;

    24     }

    25 

    26     if (ctx->trans) {

    27         evsql_trans_abort(ctx->trans);

    28 

    29         ctx->trans = NULL;

    30     }

    31 

    32     dbfs_trans_free(ctx);

    33 }

    34 

    35 static void dbfs_trans_error (struct evsql_trans *trans, void *arg) {

    36     struct dbfs_trans *ctx = arg;

    37 

    38     // deassociate trans

    39     ctx->trans = NULL;

    40 

    41     // log error

    42     INFO("\t[dbfs_trans.err %p:%p] %s", ctx, ctx->req, evsql_trans_error(trans));

    43 

    44     // mark

    45     if (ctx->err_ptr)

    46         *ctx->err_ptr = EIO;

    47     

    48     // fail

    49     dbfs_trans_fail(ctx, EIO);

    50 }

    51 

    52 static void dbfs_trans_ready (struct evsql_trans *trans, void *arg) {

    53     struct dbfs_trans *ctx = arg;

    54 

    55     // associate trans

    56     ctx->trans = trans;

    57 

    58     // log

    59     INFO("\t[dbfs_trans.ready %p:%p] -> trans=%p", ctx, ctx->req, trans);

    60 

    61     // trigger the callback

    62     ctx->begin_fn(ctx);

    63 }

    64 

    65 static void dbfs_trans_done (struct evsql_trans *trans, void *arg) {

    66     struct dbfs_trans *ctx = arg;

    67 

    68     // deassociate trans

    69     ctx->trans = NULL;

    70 

    71     // log

    72     INFO("\t[dbfs_trans.done %p:%p]", ctx, ctx->req);

    73 

    74     // trigger the callback

    75     ctx->commit_fn(ctx);

    76 }

    77 

    78 int dbfs_trans_init (struct dbfs_trans *ctx, struct fuse_req *req) {

    79     struct dbfs *dbfs_ctx = fuse_req_userdata(req);

    80     int err;

    81 

    82     // store

    83     ctx->req = req;

    84 

    85     // trans

    86     if ((ctx->trans = evsql_trans(dbfs_ctx->db, EVSQL_TRANS_SERIALIZABLE, dbfs_trans_error, dbfs_trans_ready, dbfs_trans_done, ctx)) == NULL)

    87         EERROR(err = EIO, "evsql_trans");

    88 

    89     // good

    90     return 0;

    91 

    92 error:

    93     return -1;

    94 }

    95 

    96 struct dbfs_trans *dbfs_trans_new (struct fuse_req *req) {

    97     struct dbfs_trans *ctx = NULL;

    98 

    99     // alloc

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

   101         ERROR("calloc");

   102 

   103     // init

   104     if (dbfs_trans_init(ctx, req))

   105         goto error;

   106 

   107     // good

   108     return ctx;

   109     

   110 error:

   111     free(ctx);

   112 

   113     return NULL;

   114 }

   115 

   116 void dbfs_trans_commit (struct dbfs_trans *ctx) {

   117     int err, trans_err = 0;

   118 

   119     // detect errors

   120     ctx->err_ptr = &trans_err;

   121     

   122     // attempt commit

   123     if (evsql_trans_commit(ctx->trans))

   124         SERROR(err = EIO);

   125     

   126     // drop err_ptr

   127     ctx->err_ptr = NULL;

   128 

   129     // ok, wait for done or error

   130     return;

   131 

   132 error:

   133     // fail if not already failed

   134     if (!trans_err)

   135         dbfs_trans_fail(ctx, err);

   136 }

   137 

   138