1

#include <string.h>

     2

#include <errno.h>

     3

#include <stdlib.h>

     4

#include <assert.h>

     5

     6

#include "simple.h"

     7

#include "dirbuf.h"

     8

#include "lib/log.h"

    10

#include "lib/misc.h"

    11

    12

struct simple_fs {

    13

    const struct simple_node *inode_table;

    14

    15

    size_t inode_count;

    16

};

    17

    18

/*

    19

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

    20

 */

    21

#define CACHE_TIMEOUT 1.0

    22

    23

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

    24

    stat->st_ino = node->inode;

    25

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

    26

    stat->st_nlink = 1;

    27

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

    28

}

    29

    30

/*

    31

 * Fetch the simple_node for the given inode.

    32

 *

    33

 * Returns NULL for invalid inodes.

    34

 */

    35

static const struct simple_node *_simple_get_ino (struct simple_fs *fs, fuse_ino_t ino) {

    36

    // make sure it's a valid inode

    37

    if (ino < 1 || ino > fs->inode_count) {

    38

        WARNING("invalid inode=%zu", ino);

    39

        return NULL;

    40

    }

    41

    42

    // return the node

    43

    return fs->inode_table + (ino - 1);

    44

}

    45

    46

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

    47

    struct simple_fs *fs = fuse_req_userdata(req);

    48

    const struct simple_node *node;

    49

    struct fuse_entry_param e; ZINIT(e);

    50

    int err;

    51

    52

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

    53

    54

    // find the matching node

    55

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

    56

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

    57

            break;

    58

    59

    }

    60

    61

    // did we find it?

    62

    if (node->inode) {

    63

        // set up the entry

    64

        e.ino = node->inode;

    65

        e.generation = 0x01;

    66

        _simple_stat(&e.attr, node);

    67

        e.attr_timeout = CACHE_TIMEOUT;

    68

        e.entry_timeout = CACHE_TIMEOUT;

    69

    70

        // reply

    71

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

    72

            EERROR(err, "fuse_reply_entry");

    73

    74

    } else {

    75

        // not found

    76

        err = ENOENT;

    77

        goto error;

    78

    }

    79

    80

    // success

    81

    return;

    82

    83

error:

    84

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

    85

        EWARNING(err, "fuse_reply_err");

    86

}

    87

    88

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

    89

    struct simple_fs *fs = fuse_req_userdata(req);

    90

    const struct simple_node *node;

    91

    struct stat stbuf; ZINIT(stbuf);

    92

    int err;

    93

    94

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

    95

    96

    // look up the node 

    97

    if ((node = _simple_get_ino(fs, ino)) == NULL)

    98

        EERROR(err = EINVAL, "bad inode");

    99

   100

    // set up the stbuf

   101

    _simple_stat(&stbuf, node);

   102

   103

    // reply

   104

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

   105

        EERROR(err, "fuse_reply_attr");

   106

   107

    // suceccss

   108

    return;

   109

   110

error:

   111

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

   112

        EWARNING(err, "fuse_reply_err");

   113

}

   114

   116

    struct simple_fs *fs = fuse_req_userdata(req);

   117

    const struct simple_node *dir_node, *node;

   118

    struct dirbuf buf;

   119

    int err;

   120

   121

    INFO("[simple.readdir] ino=%lu, size=%zu, off=%zu, fi=%p", ino, size, off, fi);

   122

   123

    // look up the inode

   124

    if ((dir_node = _simple_get_ino(fs, ino)) == NULL)

   125

        EERROR(err = EINVAL, "bad inode");

   126

   127

    // check that it's a dir

   128

    if (dir_node->mode_type != S_IFDIR)

   129

        EERROR(err = ENOTDIR, "bad mode");

   130

   131

    // fill in the dirbuf

   132

    if (dirbuf_init(&buf, size))

   133

        ERROR("failed to init dirbuf");

   134

   135

    // add . and ..

   136

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

   137

    err =   dirbuf_add(req, off, &buf, 0, 1, ".",   dir_node->inode,    S_IFDIR )

   138

        ||  dirbuf_add(req, off, &buf, 1, 2, "..",  dir_node->inode,    S_IFDIR );

   139

   140

    if (err != 0)

   141

        EERROR(err, "failed to add . and .. dirents");

   142

   143

    // look up all child nodes

   144

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

   145

        // skip non-children

   146

        if (node->parent != dir_node->inode)

   147

            continue;

   148

   149

        // child node offsets are just inode + 2

   150

        if ((err = dirbuf_add(req, off, &buf, node->inode + 2, node->inode + 3, node->name, node->inode, node->mode_type)) < 0)

   151

            EERROR(err, "failed to add dirent for inode=%lu", node->inode);

   152

   153

        // stop if it's full

   154

        if (err > 0)

   155

            break;

   156

    }

   157

   158

    // send it

   159

    if ((err = -dirbuf_done(req, &buf)))

   160

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

   161

   162

    // success

   163

    return;

   164

   165

error:

   166

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

   167

        EWARNING(err, "fuse_reply_err");

   168

}

   169

   209

/*

   210

 * Define our fuse_lowlevel_ops struct.

   211

 */

   212

static struct fuse_lowlevel_ops simple_ops = {

   213

    .lookup = simple_lookup,

   214

   215

    .getattr = simple_getattr,

   216

   217

    .readdir = simple_readdir,

   220

};

   221

   222

struct fuse_lowlevel_ops *simple_init () {

   223

    return &simple_ops;

   224

}

   225

   226

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

   227

    struct simple_fs *fs = NULL;

   228

    const struct simple_node *node;

   229

   230

    // generate

   231

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

   232

        ERROR("calloc");

   233

   234

    // remember node_list

   235

    fs->inode_count = 0;

   236

    fs->inode_table = node_list;

   237

   238

    // validate it

   239

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

   240

        // update inode_count

   241

        fs->inode_count++;

   242

   243

        // check that parent is valid

   244

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

   245

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

   246

    }

   247

   248

    // success

   249

    return fs;

   250

   251

error:

   252

    return NULL;

   253

}