/*
 * Copyright 2010, Haiku Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Michael Lotz <mmlr@mlotz.ch>
 */

#include <new>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <errno.h>
#include <dirent.h>

#include <fs_info.h>
#include <fs_interface.h>

#include <debug.h>
#include <KernelExport.h>

#include <io_requests.h>

static const char *kLogFilePrefix = "/var/log/log_overlay";


#define DO_LOG(format, args...) \
        { \
                char _printBuffer[256]; \
                int _printSize = snprintf(_printBuffer, sizeof(_printBuffer), \
                        "%" B_PRId64 " %" B_PRId32 " %p: " format, system_time(), \
                        find_thread(NULL), \
                        ((fs_vnode *)vnode->private_node)->private_node, args); \
                if ((unsigned int)_printSize > sizeof(_printBuffer)) { \
                        _printBuffer[sizeof(_printBuffer) - 1] = '\n'; \
                        _printSize = sizeof(_printBuffer); \
                } \
                write((int)(addr_t)volume->private_volume, _printBuffer, _printSize); \
        }

#define OVERLAY_CALL(op, params...) \
        status_t result = B_UNSUPPORTED; \
        fs_vnode *superVnode = (fs_vnode *)vnode->private_node; \
        if (superVnode->ops->op != NULL) \
                result = superVnode->ops->op(volume->super_volume, superVnode, params);


static status_t
overlay_put_vnode(fs_volume *volume, fs_vnode *vnode, bool reenter)
{
        DO_LOG("put_vnode reenter: %s\n", reenter ? "yes" : "no");

        status_t result = B_UNSUPPORTED;
        fs_vnode *superVnode = (fs_vnode *)vnode->private_node;
        if (superVnode->ops->put_vnode != NULL) {
                result = superVnode->ops->put_vnode(volume->super_volume, superVnode,
                        reenter);
        }

        DO_LOG("put_vnode result: %#" B_PRIx32 "\n", result);
        delete (fs_vnode *)vnode->private_node;
        return result;
}


static status_t
overlay_remove_vnode(fs_volume *volume, fs_vnode *vnode, bool reenter)
{
        DO_LOG("remove_vnode reenter: %s\n", reenter ? "yes" : "no");

        status_t result = B_UNSUPPORTED;
        fs_vnode *superVnode = (fs_vnode *)vnode->private_node;
        if (superVnode->ops->remove_vnode != NULL) {
                result = superVnode->ops->remove_vnode(volume->super_volume, superVnode,
                        reenter);
        }

        DO_LOG("remove_vnode result: %#" B_PRIx32 "\n", result);
        delete (fs_vnode *)vnode->private_node;
        return result;
}


static status_t
overlay_get_super_vnode(fs_volume *volume, fs_vnode *vnode,
        fs_volume *superVolume, fs_vnode *_superVnode)
{
        if (volume == superVolume) {
                *_superVnode = *vnode;
                return B_OK;
        }

        fs_vnode *superVnode = (fs_vnode *)vnode->private_node;
        if (superVnode->ops->get_super_vnode != NULL) {
                return superVnode->ops->get_super_vnode(volume->super_volume,
                        superVnode, superVolume, _superVnode);
        }

        *_superVnode = *superVnode;
        return B_OK;
}


static status_t
overlay_lookup(fs_volume *volume, fs_vnode *vnode, const char *name, ino_t *id)
{
        DO_LOG("lookup name: \"%s\"\n", name);
        OVERLAY_CALL(lookup, name, id)
        DO_LOG("lookup result: %#" B_PRIx32 "; id: %" B_PRIdINO "\n", result, *id);
        return result;
}


static status_t
overlay_get_vnode_name(fs_volume *volume, fs_vnode *vnode, char *buffer,
        size_t bufferSize)
{
        DO_LOG("get_vnode_name buffer: %p; buffer_size: %" B_PRIuSIZE "\n", buffer,
                bufferSize);
        OVERLAY_CALL(get_vnode_name, buffer, bufferSize)
        DO_LOG("get_vnode_name result: %#" B_PRIx32 "; buffer: \"%s\"\n", result,
                result == B_OK ? buffer : "unsafe");
        return result;
}


static bool
overlay_can_page(fs_volume *volume, fs_vnode *vnode, void *cookie)
{
        DO_LOG("can_page cookie: %p\n", cookie);
        bool result = false;
        fs_vnode *superVnode = (fs_vnode *)vnode->private_node;
        if (superVnode->ops->can_page != NULL) {
                result = superVnode->ops->can_page(volume->super_volume, superVnode,
                        cookie);
        }

        DO_LOG("can_page result: %s\n", result ? "yes" : "no");
        return result;
}


