1

     2

#include <stdlib.h>

     3

#include <assert.h>

     4

     5

#include "common.h"

     6

#include "ops.h"

     7

#include "../dirbuf.h"

     8

     9

/*

    10

 * Directory related functionality like opendir, readdir, releasedir

    11

 */

    12

    13

struct dbfs_dirop {

    14

    struct fuse_file_info fi;

    15

    struct fuse_req *req;

    16

    17

    struct evsql_trans *trans;

    18

    19

    // dir/parent dir inodes

    20

    uint32_t ino, parent;

    21

    22

    // opendir has returned and releasedir hasn't been called yet

    23

    int open;

    24

    25

    // for readdir

    26

    struct dirbuf dirbuf;

    27

};

    28

    29

/*

    30

 * Free the dirop, aborting any in-progress transaction.

    31

 *

    32

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

    33

 *

    34

 * The dirbuf will be released, and the dirop free'd.

    35

 */

    36

static void _dbfs_dirop_free (struct dbfs_dirop *dirop) {

    37

    assert(dirop);

    38

    assert(!dirop->open);

    39

    assert(!dirop->req);

    40

    assert(!dirop->trans);

    41

    42

    // just release the dirbuf

    43

    dirbuf_release(&dirop->dirbuf);

    44

    45

    // and then free the dirop

    46

    free(dirop);

    47

}

    48

    49

/*

    50

 * This will handle backend failures during requests.

    51

 *

    52

 * 1) if we have a trans, abort it

    53

 * 2) fail the req (mandatory)

    54

 *

    55

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

    56

 *

    57

 */

    58

static void _dbfs_dirop_fail (struct dbfs_dirop *dirop) {

    59

    int err;

    60

    61

    assert(dirop->req);

    62

    63

    if (dirop->trans) {

    64

        // abort the trans

    65

        evsql_trans_abort(dirop->trans);

    66

    67

        dirop->trans = NULL;

    68

    }

    69

    70

    // send an error reply

    71

    if ((err = fuse_reply_err(dirop->req, err)))

    72

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

    73

        EFATAL(err, "dbfs.fail %p:%p dirop_fail: reply with fuse_reply_err", dirop, dirop->req);

    74

    75

    // drop the req

    76

    dirop->req = NULL;

    77

    78

    // is it open?

    79

    if (!dirop->open) {

    80

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

    81

        _dbfs_dirop_free(dirop);

    82

    83

    } else {

    84

        // we need to wait for releasedir

    85

    86

    }

    87

}

    88

    89

/*

    90

 * Handle the results for the initial attribute lookup for the dir itself during opendir ops.

    91

 */

    92

static void dbfs_opendir_info_res (const struct evsql_result_info *res, void *arg) {

    93

    struct dbfs_dirop *dirop = arg;

    94

    int err;

    95

    96

    assert(dirop->trans);

    97

    assert(dirop->req);

    98

    assert(!dirop->open);

    99

   100

    // check the results

   101

    if ((err = _dbfs_check_res(res, 1, 2)))

   102

        SERROR(err = (err ==  1 ? ENOENT : EIO));

   103

   104

    const char *type;

   105

   106

    // extract the data

   107

    if (0

   108

        ||  evsql_result_uint32(res, 0, 0, &dirop->parent,  1 ) // file_tree.parent

   109

        ||  evsql_result_string(res, 0, 1, &type,           0 ) // inodes.type

   110

    )

   111

        SERROR(err = EIO);

   112

   113

    // is it a dir?

   114

    if (_dbfs_mode(type) != S_IFDIR)

   115

        EERROR(err = ENOTDIR, "wrong type: %s", type);

   116

   117

    INFO("[dbfs.opendir %p:%p] -> ino=%lu, parent=%lu, type=%s", dirop, dirop->req, (unsigned long int) dirop->ino, (unsigned long int) dirop->parent, type);

   118

   119

    // send the openddir reply

   120

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

   121

        EERROR(err, "fuse_reply_open");

   122

   123

    // req is done

   124

    dirop->req = NULL;

   125

   126

    // dirop is now open

   127

    dirop->open = 1;

   128

   129

    // success, fallthrough for evsql_result_free

   130

    err = 0;

   131

   132

error:

   133

    if (err)

   134

        // fail it

   135

        _dbfs_dirop_fail(dirop);

   136

   137

    // free

   138

    evsql_result_free(res);

   139

}

   140

   141

/*

   142

 * The opendir transaction is ready for use. Query for the given dir's info

   143

 */

   144

