1

     2

/*

     3

 * A simple PostgreSQL-based filesystem.

     4

 */

     5

     6

#include <stdlib.h>

     7

#include <string.h>

     8

#include <errno.h>

     9

#include <assert.h>

    10

    11

#include <event2/event.h>

    12

    13

#include "evfuse.h"

    14

#include "evsql.h"

    15

#include "dirbuf.h"

    16

#include "lib/log.h"

    17

#include "lib/signals.h"

    18

#include "lib/misc.h"

    19

    20

#define SERROR(val) do { (val); goto error; } while(0)

    21

    22

struct dbfs {

    23

    struct event_base *ev_base;

    24

    struct signals *signals;

    25

    26

    const char *db_conninfo;

    27

    struct evsql *db;

    28

    29

    struct evfuse *ev_fuse;

    30

};

    31

    32

#define CONNINFO_DEFAULT "dbname=test"

    33

    34

// XXX: not sure how this should work

    35

#define CACHE_TIMEOUT 1.0

    36

    37

mode_t _dbfs_mode (const char *type) {

    38

    if (!strcmp(type, "DIR"))

    39

        return S_IFDIR;

    40

    41

    if (!strcmp(type, "REG"))

    42

        return S_IFREG;

    43

    44

    else {

    45

        WARNING("[dbfs] weird mode-type: %s", type);

    46

        return 0;

    47

    }

    48

}

    49

    50

void dbfs_init (void *userdata, struct fuse_conn_info *conn) {

    51

    INFO("[dbfs.init] userdata=%p, conn=%p", userdata, conn);

    52

    53

}

    54

    58

    61

}

    62

    63

/*

    64

 * Check the result set.

    65

 *

    66

 * Returns;

    68

 *  0   the results match

    69

 *  1   there were no results

    70

 */

    71

int _dbfs_check_res (const struct evsql_result_info *res, size_t rows, size_t cols) {

    72

    int err = 0;

    73

    74

    // check if it failed

    75

    if (res->error)

    76

        NERROR(evsql_result_error(res));

    77

    78

    // not found?

    79

    if (evsql_result_rows(res) == 0)

    80

        SERROR(err = 1);

    81

    82

    // duplicate rows?

    85

    86

    // correct number of columns

    88

        ERROR("wrong number of columns: %zu", evsql_result_cols(res));

    89

    90

    // good

    91

    return 0;

    92

    93

error:

    94

    if (!err)

    95

        err = -1;

    96

    97

    return err;

    98

}

    99

   100

int _dbfs_stat_info (struct stat *st, const struct evsql_result_info *res, size_t row, size_t col_offset) {

   101

    int err = 0;

   102

   103

    uint16_t mode;

   104

    uint64_t size, nlink;

   105

    const char *type;

   106

   107

    // extract the data

   108

    if (0

   109

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

   110

        ||  evsql_result_uint16(res, row, col_offset + 1, &mode,       0 ) // inodes.mode

   111

        ||  evsql_result_uint64(res, row, col_offset + 2, &size,       0 ) // inodes.size

   112

        ||  evsql_result_uint64(res, row, col_offset + 3, &nlink,      0 ) // count(*)

   113

    )

   114

        EERROR(err = EIO, "invalid db data");

   115

   116

    INFO("\tst_mode=S_IF%s | %ho, st_nlink=%llu, st_size=%llu", type, mode, (long long unsigned int) nlink, (long long unsigned int) size);

   117

   118

    // convert and store

   119

    st->st_mode = _dbfs_mode(type) | mode;

   120

    st->st_nlink = nlink;

   121

    st->st_size = size;

   122

   123

    // good

   124

    return 0;

   125

   126

error:

   127

    return -1;

   128

}

   129

   130

void _dbfs_lookup_result (const struct evsql_result_info *res, void *arg) {

   131

    struct fuse_req *req = arg;

   132

    struct fuse_entry_param e; ZINIT(e);

   133

    int err = 0;

   134

   135

    uint32_t ino;

   136

   137

    // check the results

   138

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

   139

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

   140

   141

    // get the data

   142

    if (0

   143

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

   144

    )

   145

        EERROR(err = EIO, "invalid db data");

   146

   148

   149

    // stat attrs

   150

    if (_dbfs_stat_info(&e.attr, res, 0, 1))

   151

        goto error;

   152

   153

    // other attrs

   154

    e.ino = e.attr.st_ino = ino;

   155

    e.attr_timeout = CACHE_TIMEOUT;

   156

    e.entry_timeout = CACHE_TIMEOUT;

   157

   158

    // reply

   159

    if ((err = fuse_reply_entry(req, &e)))

   160

        EERROR(err, "fuse_reply_entry");

   161

   162

error:

   163

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

   164

        EWARNING(err, "fuse_reply_err");

   165

   166

    // free

   167

    evsql_result_free(res);

   168

}

   169

   170

