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"

     9

#include "lib/math.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

   115

static void simple_readlink (fuse_req_t req, fuse_ino_t ino) {

   116

    struct simple_fs *fs = fuse_req_userdata(req);

   117

    const struct simple_node *node;

   118

    int err;

   119

   120

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

   121

   122

    // look up the node 

   123

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

   124

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

   125

   126

    // check that it's a symlink

   127

    if (node->mode_type != S_IFLNK)

   128

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

   129

   130

    // return the contents

   131

    if ((err = fuse_reply_readlink(req, node->data)))

   132

        EERROR(err, "fuse_reply_readlink");

   133

   134

    // suceccss

   135

    return;

   136

   137

error:

   138

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

   139

        EWARNING(err, "fuse_reply_err");

   140

   141

}

   142

   143

static void simple_readdir (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, struct fuse_file_info *fi) {

   144

    struct simple_fs *fs = fuse_req_userdata(req);

   145

    const struct simple_node *dir_node, *node;

   146

    struct dirbuf buf;

   147

    int err;

   148

   149

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

   150

   151

    // look up the inode

   152

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

   153

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

   154

   155

    // check that it's a dir

   156

    if (dir_node->mode_type != S_IFDIR)

   157

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

   158

   159

    // fill in the dirbuf

   160

    if (dirbuf_init(&buf, size, off))

   161

        ERROR("failed to init dirbuf");

   162

   163

    // add . and ..

   164

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

   165

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

   166

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

   167

   168

    if (err != 0)

   169

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

   170

   171

    // look up all child nodes

   172

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

   173

        // skip non-children

   174

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

   175

            continue;

   176

   177

        // child node offsets are just inode + 2

   178

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

   179

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

   180

   181

        // stop if it's full

   182

        if (err > 0)

   183

            break;

   184

    }

   185

   186

    // send it

   187

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

   188

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

   189

   190

    // success

   191

    return;

   192

   193

error:

   194

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

   195

        EWARNING(err, "fuse_reply_err");

   196

}

   197

   198

static void simple_read (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, struct fuse_file_info *fi) {

   199

    struct simple_fs *fs = fuse_req_userdata(req);

   200

    const struct simple_node *node;

   201

    int err ;

   202

   203

    // fi is unused

   204

    (void) fi;

   205

   206

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

   207

   208

    // look up the inode

   209

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

   210

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

   211

   212

    // check that it's a dir

   213

    if (node->mode_type != S_IFREG)

   214

        EERROR(err = (node->mode_type == S_IFDIR ? EISDIR : EINVAL), "bad mode");

   215

   216

    // seek past EOF?

   217

    if (off >= strlen(node->data)) {

   218

        // offset is out-of-file, so return EOF

   219

        if ((err = fuse_reply_buf(req, NULL, 0)))

   220

            EERROR(err, "fuse_reply_buf size=0");

   221

   222

    } else {

   223

        // reply with the requested file data

   224

        if ((err = fuse_reply_buf(req, node->data + off, MIN(strlen(node->data) - off, size))))

   225

            EERROR(err, "fuse_reply_buf buf=%p + %zu, size=MIN(%zu, %zu)", node->data, off, strlen(node->data) - off, size);

   226

    }

   227

   228

    // success

   229

    return;

   230

   231

error:

   232

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

   233

        EWARNING(err, "fuse_reply_err");

   234

}

   235

   236

   237

/*

   238

 * Define our fuse_lowlevel_ops struct.

   239

 */

   240

static struct fuse_lowlevel_ops simple_ops = {

   241

    .lookup = simple_lookup,

   242

   243

    .getattr = simple_getattr,

   244

   245

    .readlink = simple_readlink,

   246

   247

    .readdir = simple_readdir,

   248

   249

    .read = simple_read,

   250

};

   251

   252

struct fuse_lowlevel_ops *simple_init () {

   253

    return &simple_ops;

   254

}

   255

   256

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

   257

    struct simple_fs *fs = NULL;

   258

    const struct simple_node *node;

   259

   260

    // generate

   261

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

   262

        ERROR("calloc");

   263

   264

    // remember node_list

   265

    fs->inode_count = 0;

   266

    fs->inode_table = node_list;

   267

   268

    // validate it

   269

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

   270

        // update inode_count

   271

        fs->inode_count++;

   272

   273

        // check that parent is valid

   274

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

   275

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

   276

    }

   277

   278

    // success

   279

    return fs;

   280

   281

error:

   282

    return NULL;

   283

}