static void dbfs_dirop_ready (struct evsql_trans *trans, void *arg) {

   145

    struct dbfs_dirop *dirop = arg;

   146

    struct dbfs *ctx = fuse_req_userdata(dirop->req);

   147

    int err;

   148

   149

    // XXX: unless we abort queries

   150

    assert(trans == dirop->trans);

   151

    assert(dirop->req);

   152

    assert(!dirop->open);

   153

   154

    INFO("[dbfs.opendir %p:%p] -> trans=%p", dirop, dirop->req, trans);

   155

   156

    // remember the transaction

   157

    dirop->trans = trans;

   158

   159

    // first fetch info about the dir itself

   160

    const char *sql =

   161

        "SELECT"

   162

        " file_tree.parent, inodes.type"

   163

        " FROM file_tree LEFT OUTER JOIN inodes ON (file_tree.inode = inodes.ino)"

   164

        " WHERE file_tree.inode = $1::int4";

   165

   166

    static struct evsql_query_params params = EVSQL_PARAMS(EVSQL_FMT_BINARY) {

   167

        EVSQL_PARAM ( UINT32 ),

   168

   169

        EVSQL_PARAMS_END

   170

    };

   171

   172

    // build params

   173

    if (0

   174

        ||  evsql_param_uint32(&params, 0, dirop->ino)

   175

    )

   176

        SERROR(err = EIO);

   177

   178

    // query

   179

    if (evsql_query_params(ctx->db, dirop->trans, sql, &params, dbfs_opendir_info_res, dirop) == NULL)

   180

        SERROR(err = EIO);

   181

   182

    // ok, wait for the info results

   183

    return;

   184

   185

error:

   186

    // fail it

   187

    _dbfs_dirop_fail(dirop);

   188

}

   189

   190

/*

   191

 * The dirop trans was committed, i.e. releasedir has completed

   192

 */

   193

static void dbfs_dirop_done (struct evsql_trans *trans, void *arg) {

   194

    struct dbfs_dirop *dirop = arg;

   195

    int err;

   196

   197

    assert(dirop->trans);

   198

    assert(dirop->req);

   199

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

   200

   201

    INFO("[dbfs.releasedir %p:%p] -> OK", dirop, dirop->req);

   202

   203

    // forget trans

   204

    dirop->trans = NULL;

   205

   206

    // just reply

   207

    if ((err = fuse_reply_err(dirop->req, 0)))

   208

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

   209

        EFATAL(err, "[dbfs.releasedir %p:%p] dirop_done: reply with fuse_reply_err", dirop, dirop->req);

   210

   211

    // req is done

   212

    dirop->req = NULL;

   213

   214

    // then we can just free dirop

   215

    _dbfs_dirop_free(dirop);

   216

}

   217

   218

/*

   219

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

   220

 *

   221

 * This might happend during the opendir evsql_trans, during a readdir evsql_query, during the releasedir

   222

 * evsql_trans_commit, or at any point in between.

   223

 *

   224

 * 1) loose the transaction

   225

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

   226

 */

   227

static void dbfs_dirop_error (struct evsql_trans *trans, void *arg) {

   228

    struct dbfs_dirop *dirop = arg;

   229

   230

    INFO("[dbfs:dirop %p:%p] evsql transaction error: %s", dirop, dirop->req, evsql_trans_error(trans));

   231

   232

    // deassociate the trans

   233

    dirop->trans = NULL;

   234

   235

    // if we were answering a req, error it out, and if the dirop isn't open, release it

   236

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

   237

    // for the next readdir/releasedir to detect this and return an error reply

   238

    if (dirop->req)

   239

        _dbfs_dirop_fail(dirop);

   240

    else

   241

        assert(dirop->open);

   242

}

   243

   244

/*

   245

 * Handle opendir(), this means starting a new transaction, dbfs_dirop_ready/error will continue on from there.

   246

 *

   247

 * The contents of fi will be copied into the dirop, and will be used as the basis for the fuse_reply_open reply.

   248

 */

   249

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

   250

    struct dbfs *ctx = fuse_req_userdata(req);

   251

    struct dbfs_dirop *dirop = NULL;

   252

    int err;

   253

   254

    // allocate it

   255

    if ((dirop = calloc(1, sizeof(*dirop))) == NULL && (err = EIO))

   256

        ERROR("calloc");

   257

   258

    INFO("[dbfs.opendir %p:%p] ino=%lu, fi=%p", dirop, req, ino, fi);

   259

   260

    // store the dirop

   261

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

   262

    dirop->fi = *fi;

   263

    dirop->fi.fh = (uint64_t) dirop;

   264

    dirop->req = req;

   265

    dirop->ino = ino;

   266

   267

    // start a new transaction

   268

    if ((dirop->trans = evsql_trans(ctx->db, EVSQL_TRANS_SERIALIZABLE, dbfs_dirop_error, dbfs_dirop_ready, dbfs_dirop_done, dirop)) == NULL)

   269

        SERROR(err = EIO);

   270

   271

    // XXX: handle interrupts

   272

   273

    // wait

   274

    return;

   275

   276

