1

     2

#include <stdlib.h>

     3

#include <assert.h>

     4

     5

#include "dbfs.h"

     6

#include "op_base.h"

     7

#include "../dirbuf.h"

     8

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

     9

    10

/*

    11

 * Directory related functionality like opendir, readdir, releasedir

    12

 */

    13

struct dbfs_dirop {

    14

    struct dbfs_op base;

    15

    16

    // parent dir inodes

    17

    uint32_t parent;

    18

    19

    // for readdir

    20

    struct dirbuf dirbuf;

    21

};

    22

    23

/*

    24

 * Release the dirbuf.

    25

 */

    26

static void _dbfs_dirop_free (struct dbfs_op *op_base) {

    27

    struct dbfs_dirop *dirop = (struct dbfs_dirop *) op_base;

    28

    29

    // just release the dirbuf

    30

    dirbuf_release(&dirop->dirbuf);

    31

}

    32

    33

/*

    34

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

    35

 */

    37

    struct dbfs_dirop *dirop = arg;

    38

    int err;

    39

    40

    assert(dirop->base.req);

    41

    assert(dirop->base.trans); // query callbacks don't get called if the trans fails

    42

    assert(!dirop->base.open);

    43

    44

    // check the results

    45

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

    46

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

    47

    48

    const char *type;

    49

    50

    // extract the data

    51

    if (0

    52

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

    53

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

    54

    )

    55

        SERROR(err = EIO);

    56

    57

    // is it a dir?

    58

    if (_dbfs_mode(type) != S_IFDIR)

    59

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

    60

    61

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

    62

    63

    // open_fn done, do the open_reply

    64

    if ((err = dbfs_op_open_reply(&dirop->base)))

    65

        goto error;

    66

    67

    // success, fallthrough for evsql_result_free

    68

    err = 0;

    69

    70

error:

    71

    if (err)

    72

        // fail it

    73

        dbfs_op_fail(&dirop->base, err);

    74

    75

    // free

    76

    evsql_result_free(res);

    77

}

    78

    79

/*

    80

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

    81

 */

    82

static void dbfs_dirop_open (struct dbfs_op *op_base) {

    83

    struct dbfs_dirop *dirop = (struct dbfs_dirop *) op_base;

    84

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

    85

    int err;

    86

    87

    assert(dirop->base.trans); 

    88

    assert(dirop->base.req);

    89

    assert(!dirop->base.open);

    90

    91

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

    92

    93

    // first fetch info about the dir itself

    94

    const char *sql =

    95

        "SELECT"

    96

        " file_tree.parent, inodes.type"

    97

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

    98

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

    99

   100

    static struct evsql_query_params params = EVSQL_PARAMS(EVSQL_FMT_BINARY) {

   101

        EVSQL_PARAM ( UINT32 ),

   102

   103

        EVSQL_PARAMS_END

   104

    };

   105

   106

    // build params

   107

    if (0

   108

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

   109

    )

   110

        SERROR(err = EIO);

   111

   112

    // query

   113

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

   114

        SERROR(err = EIO);

   115

   116

    // ok, wait for the info results

   117

    return;

   118

   119

error:

   120

    // fail it

   121

    dbfs_op_fail(&dirop->base, err);

   122

}

   123

   124

/*

   125

 * Handle opendir(), this means starting a new op.

   126

 */

   127

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

   128

    struct dbfs *ctx = fuse_req_userdata(req);

   129

    struct dbfs_dirop *dirop = NULL;

   130

    int err;

   131

   132

    // allocate it

   133

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

   134

        ERROR("calloc");

   135

   136

    // do the op_open

   137

    if ((err = dbfs_op_open(ctx, &dirop->base, req, ino, fi, _dbfs_dirop_free, dbfs_dirop_open)))

   138

        ERROR("dbfs_op_open");

   139

   140

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

   141

   142

    // wait

   143

    return;

   144

   145

