1 #include <stdlib.h>

     2 #include <assert.h>

     3 

     4 #include "op_base.h"

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

     6 

     7 /*

     8  * Free the op.

     9  *

    10  * The op must any oustanding request responded to first, must not be open, and must not have a transaction.

    11  *

    12  * The op will be free'd.

    13  */

    14 static void dbfs_op_free (struct dbfs_op *op) {

    15     assert(op);

    16     assert(!op->open);

    17     assert(!op->req);

    18     assert(!op->trans);

    19 

    20     // free_fn

    21     if (op->free_fn)

    22         op->free_fn(op);

    23     

    24     // and then free the op

    25     free(op);

    26 }

    27 

    28 void dbfs_op_fail (struct dbfs_op *op, int err) {

    29     assert(op->req);

    30     

    31     if (op->trans) {

    32         // abort the trans

    33         evsql_trans_abort(op->trans);

    34         

    35         op->trans = NULL;

    36     }

    37 

    38     // send an error reply

    39     if ((err = fuse_reply_err(op->req, err)))

    40         // XXX: handle these failures /somehow/, or requests will hang and interrupts might handle invalid ops

    41         EFATAL(err, "\tdbfs_op.fail %p:%p -> reply with fuse_reply_err", op, op->req);

    42    

    43     // drop the req

    44     op->req = NULL;

    45 

    46     // is it open?

    47     if (!op->open) {

    48         // no, we can free it now and then forget about the whole thing

    49         dbfs_op_free(op);

    50 

    51     } else {

    52         // we need to wait for release

    53 

    54     }

    55 }

    56 

    57 /*

    58  * The op_open transaction is ready for use.

    59  */

    60 static void dbfs_op_ready (struct evsql_trans *trans, void *arg) {

    61     struct dbfs_op *op = arg;

    62     

    63     assert(trans == op->trans);

    64     assert(op->req);

    65     assert(!op->open);

    66 

    67     INFO("\tdbfs_op.ready %p:%p -> trans=%p", op, op->req, trans);

    68 

    69     // remember the transaction

    70     op->trans = trans;

    71 

    72     // ready

    73     op->open_fn(op);

    74     

    75     // good

    76     return;

    77 }

    78 

    79 /*

    80  * The op trans was committed, i.e. release has completed

    81  */

    82 static void dbfs_op_done (struct evsql_trans *trans, void *arg) {

    83     struct dbfs_op *op = arg;

    84     int err;

    85     

    86     assert(trans == op->trans);

    87     assert(op->req);

    88     assert(!op->open);   // should not be considered as open anymore at this point, as errors should release

    89 

    90     INFO("\tdbfs_op.done %p:%p -> OK", op, op->req);

    91 

    92     // forget trans

    93     op->trans = NULL;

    94     

    95     // just reply

    96     if ((err = fuse_reply_err(op->req, 0)))

    97         // XXX: handle these failures /somehow/, or requests will hang and interrupts might handle invalid ops

    98         EFATAL(err, "dbfs_op.done %p:%p -> reply with fuse_reply_err", op, op->req);

    99     

   100     // req is done

   101     op->req = NULL;

   102 

   103     // then we can just free op

   104     dbfs_op_free(op);

   105 }

   106 

   107 /*

   108  * The op trans has failed, somehow, at some point, some where.

   109  *

   110  * This might happend during the open evsql_trans, during a read evsql_query, during the release

   111  * evsql_trans_commit, or at any point in between.

   112  *

   113  * 1) loose the transaction

   114  * 2) if op has a req, we handle failing it

   115  */

   116 static void dbfs_op_error (struct evsql_trans *trans, void *arg) {

   117     struct dbfs_op *op = arg;

   118     

   119     // unless we fail 

   120     assert(trans == op->trans);

   121 

   122     INFO("\tdbfs_op.error %p:%p -> evsql transaction error: %s", op, op->req, evsql_trans_error(trans));

   123     

   124     // deassociate the trans

   125     op->trans = NULL;

   126     

   127     // if we were answering a req, error it out, and if the op isn't open, free

   128     // if we didn't have a req outstanding, the op must be open, so we wouldn't free it in any case, and must wait

   129     // for the next read/release to detect this and return an error reply

   130     if (op->req)

   131         dbfs_op_fail(op, EIO);

   132     else

   133         assert(op->open);

   134 }

   135 

   136 int dbfs_op_open (struct dbfs *ctx, struct dbfs_op *op, struct fuse_req *req, fuse_ino_t ino, struct fuse_file_info *fi, dbfs_op_free_cb free_fn, dbfs_op_open_cb open_fn) {

   137     int err;

   138 

   139     assert(op && req && ino && fi);

   140     assert(!(op->req || op->ino));

   141 

   142     // initialize the op

   143     op->req = req;

   144     op->ino = ino;

   145     // copy *fi since it's on the stack

   146     op->fi = *fi;

   147     op->fi.fh = (uint64_t) op;

   148     op->free_fn = free_fn;

   149     op->open_fn = open_fn;

   150 

   151     // start a new transaction

   152     if ((op->trans = evsql_trans(ctx->db, EVSQL_TRANS_SERIALIZABLE, dbfs_op_error, dbfs_op_ready, dbfs_op_done, op)) == NULL)

   153         SERROR(err = EIO);

   154     

   155     // XXX: handle interrupts

   156     

   157     // good

   158     return 0;

   159 

   160 error:

   161     // nothing of ours to cleanup

   162     return err;

   163 }

   164 

   165 int dbfs_op_open_reply (struct dbfs_op *op) {

   166     int err;

   167     

   168     // detect earlier failures

   169     if (!op->trans && (err = EIO))

   170         ERROR("op trans has failed");

   171 

   172     // send the openddir reply

   173     if ((err = fuse_reply_open(op->req, &op->fi)))

   174         EERROR(err, "fuse_reply_open");

   175     

   176     // req is done

   177     op->req = NULL;

   178 

   179     // op is now open

   180     op->open = 1;

   181  

   182     // good

   183     return 0;

   184 

   185 error:

   186     return err;

   187 }

   188 

   189 struct dbfs_op *dbfs_op_req (struct fuse_req *req, fuse_ino_t ino, struct fuse_file_info *fi) {

   190     struct dbfs_op *op = (struct dbfs_op *) fi->fh;

   191     int err;

   192     

   193     // validate

   194     assert(op);

   195     assert(!op->req);

   196     assert(op->open);

   197     assert(op->ino == ino);

   198 

   199     // store the new req

   200     op->req = req;

   201     

   202     // detect earlier failures

   203     if (!op->trans && (err = EIO))

   204         ERROR("op trans has failed");

   205 

   206     // good

   207     return op;

   208 

   209 error:

   210     dbfs_op_fail(op, err);

   211     

   212     return NULL;

   213 }

   214 

   215 int dbfs_op_req_done (struct dbfs_op *op) {

   216     // validate

   217     assert(op);

   218     assert(op->req);

   219     assert(op->open);

   220 

   221     // unassign the req

   222     op->req = NULL;

   223 

   224     // k

   225     return 0;

   226 }

   227 

   228 void dbfs_op_release (struct fuse_req *req, fuse_ino_t ino, struct fuse_file_info *fi) {

   229     struct dbfs_op *op = (struct dbfs_op *) fi->fh;

   230     int err;

   231     

   232     assert(op);

   233     assert(!op->req);

   234     assert(op->ino == ino);

   235     

   236     // update to this req

   237     op->req = req;

   238 

   239     // fi is irrelevant, we don't touch the flags anyways

   240     (void) fi;

   241 

   242     // handle failed trans

   243     if (!op->trans && (err = EIO))

   244         ERROR("trans has failed");

   245     

   246     // log

   247     INFO("\tdbfs_op.release %p:%p : ino=%lu, fi=%p : trans=%p", op, req, ino, fi, op->trans);

   248     

   249     // we must commit the transaction.

   250     // Note that this might cause dbfs_op_error to be called, we can tell if that happaned by looking at op->req

   251     // or op->trans - this means that we need to keep the op open when calling trans_commit, so that op_error

   252     // doesn't free it out from underneath us.

   253     if (evsql_trans_commit(op->trans))

   254         SERROR(err = EIO);

   255 

   256     // fall-through to cleanup

   257     err = 0;

   258 

   259 error:

   260     // the op is not open anymore and can be free'd next, because we either:

   261     // a) already caught an error

   262     // b) we get+send an error later on

   263     // c) we get+send the done/no-error later on

   264     op->open = 0;

   265 

   266     // did the commit/pre-commit-checks fail?

   267     if (err) {

   268         // a) the trans failed earlier (read), so we have a req but no trans

   269         // b) the trans commit failed, op_error got called -> no req and no trans

   270         // c) the trans commit failed, op_error did not get called -> have req and trans

   271         // we either have a req (may or may not have trans), or we don't have a trans either

   272         // i.e. there is no situation where we don't have a req but do have a trans

   273 

   274         if (op->req)

   275             dbfs_op_fail(op, err);

   276         else

   277             assert(!op->trans);

   278 

   279     } else {

   280         // shouldn't slip by, op_done should not get called directly. Once it does, it will handle both.

   281         assert(op->req);

   282         assert(op->trans);

   283     }

   284 }

   285