error:

   277

    if (dirop) {

   278

        // we can fail normally

   279

        _dbfs_dirop_fail(dirop);

   280

   281

    } else {

   282

        // must error out manually as we couldn't alloc the context

   283

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

   284

            EWARNING(err, "fuse_reply_err");

   285

    }

   286

}

   287

   288

/*

   289

 * Got the list of files for our readdir() request.

   290

 *

   291

 * Fill up the dirbuf, and then send the reply.

   292

 *

   293

 */

   294

static void dbfs_readdir_files_res (const struct evsql_result_info *res, void *arg) {

   295

    struct dbfs_dirop *dirop = arg;

   296

    int err;

   297

    size_t row;

   298

   299

    assert(dirop->req);

   300

    assert(dirop->trans);

   301

    assert(dirop->open);

   302

   303

    // check the results

   304

    if ((err = _dbfs_check_res(res, 0, 4)) < 0)

   305

        SERROR(err = EIO);

   306

   307

    INFO("[dbfs.readdir %p:%p] -> files: res_rows=%zu", dirop, dirop->req, evsql_result_rows(res));

   308

   309

    // iterate over the rows

   310

    for (row = 0; row < evsql_result_rows(res); row++) {

   311

        uint32_t off, ino;

   312

        const char *name, *type;

   313

   314

        // extract the data

   315

        if (0

   316

            ||  evsql_result_uint32(res, row, 0, &off,          0 ) // file_tree.offset

   317

            ||  evsql_result_string(res, row, 1, &name,         0 ) // file_tree.name

   318

            ||  evsql_result_uint32(res, row, 2, &ino,          0 ) // inodes.ino

   319

            ||  evsql_result_string(res, row, 3, &type,         0 ) // inodes.type

   320

        )

   321

            SERROR(err = EIO);

   322

   323

        INFO("\t%zu: off=%lu+2, name=%s, ino=%lu, type=%s", row, (long unsigned int) off, name, (long unsigned int) ino, type);

   324

   325

        // add to the dirbuf

   326

        // offsets are just offset + 2

   327

        if ((err = dirbuf_add(dirop->req, &dirop->dirbuf, off + 2, off + 3, name, ino, _dbfs_mode(type))) < 0 && (err = EIO))

   328

            ERROR("failed to add dirent for inode=%lu", (long unsigned int) ino);

   329

   330

        // stop if it's full

   331

        if (err > 0)

   332

            break;

   333

    }

   334

   335

    // send it

   336

    if ((err = dirbuf_done(dirop->req, &dirop->dirbuf)))

   337

        EERROR(err, "failed to send buf");

   338

   339

    // req is done

   340

    dirop->req = NULL;

   341

   342

    // good, fallthrough

   343

    err = 0;

   344

   345

error:

   346

    if (err)

   347

        _dbfs_dirop_fail(dirop);

   348

   349

    // free

   350

    evsql_result_free(res);

   351

}

   352

   353

/*

   354

 * Handle a readdir request. This will execute a SQL query inside the transaction to get the files at the given offset,

   355

 * and _dbfs_readdir_res will handle the results.

   356

 *

   357

 * If trans failed earlier, detect that and return an error.

   358

 */

   359