void dbfs_lookup (struct fuse_req *req, fuse_ino_t parent, const char *name) {

   171

    struct dbfs *ctx = fuse_req_userdata(req);

   172

    int err;

   173

   174

    INFO("[dbfs.lookup] parent=%lu name=%s", parent, name);

   175

   176

    // query and params

   177

    const char *sql = 

   178

        "SELECT"

   179

        " inodes.ino, inodes.type, inodes.mode, inodes.size, count(*)"

   180

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

   181

        " WHERE file_tree.parent = $1::int4 AND file_tree.name = $2::varchar"

   182

        " GROUP BY inodes.ino, inodes.type, inodes.mode, inodes.size";

   183

   184

    static struct evsql_query_params params = EVSQL_PARAMS(EVSQL_FMT_BINARY) {

   185

        EVSQL_PARAM ( UINT32 ),

   186

        EVSQL_PARAM ( STRING ),

   187

   188

        EVSQL_PARAMS_END

   189

    };

   190

   191

    // build params

   192

    if (0

   193

        ||  evsql_param_uint32(&params, 0, parent)

   194

        ||  evsql_param_string(&params, 1, name)

   195

    )

   196

        EERROR(err = EIO, "evsql_param_*");

   197

   198

    // query

   199

    if (evsql_query_params(ctx->db, NULL, sql, &params, _dbfs_lookup_result, req) == NULL)

   200

        EERROR(err = EIO, "evsql_query_params");

   201

   202

    // XXX: handle interrupts

   203

   204

    // wait

   205

    return;

   206

   207

error:

   208

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

   209

        EWARNING(err, "fuse_reply_err");

   210

}

   211

   212

void _dbfs_getattr_result (const struct evsql_result_info *res, void *arg) {

   213

    struct fuse_req *req = arg;

   214

    struct stat st; ZINIT(st);

   215

    int err = 0;

   216

   217

    // check the results

   218

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

   219

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

   220

   221

    INFO("[dbfs.getattr %p] -> (stat follows)", req);

   222

   223

    // stat attrs

   224

    if (_dbfs_stat_info(&st, res, 0, 0))

   225

        goto error;

   226

   227

    // XXX: we don't have the ino

   228

    st.st_ino = 0;

   229

   230

    // reply

   231

    if ((err = fuse_reply_attr(req, &st, CACHE_TIMEOUT)))

   232

        EERROR(err, "fuse_reply_entry");

   233

   234

error:

   235

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

   236

        EWARNING(err, "fuse_reply_err");

   237

   238

    // free

   239

    evsql_result_free(res);

   240

}

   241

   242

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

   243

    struct dbfs *ctx = fuse_req_userdata(req);

   244

    int err;

   245

   246

    (void) fi;

   247

   248

    INFO("[dbfs.getattr %p] ino=%lu", req, ino);

   249

   250

    const char *sql =

   251

        "SELECT"

   252

        " inodes.type, inodes.mode, inodes.size, count(*)"

   253

        " FROM inodes"

   255

        " GROUP BY inodes.type, inodes.mode, inodes.size";

   256

   257

    static struct evsql_query_params params = EVSQL_PARAMS(EVSQL_FMT_BINARY) {

   258

        EVSQL_PARAM ( UINT32 ),

   259

   260

        EVSQL_PARAMS_END

   261

    };

   262

   263

    // build params

   264

    if (0

   265

        ||  evsql_param_uint32(&params, 0, ino)

   266

    )

   267

        SERROR(err = EIO);

   268

   269

    // query

   270

    if (evsql_query_params(ctx->db, NULL, sql, &params, _dbfs_getattr_result, req) == NULL)

   271

        SERROR(err = EIO);

   272

   273

    // XXX: handle interrupts

   274

   275

    // wait

   276

    return;

   277

   278

error:

   279

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

   280

        EWARNING(err, "fuse_reply_err");

   281

}

   282

   283

struct dbfs_dirop {

   285

    struct fuse_req *req;

   286

   287

    struct evsql_trans *trans;

   288

   292

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

   293

    int open;

   297

};

   298

   299

/*

   300

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

   301

 *

   302

 * req must be NULL.

   303

 */

   304

static void dbfs_dirop_free (struct dbfs_dirop *dirop) {

   308

   311

        evsql_trans_abort(dirop->trans);

   315

   316

    free(dirop);

   317

}

   318

   370

/*

   371

 * The opendir transaction is ready

   372

 */

   373

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

   374

    struct dbfs_dirop *dirop = arg;

   377

    int err;

   378

   382

   383

    // remember the transaction

   384

    dirop->trans = trans;

   392

   395

   410

    return;

   411

   412

error:

   417

    dbfs_dirop_free(dirop);

   419

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

   420

        EWARNING(err, "fuse_reply_err");

   421

}

   422

   423

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

   424

    struct dbfs_dirop *dirop = arg;

   426

    int err;

   427

   429

   441

}

   442

   443

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

   444

    struct dbfs_dirop *dirop = arg;

   445

    int err;

   446

   447

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

   448

   449

    // deassociate the trans

   450

    dirop->trans = NULL;

   451

   452

    // error out and pending req

   453

    if (dirop->req) {

   454

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

   455

            EWARNING(err, "fuse_erply_err");

   456

   457

        dirop->req = NULL;

   458

   459

        // only free the dirop if it isn't open

   460

        if (!dirop->open)

   461

            dbfs_dirop_free(dirop);

   462

    }

   463

}

   464

   465

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

   466

    struct dbfs *ctx = fuse_req_userdata(req);

   467

    struct dbfs_dirop *dirop = NULL;

   468

    int err;

   469

   470

    // allocate it

   471

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

   472

        ERROR("calloc");

   473

   474

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

   476

    // store the dirop

   480

    dirop->req = req;

   482

   483

    // start a new transaction

   485

        SERROR(err = EIO);

   486

   487

    // XXX: handle interrupts

   488

   489

    // wait

   490

    return;

   491

   492

error:

   493

    // we handle the req

   494

    dirop->req = NULL;

   495

   496

    dbfs_dirop_free(dirop);

   497

   498

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

   499

        EWARNING(err, "fuse_reply_err");

   500