static status_t
overlay_read_pages(fs_volume *volume, fs_vnode *vnode, void *cookie, off_t pos,
        const iovec *vecs, size_t count, size_t *numBytes)
{
        DO_LOG("read_pages cookie: %p; pos: %" B_PRIdOFF "; vecs: %p; count: %"
                B_PRIuSIZE "; num_bytes: %" B_PRIuSIZE "\n", cookie, pos, vecs, count,
                *numBytes);
        OVERLAY_CALL(read_pages, cookie, pos, vecs, count, numBytes)
        DO_LOG("read_pages result: %#" B_PRIx32 "; num_bytes: %" B_PRIuSIZE "\n",
                result, *numBytes);
        return result;
}


static status_t
overlay_write_pages(fs_volume *volume, fs_vnode *vnode, void *cookie, off_t pos,
        const iovec *vecs, size_t count, size_t *numBytes)
{
        DO_LOG("write_pages cookie: %p; pos: %" B_PRIdOFF "; vecs: %p; count: %"
                B_PRIuSIZE "; num_bytes: %" B_PRIuSIZE "\n", cookie, pos, vecs, count,
                *numBytes);
        OVERLAY_CALL(write_pages, cookie, pos, vecs, count, numBytes)
        DO_LOG("write_pages result: %#" B_PRIx32 "; num_bytes: %" B_PRIuSIZE "\n",
                result, *numBytes);
        return result;
}


