1

#include <string.h>

     2

#include <errno.h>

     3

#include <stdlib.h>

     4

#include <assert.h>

     5

     6

#include "simple.h"

     8

#include "lib/log.h"

     9

#include "lib/misc.h"

    10

    11

struct simple_fs {

    12

    const struct simple_node *inode_table;

    13

    14

    size_t inode_count;

    15

};

    16

    17

/*

    18

 * Used for stat/entry timeouts... not sure how this should really be set.

    19

 */

    20

#define CACHE_TIMEOUT 1.0

    21

    22

static void _simple_stat (struct stat *stat, const struct simple_node *node) {

    23

    stat->st_ino = node->inode;

    24

    stat->st_mode = node->mode_type | node->mode_perm;

    25

    stat->st_nlink = 1;

    26

    stat->st_size = node->data ? strlen(node->data) : 0;

    27

}

    28

    43

}

    44

    45

static void simple_lookup (fuse_req_t req, fuse_ino_t parent, const char *name) {

    46

    struct simple_fs *fs = fuse_req_userdata(req);

    47

    const struct simple_node *node;

    48

    struct fuse_entry_param e; ZINIT(e);

    49

    int err;

    50

    51

    INFO("[simple.lookup %p] parent=%lu, name=`%s'", fs, parent, name);

    52

    53

    // find the matching node

    54

    for (node = fs->inode_table; node->inode > 0; node++) {

    55

        if (node->parent == parent && strcmp(node->name, name) == 0)

    56

            break;

    57

    58

    }

    59

    60

    // did we find it?

    61

    if (node->inode) {

    62

        // set up the entry

    63

        e.ino = node->inode;

    64

        e.generation = 0x01;

    65

        _simple_stat(&e.attr, node);

    66

        e.attr_timeout = CACHE_TIMEOUT;

    67

        e.entry_timeout = CACHE_TIMEOUT;

    68

    69

        // reply

    70

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

    71

            EERROR(err, "fuse_reply_entry");

    72

    73

    } else {

    74

        // not found

    75

        err = ENOENT;

    76

        goto error;

    77

    }

    78

    79

    // success

    80

    return;

    81

    82

error:

    83

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

    84

        EWARNING(err, "fuse_reply_err");

    85

}

    86

    87

static void simple_getattr (fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi) {

    88

    struct simple_fs *fs = fuse_req_userdata(req);

    89

    const struct simple_node *node;

    90

    struct stat stbuf; ZINIT(stbuf);

    91

    int err;

    92

    93

    INFO("[simple.getattr %p] ino=%lu", fs, ino);

    94

    99

    // set up the stbuf

   100

    _simple_stat(&stbuf, node);

   101

   102

    // reply

   103

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

   104

        EERROR(err, "fuse_reply_attr");

   105

   106

    // suceccss

   107

    return;

   108

   109

error:

   110

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

   111

        EWARNING(err, "fuse_reply_err");

   112

}

   113

   168

   169

/*

   170

 * Define our fuse_lowlevel_ops struct.

   171

 */

   172

static struct fuse_lowlevel_ops simple_ops = {

   173

    .lookup = simple_lookup,

   174

   175

    .getattr = simple_getattr,

   178

};

   179

   180

struct fuse_lowlevel_ops *simple_init () {

   181

    return &simple_ops;

   182

}

   183

   184

struct simple_fs *simple_new (const struct simple_node *node_list) {

   185

    struct simple_fs *fs = NULL;

   186

    const struct simple_node *node;

   187

   188

    // generate

   189

    if ((fs = calloc(1, sizeof(*fs))) == NULL)

   190

        ERROR("calloc");

   191

   192

    // remember node_list

   193

    fs->inode_count = 0;

   194

    fs->inode_table = node_list;

   195

   196

    // validate it

   197

    for (node = fs->inode_table; node->inode; node++) {

   198

        // update inode_count

   199

        fs->inode_count++;

   200

   201

        // check that parent is valid

   202

        assert(node->inode == fs->inode_count);

   203

        assert(node->parent < node->inode);

   204

    }

   205

   206

    // success

   207

    return fs;

   208

   209

error:

   210

    return NULL;

   211

}