1

     2

#include "common.h"

     3

#include "ops.h"

     4

     5

/*

     6

 * Core fs functionality like lookup, getattr

     7

 */

     8

     9

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

    10

    struct fuse_req *req = arg;

    11

    struct fuse_entry_param e; ZINIT(e);

    12

    int err = 0;

    13

    14

    uint32_t ino;

    15

    16

    // check the results

    17

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

    18

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

    19

    20

    // get the data

    21

    if (0

    22

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

    23

    )

    24

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

    25

    26

    INFO("[dbfs.lookup] -> ino=%u", ino);

    27

    28

    // stat attrs

    29

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

    30

        goto error;

    31

    32

    // other attrs

    33

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

    34

    e.attr_timeout = CACHE_TIMEOUT;

    35

    e.entry_timeout = CACHE_TIMEOUT;

    36

    37

    // reply

    38

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

    39

        EERROR(err, "fuse_reply_entry");

    40

    41

error:

    42

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

    43

        EWARNING(err, "fuse_reply_err");

    44

    45

    // free

    46

    evsql_result_free(res);

    47

}

    48

    49

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

    50

    struct dbfs *ctx = fuse_req_userdata(req);

    51

    int err;

    52

    53

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

    54

    55

    // query and params

    56

    const char *sql = 

    57

        "SELECT"

    58

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

    59

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

    60

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

    61

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

    62

    63

    static struct evsql_query_params params = EVSQL_PARAMS(EVSQL_FMT_BINARY) {

    64

        EVSQL_PARAM ( UINT32 ),

    65

        EVSQL_PARAM ( STRING ),

    66

    67

        EVSQL_PARAMS_END

    68

    };

    69

    70

    // build params

    71

    if (0

    72

        ||  evsql_param_uint32(&params, 0, parent)

    73

        ||  evsql_param_string(&params, 1, name)

    74

    )

    75

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

    76

    77

    // query

    78

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

    79

        EERROR(err = EIO, "evsql_query_params");

    80

    81

    // XXX: handle interrupts

    82

    83

    // wait

    84

    return;

    85

    86

error:

    87

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

    88

        EWARNING(err, "fuse_reply_err");

    89

}

    90

    91

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

    92

    struct fuse_req *req = arg;

    93

    struct stat st; ZINIT(st);

    94

    int err = 0;

    95

    96

    // check the results

    97

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

    98

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

    99

   100

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

   101

   102

    // stat attrs

   103

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

   104

        goto error;

   105

   106

    // XXX: we don't have the ino

   107

    st.st_ino = 0;

   108

   109

    // reply

   110

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

   111

        EERROR(err, "fuse_reply_entry");

   112

   113

error:

   114

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

   115

        EWARNING(err, "fuse_reply_err");

   116

   117

    // free

   118

    evsql_result_free(res);

   119

}

   120

   121

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

   122

    struct dbfs *ctx = fuse_req_userdata(req);

   123

    int err;

   124

   125

    (void) fi;

   126

   127

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

   128

   129

    const char *sql =

   130

        "SELECT"

   131

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

   132

        " FROM inodes"

   133

        " WHERE inodes.ino = $1::int4"

   134

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

   135

   136

    static struct evsql_query_params params = EVSQL_PARAMS(EVSQL_FMT_BINARY) {

   137

        EVSQL_PARAM ( UINT32 ),

   138

   139

        EVSQL_PARAMS_END

   140

    };

   141

   142

    // build params

   143

    if (0

   144

        ||  evsql_param_uint32(&params, 0, ino)

   145

    )

   146

        SERROR(err = EIO);

   147

   148

    // query

   149

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

   150

        SERROR(err = EIO);

   151

   152

    // XXX: handle interrupts

   153

   154

    // wait

   155

    return;

   156

   157

error:

   158

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

   159

        EWARNING(err, "fuse_reply_err");

   160

}

   161