static status_t
overlay_io(fs_volume *volume, fs_vnode *vnode, void *cookie,
        io_request *request)
{
        DO_LOG("io cookie: %p; request: %p (write: %s; offset: %" B_PRIdOFF
                "; length: %" B_PRIdOFF ")\n", cookie, request,
                io_request_is_write(request) ? "yes" : "no", io_request_offset(request),
                io_request_length(request));
        OVERLAY_CALL(io, cookie, request)
        DO_LOG("io result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_cancel_io(fs_volume *volume, fs_vnode *vnode, void *cookie,
        io_request *request)
{
        DO_LOG("cancel_io cookie: %p; request: %p\n", cookie, request);
        OVERLAY_CALL(cancel_io, cookie, request)
        DO_LOG("cancel_io result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_get_file_map(fs_volume *volume, fs_vnode *vnode, off_t offset,
        size_t size, struct file_io_vec *vecs, size_t *count)
{
        DO_LOG("get_file_map offset: %" B_PRIdOFF "; size: %" B_PRIuSIZE
                "; vecs: %p; count: %" B_PRIuSIZE "\n", offset, size, vecs, *count);
        OVERLAY_CALL(get_file_map, offset, size, vecs, count)
        DO_LOG("get_file_map result: %#" B_PRIx32 "; count: %" B_PRIuSIZE "\n",
                result, *count);
        return result;
}


static status_t
overlay_ioctl(fs_volume *volume, fs_vnode *vnode, void *cookie, uint32 op,
        void *buffer, size_t length)
{
        DO_LOG("ioctl cookie: %p; op: %" B_PRIu32 "; buffer: %p; size: %" B_PRIuSIZE
                "\n", cookie, op, buffer, length);
        OVERLAY_CALL(ioctl, cookie, op, buffer, length)
        DO_LOG("ioctl result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_set_flags(fs_volume *volume, fs_vnode *vnode, void *cookie,
        int flags)
{
        DO_LOG("set_flags cookie: %p; flags: %#x\n", cookie, flags);
        OVERLAY_CALL(set_flags, cookie, flags)
        DO_LOG("set_flags result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_select(fs_volume *volume, fs_vnode *vnode, void *cookie, uint8 event,
        selectsync *sync)
{
        DO_LOG("select cookie: %p; event: %" B_PRIu8 "; selectsync: %p\n", cookie,
                event, sync);
        OVERLAY_CALL(select, cookie, event, sync)
        DO_LOG("select result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_deselect(fs_volume *volume, fs_vnode *vnode, void *cookie, uint8 event,
        selectsync *sync)
{
        DO_LOG("deselect cookie: %p; event: %" B_PRIu8 "; selectsync: %p\n", cookie,
                event, sync);
        OVERLAY_CALL(deselect, cookie, event, sync)
        DO_LOG("deselect result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_fsync(fs_volume *volume, fs_vnode *vnode, bool dataOnly)
{
        DO_LOG("%s\n", "fsync");

        status_t result = B_UNSUPPORTED;
        fs_vnode *superVnode = (fs_vnode *)vnode->private_node;
        if (superVnode->ops->fsync != NULL)
                result = superVnode->ops->fsync(volume->super_volume, superVnode, dataOnly);

        DO_LOG("fsync result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_read_symlink(fs_volume *volume, fs_vnode *vnode, char *buffer,
        size_t *bufferSize)
{
        DO_LOG("read_symlink buffer: %p; buffer_size: %" B_PRIuSIZE "\n", buffer,
                *bufferSize);
        OVERLAY_CALL(read_symlink, buffer, bufferSize)
        DO_LOG("read_symlink result: %#" B_PRIx32 "; buffer_size: %" B_PRIuSIZE
                "; \"%.*s\"\n", result, *bufferSize,
                result == B_OK ? (int)*bufferSize : 6,
                result == B_OK ? buffer : "unsafe");
        return result;
}


static status_t
overlay_create_symlink(fs_volume *volume, fs_vnode *vnode, const char *name,
        const char *path, int mode)
{
        DO_LOG("create_symlink name: \"%s\"; path: \"%s\"; mode: %#x\n", name, path,
                mode);
        OVERLAY_CALL(create_symlink, name, path, mode)
        DO_LOG("create_symlink result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_link(fs_volume *volume, fs_vnode *vnode, const char *name,
        fs_vnode *target)
{
        DO_LOG("link name: \"%s\"; target: %p\n", name,
                ((fs_vnode *)target->private_node)->private_node);
        OVERLAY_CALL(link, name, (fs_vnode *)target->private_node)
        DO_LOG("link result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_unlink(fs_volume *volume, fs_vnode *vnode, const char *name)
{
        DO_LOG("unlink name: \"%s\"\n", name);
        OVERLAY_CALL(unlink, name)
        DO_LOG("unlink result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_rename(fs_volume *volume, fs_vnode *vnode,
        const char *fromName, fs_vnode *toDir, const char *toName)
{
        DO_LOG("rename from_name: \"%s\"; to_dir: %p; to_name: \"%s\"\n",
                fromName, ((fs_vnode *)toDir->private_node)->private_node, toName);
        OVERLAY_CALL(rename, fromName, (fs_vnode *)toDir->private_node, toName)
        DO_LOG("rename result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_access(fs_volume *volume, fs_vnode *vnode, int mode)
{
        DO_LOG("access mode: %#x\n", mode);
        OVERLAY_CALL(access, mode)
        DO_LOG("access result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_read_stat(fs_volume *volume, fs_vnode *vnode, struct stat *stat)
{
        DO_LOG("read_stat stat: %p\n", stat);
        OVERLAY_CALL(read_stat, stat)
        if (result == B_OK) {
                DO_LOG("read_stat result: %#" B_PRIx32 "; stat(dev: %" B_PRIdDEV
                        "; ino: %" B_PRIdINO "; mode: %#x; uid: %u; gid %u; size: %"
                        B_PRIdOFF ")\n", result, stat->st_dev, stat->st_ino, stat->st_mode,
                        stat->st_uid, stat->st_gid, stat->st_size);
        } else
                DO_LOG("read_stat result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_write_stat(fs_volume *volume, fs_vnode *vnode, const struct stat *stat,
        uint32 statMask)
{
        DO_LOG("write_stat stat: %p; mask: %" B_PRIu32 "\n", stat, statMask);
        OVERLAY_CALL(write_stat, stat, statMask)
        DO_LOG("write_stat result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_create(fs_volume *volume, fs_vnode *vnode, const char *name,
        int openMode, int perms, void **cookie, ino_t *newVnodeID)
{
        DO_LOG("create name: \"%s\"; open_mode: %#x; perms: %#x\n", name, openMode,
                perms);
        OVERLAY_CALL(create, name, openMode, perms, cookie, newVnodeID)
        DO_LOG("create result: %#" B_PRIx32 "; cookie: %p; new_vnode_id: %"
                B_PRIdINO "\n", result, *cookie, *newVnodeID);
        return result;
}


static status_t
overlay_open(fs_volume *volume, fs_vnode *vnode, int openMode, void **cookie)
{
        DO_LOG("open open_mode: %#x\n", openMode);
        OVERLAY_CALL(open, openMode, cookie)
        DO_LOG("open result: %#" B_PRIx32 "; cookie: %p\n", result, *cookie);
        return result;
}


static status_t
overlay_close(fs_volume *volume, fs_vnode *vnode, void *cookie)
{
        DO_LOG("close cookie %p\n", cookie);
        OVERLAY_CALL(close, cookie)
        DO_LOG("close result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_free_cookie(fs_volume *volume, fs_vnode *vnode, void *cookie)
{
        DO_LOG("free_cookie cookie %p\n", cookie);
        OVERLAY_CALL(free_cookie, cookie)
        DO_LOG("free_cookie result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_read(fs_volume *volume, fs_vnode *vnode, void *cookie, off_t pos,
        void *buffer, size_t *length)
{
        DO_LOG("read cookie: %p; pos: %" B_PRIdOFF "; buffer: %p; length: %"
                B_PRIuSIZE "\n", cookie, pos, buffer, *length);
        OVERLAY_CALL(read, cookie, pos, buffer, length)
        DO_LOG("read result: %#" B_PRIx32 "; length: %" B_PRIuSIZE "\n", result,
                *length);
        return result;
}


static status_t
overlay_write(fs_volume *volume, fs_vnode *vnode, void *cookie, off_t pos,
        const void *buffer, size_t *length)
{
        DO_LOG("write cookie: %p; pos: %" B_PRIdOFF "; buffer: %p; length: %"
                B_PRIuSIZE "\n", cookie, pos, buffer, *length);
        OVERLAY_CALL(write, cookie, pos, buffer, length)
        DO_LOG("write result: %#" B_PRIx32 "; length: %" B_PRIuSIZE "\n", result,
                *length);
        return result;
}


static status_t
overlay_create_dir(fs_volume *volume, fs_vnode *vnode, const char *name,
        int perms)
{
        DO_LOG("create_dir name: \"%s\"; perms: %#x\n", name, perms);
        OVERLAY_CALL(create_dir, name, perms)
        DO_LOG("create_dir result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_remove_dir(fs_volume *volume, fs_vnode *vnode, const char *name)
{
        DO_LOG("remove_dir name: \"%s\"\n", name);
        OVERLAY_CALL(remove_dir, name)
        DO_LOG("remove_dir result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_open_dir(fs_volume *volume, fs_vnode *vnode, void **cookie)
{
        DO_LOG("%s\n", "open_dir");
        OVERLAY_CALL(open_dir, cookie)
        DO_LOG("open_dir result: %#" B_PRIx32 "; cookie: %p\n", result, *cookie);
        return result;
}


static status_t
overlay_close_dir(fs_volume *volume, fs_vnode *vnode, void *cookie)
{
        DO_LOG("close_dir cookie: %p\n", cookie);
        OVERLAY_CALL(close_dir, cookie)
        DO_LOG("close_dir result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_free_dir_cookie(fs_volume *volume, fs_vnode *vnode, void *cookie)
{
        DO_LOG("free_dir_cookie cookie: %p\n", cookie);
        OVERLAY_CALL(free_dir_cookie, cookie)
        DO_LOG("free_dir_cookie result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_read_dir(fs_volume *volume, fs_vnode *vnode, void *cookie,
        struct dirent *buffer, size_t bufferSize, uint32 *num)
{
        DO_LOG("read_dir cookie: %p; buffer: %p; buffer_size: %" B_PRIuSIZE "\n",
                cookie, buffer, bufferSize);
        OVERLAY_CALL(read_dir, cookie, buffer, bufferSize, num);
        DO_LOG("read_dir result: %#" B_PRIx32 "; num: %" B_PRIu32 "\n", result,
                *num);
        return result;
}


static status_t
overlay_rewind_dir(fs_volume *volume, fs_vnode *vnode, void *cookie)
{
        DO_LOG("rewind_dir cookie: %p\n", cookie);
        OVERLAY_CALL(rewind_dir, cookie)
        DO_LOG("rewind_dir result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_open_attr_dir(fs_volume *volume, fs_vnode *vnode, void **cookie)
{
        DO_LOG("%s\n", "open_attr_dir");
        OVERLAY_CALL(open_attr_dir, cookie)
        DO_LOG("open_attr_dir result: %#" B_PRIx32 "; cookie: %p\n", result,
                *cookie);
        return result;
}


static status_t
overlay_close_attr_dir(fs_volume *volume, fs_vnode *vnode, void *cookie)
{
        DO_LOG("close_attr_dir cookie: %p\n", cookie);
        OVERLAY_CALL(close_attr_dir, cookie)
        DO_LOG("close_attr_dir result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_free_attr_dir_cookie(fs_volume *volume, fs_vnode *vnode, void *cookie)
{
        DO_LOG("free_attr_dir_cookie cookie: %p\n", cookie);
        OVERLAY_CALL(free_attr_dir_cookie, cookie)
        DO_LOG("free_attr_dir_cookie result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_read_attr_dir(fs_volume *volume, fs_vnode *vnode, void *cookie,
        struct dirent *buffer, size_t bufferSize, uint32 *num)
{
        DO_LOG("read_attr_dir cookie: %p; buffer: %p; buffer_size: %" B_PRIuSIZE
                "\n", cookie, buffer, bufferSize);
        OVERLAY_CALL(read_attr_dir, cookie, buffer, bufferSize, num);
        DO_LOG("read_attr_dir result: %#" B_PRIx32 "; num: %" B_PRIu32 "\n", result,
                *num);
        return result;
}


static status_t
overlay_rewind_attr_dir(fs_volume *volume, fs_vnode *vnode, void *cookie)
{
        DO_LOG("rewind_attr_dir cookie: %p\n", cookie);
        OVERLAY_CALL(rewind_attr_dir, cookie)
        DO_LOG("rewind_attr_dir result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_create_attr(fs_volume *volume, fs_vnode *vnode, const char *name,
        uint32 type, int openMode, void **cookie)
{
        DO_LOG("create_attr name: \"%s\"; type: %#" B_PRIx32 "; open_mode: %#x\n",
                name, type, openMode);
        OVERLAY_CALL(create_attr, name, type, openMode, cookie)
        DO_LOG("create_attr result: %#" B_PRIx32 "; cookie: %p\n", result, *cookie);
        return result;
}


static status_t
overlay_open_attr(fs_volume *volume, fs_vnode *vnode, const char *name,
        int openMode, void **cookie)
{
        DO_LOG("open_attr name: \"%s\"; open_mode: %#x\n", name, openMode);
        OVERLAY_CALL(open_attr, name, openMode, cookie)
        DO_LOG("open_attr result: %#" B_PRIx32 "; cookie: %p\n", result, *cookie);
        return result;
}


static status_t
overlay_close_attr(fs_volume *volume, fs_vnode *vnode, void *cookie)
{
        DO_LOG("close_attr cookie: %p\n", cookie);
        OVERLAY_CALL(close_attr, cookie)
        DO_LOG("close_attr result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_free_attr_cookie(fs_volume *volume, fs_vnode *vnode, void *cookie)
{
        DO_LOG("free_attr_cookie cookie: %p\n", cookie);
        OVERLAY_CALL(free_attr_cookie, cookie)
        DO_LOG("free_attr_cookie result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_read_attr(fs_volume *volume, fs_vnode *vnode, void *cookie, off_t pos,
        void *buffer, size_t *length)
{
        DO_LOG("read_attr cookie: %p; pos: %" B_PRIdOFF "; buffer: %p; length: %"
                B_PRIuSIZE "\n", cookie, pos, buffer, *length);
        OVERLAY_CALL(read_attr, cookie, pos, buffer, length)
        DO_LOG("read_attr result: %#" B_PRIx32 "; length: %" B_PRIuSIZE "\n",
                result, *length);
        return result;
}


static status_t
overlay_write_attr(fs_volume *volume, fs_vnode *vnode, void *cookie, off_t pos,
        const void *buffer, size_t *length)
{
        DO_LOG("write_attr cookie: %p; pos: %" B_PRIdOFF "; buffer: %p; length: %"
                B_PRIuSIZE "\n", cookie, pos, buffer, *length);
        OVERLAY_CALL(write_attr, cookie, pos, buffer, length)
        DO_LOG("write_attr result: %#" B_PRIx32 "; length: %" B_PRIuSIZE "\n",
                result, *length);
        return result;
}


static status_t
overlay_read_attr_stat(fs_volume *volume, fs_vnode *vnode, void *cookie,
        struct stat *stat)
{
        DO_LOG("read_attr_stat cookie: %p; stat: %p\n", cookie, stat);
        OVERLAY_CALL(read_attr_stat, cookie, stat)
        if (result == B_OK) {
                DO_LOG("read_attr_stat result: %#" B_PRIx32 "; stat(dev: %" B_PRIdDEV
                        "; ino: %" B_PRIdINO "; mode: %#x; uid: %u; gid %u; size: %"
                        B_PRIdOFF "; type: %#" B_PRIx32 ")\n", result,
                        stat->st_dev, stat->st_ino, stat->st_mode, stat->st_uid,
                        stat->st_gid, stat->st_size, stat->st_type);
        } else
                DO_LOG("read_attr_stat result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_write_attr_stat(fs_volume *volume, fs_vnode *vnode, void *cookie,
        const struct stat *stat, int statMask)
{
        DO_LOG("write_attr_stat cookie: %p; stat: %p; mask: %#x\n", cookie, stat,
                statMask);
        OVERLAY_CALL(write_attr_stat, cookie, stat, statMask)
        DO_LOG("write_attr_stat result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_rename_attr(fs_volume *volume, fs_vnode *vnode,
        const char *fromName, fs_vnode *toVnode, const char *toName)
{
        DO_LOG("rename_attr from_name: \"%s\"; to_vnode: %p; to_name: \"%s\"\n",
                fromName, ((fs_vnode *)toVnode->private_node)->private_node, toName);
        OVERLAY_CALL(rename_attr, fromName, (fs_vnode *)toVnode->private_node,
                toName)
        DO_LOG("rename_attr result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_remove_attr(fs_volume *volume, fs_vnode *vnode, const char *name)
{
        DO_LOG("remove_attr name: \"%s\"\n", name);
        OVERLAY_CALL(remove_attr, name)
        DO_LOG("remove_attr result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_create_special_node(fs_volume *volume, fs_vnode *vnode,
        const char *name, fs_vnode *subVnode, mode_t mode, uint32 flags,
        fs_vnode *_superVnode, ino_t *nodeID)
{
        DO_LOG("create_special_node name: \"%s\"; sub_vnode: %p; mode: %#x;"
                " flags: %" B_PRIu32 "\n", name, subVnode->private_node, mode, flags);
        OVERLAY_CALL(create_special_node, name, (fs_vnode *)subVnode->private_node,
                mode, flags, _superVnode, nodeID)
        DO_LOG("create_special_node result: %#" B_PRIx32 "; super_vnode: %p;"
                " node_id: %" B_PRIdINO "\n", result, _superVnode->private_node,
                *nodeID);
        return result;
}


static fs_vnode_ops sOverlayVnodeOps = {
        &overlay_lookup,
        &overlay_get_vnode_name,

        &overlay_put_vnode,
        &overlay_remove_vnode,

        &overlay_can_page,
        &overlay_read_pages,
        &overlay_write_pages,

        &overlay_io,
        &overlay_cancel_io,

        &overlay_get_file_map,

        /* common */
        &overlay_ioctl,
        &overlay_set_flags,
        &overlay_select,
        &overlay_deselect,
        &overlay_fsync,

        &overlay_read_symlink,
        &overlay_create_symlink,
        &overlay_link,
        &overlay_unlink,
        &overlay_rename,

        &overlay_access,
        &overlay_read_stat,
        &overlay_write_stat,
        NULL,   // fs_preallocate

        /* file */
        &overlay_create,
        &overlay_open,
        &overlay_close,
        &overlay_free_cookie,
        &overlay_read,
        &overlay_write,

        /* directory */
        &overlay_create_dir,
        &overlay_remove_dir,
        &overlay_open_dir,
        &overlay_close_dir,
        &overlay_free_dir_cookie,
        &overlay_read_dir,
        &overlay_rewind_dir,

        /* attribute directory operations */
        &overlay_open_attr_dir,
        &overlay_close_attr_dir,
        &overlay_free_attr_dir_cookie,
        &overlay_read_attr_dir,
        &overlay_rewind_attr_dir,

        /* attribute operations */
        &overlay_create_attr,
        &overlay_open_attr,
        &overlay_close_attr,
        &overlay_free_attr_cookie,
        &overlay_read_attr,
        &overlay_write_attr,

        &overlay_read_attr_stat,
        &overlay_write_attr_stat,
        &overlay_rename_attr,
        &overlay_remove_attr,

        /* support for node and FS layers */
        &overlay_create_special_node,
        &overlay_get_super_vnode
};


//      #pragma mark - volume ops


#define DO_VOLUME_LOG(format, args...) \
        { \
                char _printBuffer[256]; \
                int _printSize = snprintf(_printBuffer, sizeof(_printBuffer), \
                        "%" B_PRId64 " %" B_PRId32 " %p: " format, system_time(), \
                        find_thread(NULL), volume->super_volume, args); \
                if ((unsigned int)_printSize > sizeof(_printBuffer)) { \
                        _printBuffer[sizeof(_printBuffer) - 1] = '\n'; \
                        _printSize = sizeof(_printBuffer); \
                } \
                write((int)(addr_t)volume->private_volume, _printBuffer, _printSize); \
        }

#define OVERLAY_VOLUME_CALL(op, params...) \
        status_t result = B_UNSUPPORTED; \
        if (volume->super_volume->ops->op != NULL) \
                result = volume->super_volume->ops->op(volume->super_volume, params);


static status_t
overlay_unmount(fs_volume *volume)
{
        if (volume->super_volume != NULL
                && volume->super_volume->ops != NULL
                && volume->super_volume->ops->unmount != NULL)
                volume->super_volume->ops->unmount(volume->super_volume);

        close((int)(addr_t)volume->private_volume);
        return B_OK;
}


static status_t
overlay_read_fs_info(fs_volume *volume, struct fs_info *info)
{
        DO_VOLUME_LOG("%s\n", "read_fs_info");
        OVERLAY_VOLUME_CALL(read_fs_info, info)
        DO_VOLUME_LOG("read_fs_info result: %#" B_PRIx32 "; info(dev: %" B_PRIdDEV
                "; root: %" B_PRIdINO "; flags: %#" B_PRIx32 "; block_size: %" B_PRIdOFF
                "; io_size: %" B_PRIdOFF "; total_blocks: %" B_PRIdOFF
                "; free_blocks: %" B_PRIdOFF "; total_nodes: %" B_PRIdOFF
                "; free_nodes: %" B_PRIdOFF "; device_name: \"%s\"; volume_name: \"%s\""
                "; fsh_name: \"%s\")\n", result, info->dev, info->root, info->flags,
                info->block_size, info->io_size, info->total_blocks, info->free_blocks,
                info->total_nodes, info->free_nodes, info->device_name,
                info->volume_name, info->fsh_name);
        return result;
}


static status_t
overlay_write_fs_info(fs_volume *volume, const struct fs_info *info,
        uint32 mask)
{
        DO_VOLUME_LOG("write_fs_info info: %p; mask: %#" B_PRIx32 "\n", info, mask);
        OVERLAY_VOLUME_CALL(write_fs_info, info, mask)
        DO_VOLUME_LOG("write_fs_info result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_sync(fs_volume *volume)
{
        DO_VOLUME_LOG("%s\n", "sync");
        status_t result = B_UNSUPPORTED;
        if (volume->super_volume->ops->sync != NULL)
                result = volume->super_volume->ops->sync(volume->super_volume);
        DO_VOLUME_LOG("sync result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_get_vnode(fs_volume *volume, ino_t id, fs_vnode *vnode, int *type,
        uint32 *flags, bool reenter)
{
        DO_VOLUME_LOG("get_vnode id: %" B_PRIdINO "; vnode: %p; type*: %p;"
                " flags*: %p; reenter: %s\n", id, vnode, type, flags,
                reenter ? "yes" : "no");

        if (volume->super_volume->ops->get_vnode == NULL) {
                DO_VOLUME_LOG("get_vnode %s\n", "not supported");
                return B_UNSUPPORTED;
        }

        fs_vnode *superVnode = new(std::nothrow) fs_vnode;
        if (superVnode == NULL) {
                DO_VOLUME_LOG("get_vnode %s\n", "no memory");
                return B_NO_MEMORY;
        }

        status_t result = volume->super_volume->ops->get_vnode(volume->super_volume,
                id, superVnode, type, flags, reenter);
        if (result != B_OK) {
                DO_VOLUME_LOG("get_vnode result: %#" B_PRIx32 "\n", result);
                delete superVnode;
                return result;
        }

        vnode->private_node = superVnode;
        vnode->ops = &sOverlayVnodeOps;

        DO_VOLUME_LOG("get_vnode result: %#" B_PRIx32 "; super_vnode: %p\n", result,
                superVnode->private_node);
        return B_OK;
}


static status_t
overlay_open_index_dir(fs_volume *volume, void **cookie)
{
        DO_VOLUME_LOG("%s\n", "open_index_dir");
        OVERLAY_VOLUME_CALL(open_index_dir, cookie)
        DO_VOLUME_LOG("open_index_dir result: %#" B_PRIx32 "; cookie: %p\n", result,
                *cookie);
        return result;
}


static status_t
overlay_close_index_dir(fs_volume *volume, void *cookie)
{
        DO_VOLUME_LOG("close_index_dir cookie: %p\n", cookie);
        OVERLAY_VOLUME_CALL(close_index_dir, cookie)
        DO_VOLUME_LOG("close_index_dir result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_free_index_dir_cookie(fs_volume *volume, void *cookie)
{
        DO_VOLUME_LOG("free_index_dir_cookie cookie: %p\n", cookie);
        OVERLAY_VOLUME_CALL(free_index_dir_cookie, cookie)
        DO_VOLUME_LOG("free_index_dir_cookie result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_read_index_dir(fs_volume *volume, void *cookie, struct dirent *buffer,
        size_t bufferSize, uint32 *num)
{
        DO_VOLUME_LOG("read_index_dir cookie: %p; buffer: %p; buffer_size: %"
                B_PRIuSIZE "\n", cookie, buffer, bufferSize);
        OVERLAY_VOLUME_CALL(read_index_dir, cookie, buffer, bufferSize, num)
        DO_VOLUME_LOG("read_index_dir result: %#" B_PRIx32 "; num: %" B_PRIu32 "\n",
                result, *num);
        return result;
}


static status_t
overlay_rewind_index_dir(fs_volume *volume, void *cookie)
{
        DO_VOLUME_LOG("rewind_index_dir cookie: %p\n", cookie);
        OVERLAY_VOLUME_CALL(rewind_index_dir, cookie)
        DO_VOLUME_LOG("rewind_index_dir result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_create_index(fs_volume *volume, const char *name, uint32 type,
        uint32 flags)
{
        DO_VOLUME_LOG("create_index name: \"%s\"; type: %#" B_PRIx32
                "; flags: %#" B_PRIx32 "\n", name, type, flags);
        OVERLAY_VOLUME_CALL(create_index, name, type, flags)
        DO_VOLUME_LOG("create_index result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_remove_index(fs_volume *volume, const char *name)
{
        DO_VOLUME_LOG("remove_index name: \"%s\"\n", name);
        OVERLAY_VOLUME_CALL(remove_index, name)
        DO_VOLUME_LOG("remove_index result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_read_index_stat(fs_volume *volume, const char *name, struct stat *stat)
{
        DO_VOLUME_LOG("read_index_stat name: \"%s\"; stat: %p\n", name, stat);
        OVERLAY_VOLUME_CALL(read_index_stat, name, stat)
        if (result == B_OK) {
                DO_VOLUME_LOG("read_index_stat result: %#" B_PRIx32 "; stat(dev: %"
                        B_PRIdDEV "; ino: %" B_PRIdINO "; mode: %#x; uid: %u; gid %u;"
                        " size: %" B_PRIdOFF "; type: %#" B_PRIx32 ")\n", result,
                        stat->st_dev, stat->st_ino, stat->st_mode, stat->st_uid,
                        stat->st_gid, stat->st_size, stat->st_type);
        } else
                DO_VOLUME_LOG("read_index_stat result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_open_query(fs_volume *volume, const char *query, uint32 flags,
        port_id port, uint32 token, void **cookie)
{
        DO_VOLUME_LOG("open_query query: \"%s\"; flags: %#" B_PRIx32 "; port: %"
                B_PRId32 "; token: %" B_PRIu32 "\n", query, flags, port, token);
        OVERLAY_VOLUME_CALL(open_query, query, flags, port, token, cookie)
        DO_VOLUME_LOG("open_query result: %#" B_PRIx32 "; cookie: %p\n", result,
                *cookie);
        return result;
}


static status_t
overlay_close_query(fs_volume *volume, void *cookie)
{
        DO_VOLUME_LOG("close_query cookie: %p\n", cookie);
        OVERLAY_VOLUME_CALL(close_query, cookie)
        DO_VOLUME_LOG("close_query result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_free_query_cookie(fs_volume *volume, void *cookie)
{
        DO_VOLUME_LOG("free_query_cookie cookie: %p\n", cookie);
        OVERLAY_VOLUME_CALL(free_query_cookie, cookie)
        DO_VOLUME_LOG("free_query_cookie result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_read_query(fs_volume *volume, void *cookie, struct dirent *buffer,
        size_t bufferSize, uint32 *num)
{
        DO_VOLUME_LOG("read_query cookie: %p; buffer: %p; buffer_size: %"
                B_PRIuSIZE "\n", cookie, buffer, bufferSize);
        OVERLAY_VOLUME_CALL(read_query, cookie, buffer, bufferSize, num)
        DO_VOLUME_LOG("read_query result: %#" B_PRIx32 "; num: %" B_PRIu32 "\n",
                result, *num);
        return result;
}


static status_t
overlay_rewind_query(fs_volume *volume, void *cookie)
{
        DO_VOLUME_LOG("rewind_query cookie: %p\n", cookie);
        OVERLAY_VOLUME_CALL(rewind_query, cookie)
        DO_VOLUME_LOG("rewind_query result: %#" B_PRIx32 "\n", result);
        return result;
}


static status_t
overlay_all_layers_mounted(fs_volume *volume)
{
        return B_OK;
}


static status_t
overlay_create_sub_vnode(fs_volume *volume, ino_t id, fs_vnode *vnode)
{
        fs_vnode *superVnode = new(std::nothrow) fs_vnode;
        if (superVnode == NULL)
                return B_NO_MEMORY;

        *superVnode = *vnode;
        vnode->private_node = superVnode;
        vnode->ops = &sOverlayVnodeOps;
        return B_OK;
}


static status_t
overlay_delete_sub_vnode(fs_volume *volume, fs_vnode *vnode)
{
        delete (fs_vnode *)vnode->private_node;
        return B_OK;
}


static fs_volume_ops sOverlayVolumeOps = {
        &overlay_unmount,

        &overlay_read_fs_info,
        &overlay_write_fs_info,
        &overlay_sync,

        &overlay_get_vnode,
        &overlay_open_index_dir,
        &overlay_close_index_dir,
        &overlay_free_index_dir_cookie,
        &overlay_read_index_dir,
        &overlay_rewind_index_dir,

        &overlay_create_index,
        &overlay_remove_index,
        &overlay_read_index_stat,

        &overlay_open_query,
        &overlay_close_query,
        &overlay_free_query_cookie,
        &overlay_read_query,
        &overlay_rewind_query,

        &overlay_all_layers_mounted,
        &overlay_create_sub_vnode,
        &overlay_delete_sub_vnode
};


//      #pragma mark - filesystem module


static status_t
overlay_mount(fs_volume *volume, const char *device, uint32 flags,
        const char *args, ino_t *rootID)
{
        if (volume->super_volume == NULL)
                return B_UNSUPPORTED;

        char filename[256];
        snprintf(filename, sizeof(filename), "%s%s", kLogFilePrefix, device);
        filename[sizeof(filename) - 1] = 0;

        int filenameLength = strlen(filename);
        for (int i = strlen(kLogFilePrefix); i < filenameLength; i++) {
                if (filename[i] == '/')
                        filename[i] = '_';
        }

        int fd = creat(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
        if (fd < 0)
                return errno;

        volume->private_volume = (void *)(addr_t)fd;
        volume->ops = &sOverlayVolumeOps;
        return B_OK;
}


static status_t
overlay_std_ops(int32 op, ...)
{
        switch (op) {
                case B_MODULE_INIT:
                case B_MODULE_UNINIT:
                        return B_OK;
                default:
                        return B_ERROR;
        }
}


static file_system_module_info sOverlayFileSystem = {
        {
                "file_systems/log_overlay" B_CURRENT_FS_API_VERSION,
                0,
                overlay_std_ops,
        },

        "log_overlay",                                          // short_name
        "Logging Overlay File System",          // pretty_name
        0,                                                                      // DDM flags

        // scanning
        NULL, // identify_partition
        NULL, // scan_partition
        NULL, // free_identify_partition_cookie
        NULL, // free_partition_content_cookie

        // general operations
        &overlay_mount,

        // capability querying
        NULL, // get_supported_operations

        NULL, // validate_resize
        NULL, // validate_move
        NULL, // validate_set_content_name
        NULL, // validate_set_content_parameters
        NULL, // validate_initialize

        // shadow partition modification
        NULL, // shadow_changed

        // writing
        NULL, // defragment
        NULL, // repair
        NULL, // resize
        NULL, // move
        NULL, // set_content_name
        NULL, // set_content_parameters
        NULL // initialize
};

module_info *modules[] = {
        (module_info *)&sOverlayFileSystem,
        NULL,
};