1 #ifndef DBFS_OP_BASE_H

     2 #define DBFS_OP_BASE_H

     3 

     4 #include "dbfs.h"

     5 

     6 // forward-declaration for callbacks

     7 struct dbfs_op;

     8 

     9 /*

    10  * Called by dbfs_op_free to release any resources when the op is free'd (i.e. not open anymore).

    11  */

    12 typedef void (*dbfs_op_free_cb) (struct dbfs_op *op_base);

    13 

    14 /*

    15  * Called after the transaction has been opened, and before reply_open.

    16  *

    17  * You can do any at-open initialization here.

    18  */

    19 typedef void (*dbfs_op_open_cb) (struct dbfs_op *op_base);

    20 

    21 // the base op state

    22 struct dbfs_op {

    23     struct fuse_file_info fi;

    24     struct fuse_req *req;

    25 

    26     struct evsql_trans *trans;

    27     

    28     // op target inode

    29     uint32_t ino;

    30     

    31     // open has returned and release hasn't been called yet

    32     int open;

    33 

    34     // callbacks

    35     dbfs_op_free_cb free_fn;

    36     dbfs_op_open_cb open_fn;

    37 };

    38 

    39 /*

    40  * This will handle failures during requests.

    41  *

    42  * 1) if we have a trans, abort it

    43  * 2) fail the req (mandatory) with the given err

    44  *

    45  * If the op is open, then we don't release it, but if it's not open, then the op will be free'd completely.

    46  *

    47  */

    48 void dbfs_op_fail (struct dbfs_op *op, int err);

    49 

    50 /*

    51  * Open the op, that is, store all the initial state, and open a new transaction.

    52  *

    53  * The op must be pre-allocated and zero-initialized.

    54  *

    55  * This will always set op->req, so op is safe for dbfs_op_fail after this.

    56  *

    57  * This does not fail the dirop, handle error replies yourself.

    58  *

    59  * Returns zero on success, err on failure.

    60  */

    61 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 ready_fn);

    62 

    63 /*

    64  * Should be called from open_fn to send the fuse_reply_open with fi and mark the op as open.

    65  *

    66  * If the op has failed earlier or fuse_reply_open fails, this will return nonzero. Fail the op yourself.

    67  */ 

    68 int dbfs_op_open_reply (struct dbfs_op *op);

    69 

    70 /*

    71  * Start handling a normal op requests.

    72  *

    73  * Lookup the op for the given fi, validate params, and assign the new req.

    74  *

    75  * In case the op failed previously, this will error the req and return NULL, indicating that the req has been handled.

    76  */

    77 struct dbfs_op *dbfs_op_req (struct fuse_req *req, fuse_ino_t ino, struct fuse_file_info *fi);

    78 

    79 /*

    80  * Done handling a request, adjust state accordingly.

    81  *

    82  * req *must* have been replied to.

    83  */

    84 int dbfs_op_req_done (struct dbfs_op *op);

    85 

    86 /*

    87  * Handle the op release.

    88  *

    89  * This will take care of committing the transaction, sending any reply/error, closing the op and freeing it.

    90  */

    91 void dbfs_op_release (struct fuse_req *req, fuse_ino_t, struct fuse_file_info *fi);

    92 

    93 

    94 #endif /* DBFS_OP_BASE_H */