void dbfs_readdir (struct fuse_req *req, fuse_ino_t ino, size_t size, off_t off, struct fuse_file_info *fi) {

   360

    struct dbfs *ctx = fuse_req_userdata(req);

   361

    struct dbfs_dirop *dirop = (struct dbfs_dirop *) fi->fh;

   362

    int err;

   363

   364

    assert(dirop);

   365

    assert(!dirop->req);

   366

    assert(dirop->open);

   367

    assert(dirop->ino == ino);

   368

   369

    // store the new req

   370

    dirop->req = req;

   371

   372

    // detect earlier failures

   373

    if (!dirop->trans && (err = EIO))

   374

        ERROR("dirop trans has failed");

   375

   376

    INFO("[dbfs.readdir %p:%p] ino=%lu, size=%zu, off=%zu, fi=%p : trans=%p", dirop, req, ino, size, off, fi, dirop->trans);

   377

   378

    // create the dirbuf

   379

    if (dirbuf_init(&dirop->dirbuf, size, off))

   380

        SERROR(err = EIO);

   381

   382

    // add . and ..

   383

    // we set the next offset to 2, because all dirent offsets will be larger than that

   384

    // assume that these two should *always* fit

   385

    if ((err = (0

   386

        ||  dirbuf_add(req, &dirop->dirbuf, 0, 1, ".",   dirop->ino,    S_IFDIR )

   387

        ||  dirbuf_add(req, &dirop->dirbuf, 1, 2, "..",  

   388

                        dirop->parent ? dirop->parent : dirop->ino,     S_IFDIR )

   389

    )) && (err = EIO))

   390

        ERROR("failed to add . and .. dirents");

   391

   392

    // select all relevant file entries

   393

    const char *sql = 

   394

        "SELECT"

   395

        " file_tree.\"offset\", file_tree.name, inodes.ino, inodes.type"

   396

        " FROM file_tree LEFT OUTER JOIN inodes ON (file_tree.inode = inodes.ino)"

   397

        " WHERE file_tree.parent = $1::int4 AND file_tree.\"offset\" >= $2::int4"

   398

        " LIMIT $3::int4";

   399

   400

    static struct evsql_query_params params = EVSQL_PARAMS(EVSQL_FMT_BINARY) {

   401

        EVSQL_PARAM ( UINT32 ),

   402

        EVSQL_PARAM ( UINT32 ),

   403

        EVSQL_PARAM ( UINT32 ),

   404

   405

        EVSQL_PARAMS_END

   406

    };

   407

   408

    // adjust offset to take . and .. into account

   409

    if (off > 2)

   410

        off -= 2;

   411

   412

    // build params

   413

    if (0

   414

        ||  evsql_param_uint32(&params, 0, dirop->ino)

   415

        ||  evsql_param_uint32(&params, 1, off)

   416

        ||  evsql_param_uint32(&params, 2, dirbuf_estimate(&dirop->dirbuf, 0))

   417

    )

   418

        SERROR(err = EIO);

   419

   420

    // query

   421

    if (evsql_query_params(ctx->db, dirop->trans, sql, &params, dbfs_readdir_files_res, dirop) == NULL)

   422

        SERROR(err = EIO);

   423

   424

    // good, wait

   425

    return;

   426

   427

error:

   428

    _dbfs_dirop_fail(dirop);

   429

}

   430

   431

/*

   432

 * "For every [succesfull] opendir call there will be exactly one releasedir call."

   433

 *

   434

 * The dirop may be in a failed state.

   435

 */

   436

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

   437

    struct dbfs *ctx = fuse_req_userdata(req);

   438

    struct dbfs_dirop *dirop = (struct dbfs_dirop *) fi->fh;

   439

    int err;

   440

   441

    (void) ctx;

   442

   443

    assert(dirop);

   444

    assert(!dirop->req);

   445

    assert(dirop->ino == ino);

   446

   447

    // update to this req

   448

    dirop->req = req;

   449

   450

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

   451

    (void) fi;

   452

   453

    // handle failed trans

   454

    if (!dirop->trans)

   455

        ERROR("trans has failed");

   456

   457

    // log

   458

    INFO("[dbfs.releasedir %p:%p] ino=%lu, fi=%p : trans=%p", dirop, req, ino, fi, dirop->trans);

   459

   460

    // we must commit the transaction (although it was jut SELECTs, no changes).

   461

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

   462

    // or dirop->trans this means that we need to keep the dirop open when calling trans_commit, so that dirop_error

   463

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

   464

    if (evsql_trans_commit(dirop->trans))

   465

        SERROR(err = EIO);

   466

   467

    // fall-through to cleanup

   468

    err = 0;

   469

   470

error:

   471

    // the dirop is not open anymore and can be free'd:

   472

    // a) if we already caught an error

   473

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

   474

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

   475

    dirop->open = 0;

   476

   477

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

   478

    if (err) {

   479

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

   480

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

   481

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

   482

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

   483

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

   484

   485

        if (dirop->req)

   486

            _dbfs_dirop_fail(dirop);

   487

        else

   488

            assert(!dirop->trans);

   489

   490

    } else {

   491

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

   492

        assert(dirop->req);

   493

        assert(dirop->trans);

   494

    }

   495

}

   496