error:

   146

    if (dirop) {

   147

        // we can fail normally

   148

        dbfs_op_fail(&dirop->base, err);

   149

   150

    } else {

   151

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

   152

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

   153

            EWARNING(err, "fuse_reply_err");

   154

    }

   155

}

   156

   157

/*

   158

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

   159

 *

   160

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

   161

 *

   162

 */

   164

    struct dbfs_dirop *dirop = arg;

   165

    int err;

   166

    size_t row;

   167

   168

    assert(dirop->base.req);

   169

    assert(dirop->base.trans); // query callbacks don't get called if the trans fails

   170

    assert(dirop->base.open);

   171

   172

    // check the results

   173

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

   174

        SERROR(err = EIO);

   175

   176

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

   177

   178

    // iterate over the rows

   179

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

   180

        uint32_t off, ino;

   181

        const char *name, *type;

   182

   183

        // extract the data

   184

        if (0

   185

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

   186

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

   187

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

   188

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

   189

        )

   190

            SERROR(err = EIO);

   191

   192

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

   193

   194

        // add to the dirbuf

   195

        // offsets are just offset + 2

   196

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

   197

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

   198

   199

        // stop if it's full

   200

        if (err > 0)

   201

            break;

   202

    }

   203

   204

    // send it

   205

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

   206

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

   207

   208

    // handled the req

   209

    if ((err = dbfs_op_req_done(&dirop->base)))

   210

        goto error;

   211

   212

    // good, fallthrough

   213

    err = 0;

   214

   215

error:

   216

    if (err)

   217

        dbfs_op_fail(&dirop->base, err);

   218

   219

    // free

   220

    evsql_result_free(res);

   221

}

   222

   223

/*

   224

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

   225

 * and dbfs_readdir_res will handle the results.

   226

 *

   227

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

   228

 */

   229

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

   230

    struct dbfs *ctx = fuse_req_userdata(req);

   231

    struct dbfs_dirop *dirop;

   232

    int err;

   233

   234

    // get the op

   235

    if ((dirop = (struct dbfs_dirop *) dbfs_op_req(req, ino, fi)) == NULL)

   236

        return;

   237

   238

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

   239

   240

    // create the dirbuf

   241

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

   242

        SERROR(err = EIO);

   243

   244

    // add . and ..

   245

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

   246

    // assume that these two should *always* fit

   247

    if ((err = (0

   248

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

   249

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

   250

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

   251

    )) && (err = EIO))

   252

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

   253

   254

    // select all relevant file entries

   255

    const char *sql = 

   256

        "SELECT"

   257

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

   258

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

   259

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

   260

        " ORDER BY file_tree.\"offset\""

   261

        " LIMIT $3::int4";

   262

   263

    static struct evsql_query_params params = EVSQL_PARAMS(EVSQL_FMT_BINARY) {

   264

        EVSQL_PARAM ( UINT32 ),

   265

        EVSQL_PARAM ( UINT32 ),

   266

        EVSQL_PARAM ( UINT32 ),

   267

   268

        EVSQL_PARAMS_END

   269

    };

   270

   271

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

   272

    if (off > 2)

   273

        off -= 2;

   274

   275

    // build params

   276

    if (0

   277

        ||  evsql_param_uint32(&params, 0, ino)

   278

        ||  evsql_param_uint32(&params, 1, off)

   279

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

   280

    )

   281

        SERROR(err = EIO);

   282

   283

    // query

   284

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

   285

        SERROR(err = EIO);

   286

   287

    // good, wait

   288

    return;

   289

   290

error:

   291

    dbfs_op_fail(&dirop->base, err);

   292

}

   293

   294

/*

   295

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

   296

 *

   297

 * The dirop may be in a failed state.

   298

 */

   299

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

   300

    // just passthrough to dbfs_op

   301

    dbfs_op_release(req, ino, fi);

   302

}

   303