/*
 * Copyright 2010, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include <dirent.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>

#include <new>

#include <fs_interface.h>
#include <io_requests.h>
#include <NodeMonitor.h>

#include <AutoDeleter.h>
#include <AutoLocker.h>

#include <debug.h>
#include <util/AutoLock.h>

#include "checksumfs.h"
#include "checksumfs_private.h"
#include "DebugSupport.h"
#include "Directory.h"
#include "File.h"
#include "Notifications.h"
#include "SuperBlock.h"
#include "SymLink.h"
#include "Transaction.h"
#include "Volume.h"


static const char* const kCheckSumFSModuleName  = "file_systems/checksumfs"
        B_CURRENT_FS_API_VERSION;
static const char* const kCheckSumFSShortName   = "checksumfs";

static const bigtime_t kModifiedInterimUpdateInterval = 500000;
        // wait at least 0.5s between interim modified updates


// #pragma mark -


struct FileCookie {
        mutex           lock;
        int                     openMode;
        bigtime_t       lastModifiedUpdate;
        bool            modifiedNeedsUpdate;
        bool            sizeChangedSinceUpdate;
        bool            modifiedNeedsFinalUpdate;
        bool            finalSizeChanged;


        FileCookie(int openMode)
                :
                openMode(openMode),
                lastModifiedUpdate(0),
                modifiedNeedsUpdate(false),
                sizeChangedSinceUpdate(false),
                modifiedNeedsFinalUpdate(false),
                finalSizeChanged(false)
        {
                mutex_init(&lock, "checksumfs file cookie");
        }

        ~FileCookie()
        {
                mutex_destroy(&lock);
        }

        status_t UpdateModifiedIfNecessary(Node* node, bool finalUpdate)
        {
                MutexLocker locker(lock);

                return _UpdateModifiedIfNecessary(node, finalUpdate);
        }

        status_t FileModified(Node* node, bool sizeChanged)
        {
                MutexLocker locker(lock);

                modifiedNeedsUpdate = true;
                modifiedNeedsFinalUpdate = true;
                sizeChangedSinceUpdate |= sizeChanged;
                finalSizeChanged |= sizeChanged;

                return _UpdateModifiedIfNecessary(node, false);
        }

private:
        status_t _UpdateModifiedIfNecessary(Node* node, bool finalUpdate)
        {
                uint32 statFlags = B_STAT_MODIFICATION_TIME | B_STAT_CHANGE_TIME;

                if (finalUpdate) {
                        if (!modifiedNeedsFinalUpdate)
                                return B_OK;
                        if (finalSizeChanged)
                                statFlags |= B_STAT_SIZE;
                } else {
                        if (!modifiedNeedsUpdate)
                                return B_OK;

                        if (system_time()
                                        < lastModifiedUpdate + kModifiedInterimUpdateInterval) {
                                // not enough time passed -- postpone update
                                return B_OK;
                        }

                        statFlags |= B_STAT_INTERIM_UPDATE
                                | (sizeChangedSinceUpdate ? B_STAT_SIZE : 0);
                }

                // do the update -- start a transaction, lock the node, and update
                Transaction transaction(node->GetVolume());
                status_t error = transaction.StartAndAddNode(node);
                if (error != B_OK)
                        return error;

                node->Touched(NODE_MODIFIED);

                error = transaction.Commit(StatChangedNotification(node, statFlags));
                if (error != B_OK)
                        return error;

                modifiedNeedsUpdate = false;
                lastModifiedUpdate = system_time();

                return B_OK;
        }
};


struct DirCookie {
        DirCookie(Directory* directory)
                :
                fDirectory(directory)
        {
                Rewind();
        }

        Directory* GetDirectory() const
        {
                return fDirectory;
        }

        void SetTo(Directory* directory, bool skipArtificialEntries)
        {
                fDirectory = directory;
                Rewind(skipArtificialEntries);
        }

        status_t ReadNextEntry(struct dirent* buffer, size_t size,
                uint32& _countRead)
        {
                const char* name;
                size_t nameLength;
                uint64 blockIndex;

                int nextIterationState = OTHERS;
                switch (fIterationState) {
                        case DOT:
                                name = ".";
                                nameLength = 1;
                                blockIndex = fDirectory->BlockIndex();
                                nextIterationState = DOT_DOT;
                                break;
                        case DOT_DOT:
                                name = "..";
                                nameLength = 2;
                                blockIndex = fDirectory->ParentDirectory();
                                break;
                        default:
                        {
                                status_t error = fDirectory->LookupNextEntry(fEntryName,
                                        fEntryName, nameLength, blockIndex);
                                if (error != B_OK) {
                                        if (error != B_ENTRY_NOT_FOUND)
                                                return error;

                                        _countRead = 0;
                                        return B_OK;
                                }

                                name = fEntryName;
                                break;
                        }
                }

                size_t entrySize = sizeof(dirent) + nameLength + 1;
                if (entrySize > size)
                        return B_BUFFER_OVERFLOW;

                buffer->d_dev = fDirectory->GetVolume()->ID();
                buffer->d_ino = blockIndex;
                buffer->d_reclen = entrySize;
                strcpy(buffer->d_name, name);

                fIterationState = nextIterationState;

                _countRead = 1;
                return B_OK;
        }

        void Rewind(bool skipArtificialEntries = false)
        {
                fIterationState = skipArtificialEntries ? OTHERS : DOT;
                fEntryName[0] = '\0';
        }

private:
        enum {
                DOT,
                DOT_DOT,
                OTHERS
        };

        Directory*      fDirectory;
        int                     fIterationState;
        char            fEntryName[kCheckSumFSNameLength + 1];
};


struct AttrDirCookie {
        AttrDirCookie(Node* node)
                :
                fNode(node),
                fAttributeDirectory(NULL),
                fDirCookie(NULL)
        {
        }

        ~AttrDirCookie()
        {
                if (fAttributeDirectory != NULL)
                        fNode->GetVolume()->PutNode(fAttributeDirectory);
        }

        status_t ReadNextEntry(struct dirent* buffer, size_t size,
                uint32& _countRead)
        {
                status_t error = _UpdateAttributeDirectory();
                if (error != B_OK)
                        RETURN_ERROR(error);

                if (fAttributeDirectory == NULL) {
                        _countRead = 0;
                        return B_OK;
                }

                return fDirCookie.ReadNextEntry(buffer, size, _countRead);
        }

        void Rewind()
        {
                fDirCookie.Rewind(true);
        }

private:
        status_t _UpdateAttributeDirectory()
        {
                uint64 blockIndex = fNode->AttributeDirectory();
                if (blockIndex == 0) {
                        // no (empty) attribute directory
                        if (fAttributeDirectory != NULL) {
                                fNode->GetVolume()->PutNode(fAttributeDirectory);
                                fAttributeDirectory = NULL;
                        }

                        return B_OK;
                }

                if (fAttributeDirectory != NULL) {
                        if (blockIndex == fAttributeDirectory->BlockIndex())
                                return B_OK;

                        // The attribute directory has changed in the meantime -- get rid
                        // of the old one.
                        fNode->GetVolume()->PutNode(fAttributeDirectory);
                        fAttributeDirectory = NULL;
                }

                // get the attribute directory node
                Node* node;
                status_t error = fNode->GetVolume()->GetNode(blockIndex, node);
                if (error != B_OK)
                        RETURN_ERROR(error);

                fAttributeDirectory = dynamic_cast<Directory*>(node);
                if (fAttributeDirectory == NULL) {
                        fNode->GetVolume()->PutNode(node);
                        ERROR("checksumfs: attribute directory (%" B_PRIu64 ") of node %"
                                B_PRIu64 " is not a directory!\n", blockIndex,
                                fNode->BlockIndex());
                        RETURN_ERROR(B_BAD_DATA);
                }

                fDirCookie.SetTo(fAttributeDirectory, true);

                return B_OK;
        }

private:
        Node*           fNode;
        Directory*      fAttributeDirectory;
        DirCookie       fDirCookie;
};


struct AttributeCookie {
        char*           name;
        Node*           attribute;
        FileCookie*     fileCookie;

        AttributeCookie(const char* name)
                :
                name(strdup(name)),
                attribute(NULL),
                fileCookie(NULL)
        {
        }

        ~AttributeCookie()
        {
                if (attribute != NULL)
                        attribute->GetVolume()->PutNode(attribute);
                delete fileCookie;
                free(name);
        }
};


// #pragma mark -


static void
set_timespec(timespec& time, uint64 nanos)
{
        time.tv_sec = nanos / 1000000000;
        time.tv_nsec = nanos % 1000000000;
}


static uint64
timespec_to_nsecs(const timespec& time)
{
        return (uint64)time.tv_sec * 1000000000 + time.tv_nsec;
}


struct PutNode {
        inline void operator()(Node* node)
        {
                if (node != NULL)
                        node->GetVolume()->PutNode(node);
        }
};

typedef BPrivate::AutoDeleter<Node, PutNode> NodePutter;


static bool
is_user_in_group(gid_t gid)
{
        gid_t groups[NGROUPS_MAX];
        int groupCount = getgroups(NGROUPS_MAX, groups);
        for (int i = 0; i < groupCount; i++) {
                if (gid == groups[i])
                        return true;
        }

        return gid == getegid();
}


static status_t
check_access(Node* node, uint32 accessFlags)
{
        // Note: we assume that the access flags are compatible with the permission
        // bits.
        STATIC_ASSERT(R_OK == S_IROTH && W_OK == S_IWOTH && X_OK == S_IXOTH);

        // get node permissions
        int userPermissions = (node->Mode() & S_IRWXU) >> 6;
        int groupPermissions = (node->Mode() & S_IRWXG) >> 3;
        int otherPermissions = node->Mode() & S_IRWXO;

        // get the permissions for this uid/gid
        int permissions = 0;
        uid_t uid = geteuid();

        if (uid == 0) {
                // user is root
                // root has always read/write permission, but at least one of the
                // X bits must be set for execute permission
                permissions = userPermissions | groupPermissions | otherPermissions
                        | R_OK | W_OK;
        } else if (uid == node->UID()) {
                // user is node owner
                permissions = userPermissions;
        } else if (is_user_in_group(node->GID())) {
                // user is in owning group
                permissions = groupPermissions;
        } else {
                // user is one of the others
                permissions = otherPermissions;
        }

        return (accessFlags & ~permissions) == 0 ? B_OK : B_NOT_ALLOWED;
}


static status_t
remove_entry(fs_volume* fsVolume, fs_vnode* parent, const char* name,
        bool removeDirectory)
{
        Volume* volume = (Volume*)fsVolume->private_volume;
        Directory* directory
                = dynamic_cast<Directory*>((Node*)parent->private_node);
        if (directory == NULL)
                return B_NOT_A_DIRECTORY;

        if (volume->IsReadOnly())
                return B_READ_ONLY_DEVICE;

        // Since we need to lock both nodes (the directory and the entry's), this
        // is a bit cumbersome. We first look up the entry while having the
        // directory read-locked, then drop the read lock, write-lock both nodes
        // and check whether anything has changed.
        Transaction transaction(volume);
        Node* childNode;
        NodePutter childNodePutter;

        while (true) {
                // look up the entry
                NodeReadLocker directoryLocker(directory);

                uint64 blockIndex;
                status_t error = directory->LookupEntry(name, blockIndex);
                if (error != B_OK)
                        RETURN_ERROR(error);

                directoryLocker.Unlock();

                // get the entry's node
                error = volume->GetNode(blockIndex, childNode);
                if (error != B_OK)
                        RETURN_ERROR(error);
                childNodePutter.SetTo(childNode);

                // start the transaction
                error = transaction.Start();
                if (error != B_OK)
                        RETURN_ERROR(error);

                // write-lock the nodes
                error = transaction.AddNodes(directory, childNode);
                if (error != B_OK)
                        RETURN_ERROR(error);

                // check the situation again
                error = directory->LookupEntry(name, blockIndex);
                if (error != B_OK)
                        RETURN_ERROR(error);
                if (blockIndex != childNode->BlockIndex()) {
                        transaction.Abort();
                        continue;
                }

                break;
        }

        // check permissions
        status_t error = check_access(directory, W_OK);
        if (error != B_OK)
                return error;

        // check whether the child node type agrees with our caller
        if (removeDirectory) {
                if (!S_ISDIR(childNode->Mode()))
                        RETURN_ERROR(B_NOT_A_DIRECTORY);

                // directory must be empty
                if (childNode->Size() > 0)
                        RETURN_ERROR(B_DIRECTORY_NOT_EMPTY);
        } else if (S_ISDIR(childNode->Mode()))
                RETURN_ERROR(B_IS_A_DIRECTORY);

        // remove the entry
        error = directory->RemoveEntry(name, transaction);
        if (error != B_OK)
                RETURN_ERROR(error);

        // update stat data
        childNode->SetHardLinks(childNode->HardLinks() - 1);

        directory->Touched(NODE_MODIFIED);

        // remove the child node, if no longer referenced
        if (childNode->HardLinks() == 0) {
                error = volume->RemoveNode(childNode);
                if (error != B_OK)
                        return error;
        }

        // commit the transaction
        return transaction.Commit(EntryRemovedNotification(directory, name,
                childNode));
}


/*!     Opens the node according to the given open mode (if the permissions allow
        that) and creates a file cookie.
*/
static status_t
open_file(Volume* volume, Node* node, int openMode, Transaction& transaction,
        bool commitTransaction, FileCookie*& _cookie)
{
        // translate the open mode to required permissions
        uint32 accessFlags = 0;
        switch (openMode & O_RWMASK) {
                case O_RDONLY:
                        accessFlags = R_OK;
                        break;
                case O_WRONLY:
                        accessFlags = W_OK;
                        break;
                case O_RDWR:
                        accessFlags = R_OK | W_OK;
                        break;
        }

        // We need to at least read-lock the node. If O_TRUNC is specified, we even
        // need a write lock and a transaction.
        NodeReadLocker nodeReadLocker;

        if ((openMode & O_TRUNC) != 0) {
                accessFlags |= W_OK;

                status_t error = transaction.IsActive()
                        ? transaction.AddNode(node) : transaction.StartAndAddNode(node);
                if (error != B_OK)
                        RETURN_ERROR(error);
        } else if (!transaction.IsNodeLocked(node))
                nodeReadLocker.SetTo(node, false);

        // check permissions
        if ((accessFlags & W_OK) != 0) {
                if (volume->IsReadOnly())
                        return B_READ_ONLY_DEVICE;
                if (S_ISDIR(node->Mode()))
                        return B_IS_A_DIRECTORY;
        }

        status_t error = check_access(node, accessFlags);
        if (error != B_OK)
                return error;

        // TODO: Support O_NOCACHE.

        FileCookie* cookie = new(std::nothrow) FileCookie(openMode);
        if (cookie == NULL)
                return B_NO_MEMORY;
        ObjectDeleter<FileCookie> cookieDeleter(cookie);

        // truncate the file, if requested
        if ((openMode & O_TRUNC) != 0 && node->Size() > 0) {
                error = node->Resize(0, false, transaction);
                if (error != B_OK)
                        return error;

                node->Touched(NODE_MODIFIED);

                if (commitTransaction) {
                        uint32 statFlags = B_STAT_MODIFICATION_TIME | B_STAT_CHANGE_TIME
                                | B_STAT_SIZE;
                        error = transaction.Commit(StatChangedNotification(node,
                                statFlags));
                        if (error != B_OK)
                                return error;
                }
        }

        _cookie = cookieDeleter.Detach();
        return B_OK;
}


static status_t
create_file(Volume* volume, Directory* directory, const char* name,
        int openMode, int permissions, Transaction& transaction,
        bool commitTransaction, FileCookie*& _cookie, Node*& _node, bool& _created)
{
        Node* childNode = NULL;
        NodePutter childNodePutter;

        // Start the transaction and add the directory. We only need a read lock
        // for the lookup, but later we'll need a write lock, if we have to create
        // the file. So this is simpler.
        status_t error = B_OK;
        bool directoryLocked = false;
        if (transaction.IsActive()) {
                directoryLocked = transaction.IsNodeLocked(directory);
                if (!directoryLocked)
                        error = transaction.AddNode(directory);
        } else
                error = transaction.StartAndAddNode(directory);
        if (error != B_OK)
                RETURN_ERROR(error);

        // look up the entry
        uint64 blockIndex;
        error = directory->LookupEntry(name, blockIndex);
        if (error == B_OK) {
                // the entry already exists
                if ((openMode & O_EXCL) != 0)
                        return B_FILE_EXISTS;

                // get the entry's node
                error = volume->GetNode(blockIndex, childNode);
                if (error != B_OK)
                        RETURN_ERROR(error);
                childNodePutter.SetTo(childNode);

                // We can (must even) unlock the directory now. The file won't go
                // anywhere, since a transaction is already running.
                if (!directoryLocked)
                        transaction.RemoveNode(directory);

                error = open_file(volume, childNode, openMode, transaction,
                        commitTransaction, _cookie);
                if (error != B_OK)
                        RETURN_ERROR(error);

                childNodePutter.Detach();
                _node = childNode;
                _created = false;
                return B_OK;
        }

        if (error != B_ENTRY_NOT_FOUND)
                RETURN_ERROR(error);

        // The entry doesn't exist yet. We have to create a new file.

        // check the directory write permission
        error = check_access(directory, W_OK);
        if (error != B_OK)
                return error;

        // don't create an entry in an unlinked directory
        if (directory->HardLinks() == 0)
                RETURN_ERROR(B_ENTRY_NOT_FOUND);

        // create a file
        File* newFile;
        error = volume->CreateFile(permissions, transaction, newFile);
        if (error != B_OK)
                return error;

        // insert the new file
        error = directory->InsertEntry(name, newFile->BlockIndex(), transaction);
        if (error != B_OK)
                return error;

        // open the file
        FileCookie* cookie;
        error = open_file(volume, newFile, openMode & ~O_TRUNC, transaction,
                false, cookie);
        if (error != B_OK)
                RETURN_ERROR(error);
        ObjectDeleter<FileCookie> cookieDeleter(cookie);

        // update stat data
        newFile->SetHardLinks(1);
        newFile->SetParentDirectory(directory->BlockIndex());

        directory->Touched(NODE_MODIFIED);

        // announce the new vnode (needed for creating the file cache), but don't
        // publish it yet
        error = volume->NewNode(newFile);
        if (error != B_OK)
                RETURN_ERROR(error);

        // There's a vnode now -- the File object will be deleted when that is
        // removed.
        transaction.UpdateNodeFlags(newFile, TRANSACTION_REMOVE_NODE_ON_ERROR);

        // create the file cache
        error = newFile->InitForVFS();
        if (error != B_OK)
                return error;

        // node is fully initialized -- publish the vnode
        error = volume->PublishNode(newFile, 0);
        if (error != B_OK) {
                // publish_vnode() deletes the vnode on error, but it doesn't call the
                // remove_vnode() hook. So we need to make sure the object is deleted.
                transaction.UpdateNodeFlags(newFile, TRANSACTION_DELETE_NODE);
                RETURN_ERROR(error);
        }

        // commit the transaction
        if (commitTransaction) {
                error = transaction.Commit(EntryCreatedNotification(directory, name,
                        newFile));
                if (error != B_OK) {
                        volume->PutNode(newFile);
                        RETURN_ERROR(error);
                }
        }

        _cookie = cookieDeleter.Detach();
        _node = newFile;
        _created = true;

        return B_OK;
}


/*!     Gets the node's attribute directory.
        If a transaction is given and the attribute directory doesn't exist, a new
        one is created and associate with the node.
        On success the caller gets a reference to the attribute directory and is
        responsible for putting it. If a transaction was given, the attribute
        directory must be put after committing/aborting the transaction.
*/
static status_t
get_attribute_directory(Node* node, Transaction* transaction,
        Directory*& _attributeDirectory)
{
        uint64 blockIndex = node->AttributeDirectory();
        Directory* attributeDirectory;

        if (blockIndex != 0) {
                // get the attribute directory node
                Node* attrDirNode;
                status_t error = node->GetVolume()->GetNode(blockIndex, attrDirNode);
                if (error != B_OK)
                        RETURN_ERROR(error);

                attributeDirectory = dynamic_cast<Directory*>(attrDirNode);
                if (attributeDirectory == NULL) {
                        node->GetVolume()->PutNode(node);
                        ERROR("checksumfs: attribute directory (%" B_PRIu64 ") of node %"
                                B_PRIu64 " is not a directory!\n", blockIndex,
                                node->BlockIndex());
                        RETURN_ERROR(B_BAD_DATA);
                }
        } else {
                // no (i.e. empty) attribute directory yet
                if (transaction == NULL)
                        return B_ENTRY_NOT_FOUND;

                // create a new one
                status_t error = node->GetVolume()->CreateDirectory(
                        S_IRWXU | S_IRWXG | S_IRWXO, *transaction, attributeDirectory);
                if (error != B_OK)
                        RETURN_ERROR(error);

                attributeDirectory->SetMode(attributeDirectory->Mode() | S_ATTR_DIR);
                attributeDirectory->SetParentDirectory(node->BlockIndex());
                attributeDirectory->SetHardLinks(1);
                node->SetAttributeDirectory(attributeDirectory->BlockIndex());

                // publish it
                error = node->GetVolume()->PublishNode(attributeDirectory, 0);
                if (error != B_OK)
                        RETURN_ERROR(error);

                // We have published the attribute directory, so don't delete it when
                // committing or aborting the transaction. Instead, on error remove it.
                transaction->UpdateNodeFlags(attributeDirectory,
                        TRANSACTION_REMOVE_NODE_ON_ERROR);
        }

        _attributeDirectory = attributeDirectory;
        return B_OK;
}


// #pragma mark - FS operations


static float
checksumfs_identify_partition(int fd, partition_data* partition,
        void** _cookie)
{
        if ((uint64)partition->size < kCheckSumFSMinSize)
                return -1;

        SuperBlock* superBlock = new(std::nothrow) SuperBlock;
        if (superBlock == NULL)
                return -1;
        ObjectDeleter<SuperBlock> superBlockDeleter(superBlock);

        if (pread(fd, superBlock, sizeof(*superBlock), kCheckSumFSSuperBlockOffset)
                        != sizeof(*superBlock)) {
                return -1;
        }

        if (!superBlock->Check((uint64)partition->size / B_PAGE_SIZE))
                return -1;

        *_cookie = superBlockDeleter.Detach();
        return 0.8f;
}


static status_t
checksumfs_scan_partition(int fd, partition_data* partition, void* cookie)
{
        SuperBlock* superBlock = (SuperBlock*)cookie;

        partition->status = B_PARTITION_VALID;
        partition->flags |= B_PARTITION_FILE_SYSTEM;
        partition->content_size = superBlock->TotalBlocks() * B_PAGE_SIZE;
        partition->block_size = B_PAGE_SIZE;
        partition->content_name = strdup(superBlock->Name());
        if (partition->content_name == NULL)
                return B_NO_MEMORY;

        return B_OK;
}


static void
checksumfs_free_identify_partition_cookie(partition_data* partition,
        void* cookie)
{
        SuperBlock* superBlock = (SuperBlock*)cookie;
        delete superBlock;
}


static status_t
checksumfs_mount(fs_volume* fsVolume, const char* device, uint32 flags,
        const char* args, ino_t* _rootVnodeID)
{
        Volume* volume = new(std::nothrow) Volume(flags);
        if (volume == NULL)
                RETURN_ERROR(B_NO_MEMORY);
        ObjectDeleter<Volume> volumeDeleter(volume);

        status_t error = volume->Init(device);
        if (error != B_OK)
                RETURN_ERROR(error);

        error = volume->Mount(fsVolume);
        if (error != B_OK)
                RETURN_ERROR(error);

        fsVolume->private_volume = volumeDeleter.Detach();
        fsVolume->ops = &gCheckSumFSVolumeOps;
        *_rootVnodeID = volume->RootDirectory()->BlockIndex();

        return B_OK;
}


static status_t
checksumfs_set_content_name(int fd, partition_id partition, const char* name,
        disk_job_id job)
{
        // TODO: Implement!
        return B_UNSUPPORTED;
}


static status_t
checksumfs_initialize(int fd, partition_id partition, const char* name,
        const char* parameters, off_t partitionSize, disk_job_id job)
{
        if (name == NULL || strlen(name) >= kCheckSumFSNameLength)
                return B_BAD_VALUE;

        // TODO: Forcing a non-empty name here. Superfluous when the userland disk
        // system add-on has a parameter editor for it.
        if (*name == '\0')
                name = "Unnamed";

        update_disk_device_job_progress(job, 0);

        Volume volume(0);

        status_t error = volume.Init(fd, partitionSize / B_PAGE_SIZE);
        if (error != B_OK)
                return error;

        error = volume.Initialize(name);
        if (error != B_OK)
                return error;

        // rescan partition
        error = scan_partition(partition);
        if (error != B_OK)
                return error;

        update_disk_device_job_progress(job, 1);

        return B_OK;
}


// #pragma mark - volume operations


static status_t
checksumfs_unmount(fs_volume* fsVolume)
{
        Volume* volume = (Volume*)fsVolume->private_volume;
        volume->Unmount();
        return B_OK;
}


static status_t
checksumfs_read_fs_info(fs_volume* fsVolume, struct fs_info* info)
{
        Volume* volume = (Volume*)fsVolume->private_volume;
        volume->GetInfo(*info);
        return B_OK;
}


static status_t
checksumfs_write_fs_info(fs_volume* fsVolume, const struct fs_info* info,
        uint32 mask)
{
        Volume* volume = (Volume*)fsVolume->private_volume;

        if ((mask & FS_WRITE_FSINFO_NAME) != 0) {
                status_t error = volume->SetName(info->volume_name);
                if (error != B_OK)
                        return error;
        }

        return B_OK;
}


static status_t
checksumfs_sync(fs_volume* fsVolume)
{
        Volume* volume = (Volume*)fsVolume->private_volume;

        return block_cache_sync(volume->BlockCache());
}


static status_t
checksumfs_get_vnode(fs_volume* fsVolume, ino_t id, fs_vnode* vnode,
        int* _type, uint32* _flags, bool reenter)
{
        Volume* volume = (Volume*)fsVolume->private_volume;

        Node* node;
        status_t error = volume->ReadNode(id, node);
        if (error != B_OK)
                return error;

        error = node->InitForVFS();
        if (error != B_OK) {
                delete node;
                return error;
        }

        vnode->private_node = node;
        vnode->ops = &gCheckSumFSVnodeOps;
        *_type = node->Mode();
        *_flags = 0;

        return B_OK;
}


// #pragma mark - vnode operations


static status_t
checksumfs_lookup(fs_volume* fsVolume, fs_vnode* fsDir, const char* name,
        ino_t* _id)
{
        Volume* volume = (Volume*)fsVolume->private_volume;
        Node* node = (Node*)fsDir->private_node;

        Directory* directory = dynamic_cast<Directory*>(node);
        if (directory == NULL)
                return B_NOT_A_DIRECTORY;

        status_t error = check_access(directory, X_OK);
        if (error != B_OK)
                return error;

        NodeReadLocker nodeLocker(node);

        uint64 blockIndex;

        if (strcmp(name, ".") == 0) {
                blockIndex = directory->BlockIndex();
        } else if (strcmp(name, "..") == 0) {
                blockIndex = directory->ParentDirectory();
        } else {
                status_t error = directory->LookupEntry(name, blockIndex);
                if (error != B_OK)
                        return error;
        }

        // get the node
        Node* childNode;
        error = volume->GetNode(blockIndex, childNode);
        if (error != B_OK)
                return error;

        *_id = blockIndex;
        return B_OK;
}


static status_t
checksumfs_put_vnode(fs_volume* fsVolume, fs_vnode* vnode, bool reenter)
{
        Node* node = (Node*)vnode->private_node;
        delete node;
        return B_OK;
}


static status_t
checksumfs_remove_vnode(fs_volume* fsVolume, fs_vnode* vnode, bool reenter)
{
        Volume* volume = (Volume*)fsVolume->private_volume;
        Node* node = (Node*)vnode->private_node;
        return volume->DeleteNode(node);
}



// #pragma mark - asynchronous I/O


static status_t
iterative_io_get_vecs_hook(void* cookie, io_request* request, off_t offset,
        size_t size, file_io_vec* vecs, size_t* _count)
{
        File* file = (File*)cookie;

        RETURN_ERROR(file_map_translate(file->FileMap(), offset, size, vecs, _count,
                B_PAGE_SIZE));
}


static status_t
iterative_io_finished_hook(void* cookie, io_request* request, status_t status,
        bool partialTransfer, size_t bytesTransferred)
{
        File* file = (File*)cookie;
        file->ReadUnlock();
        return B_OK;
}


static status_t
checksumfs_io(fs_volume* fsVolume, fs_vnode* vnode, void* cookie,
        io_request* request)
{
        Volume* volume = (Volume*)fsVolume->private_volume;
        File* file = dynamic_cast<File*>((Node*)vnode->private_node);
        if (file == NULL) {
        notify_io_request(request, B_READ_ONLY_DEVICE);
                RETURN_ERROR(B_BAD_VALUE);
        }

        if (io_request_is_write(request) && volume->IsReadOnly()) {
        notify_io_request(request, B_READ_ONLY_DEVICE);
                RETURN_ERROR(B_READ_ONLY_DEVICE);
        }

        // Read-lock the file -- we'll unlock it in the finished hook.
        if (io_request_is_vip(request)) {
                // We cannot wait for the node lock indefinitely. So try read-locking
                // with a timeout (0.1 s).
                if (!file->ReadLockWithTimeout(B_RELATIVE_TIMEOUT, 100000)) {
                notify_io_request(request, B_BUSY);
                        RETURN_ERROR(B_BUSY);
                }
        } else
                file->ReadLock();

        RETURN_ERROR(do_iterative_fd_io(volume->FD(), request,
                iterative_io_get_vecs_hook, iterative_io_finished_hook, file));
}


// #pragma mark - cache file access


static status_t
checksumfs_get_file_map(fs_volume* fsVolume, fs_vnode* vnode, off_t offset,
        size_t size, struct file_io_vec* vecs, size_t* _count)
{
        if (offset < 0)
                RETURN_ERROR(B_BAD_VALUE);

        File* file = dynamic_cast<File*>((Node*)vnode->private_node);
        if (file == NULL)
                RETURN_ERROR(B_BAD_VALUE);

        RETURN_ERROR(file->GetFileVecs(offset, size, vecs, *_count, *_count));
}


// #pragma mark - common operations


static status_t
checksumfs_set_flags(fs_volume* fsVolume, fs_vnode* vnode, void* _cookie,
        int flags)
{
        FileCookie* cookie = (FileCookie*)_cookie;

        cookie->openMode = (cookie->openMode & ~O_APPEND) | (flags & O_APPEND);

        // TODO: Also support O_NOCACHE!

        return B_OK;
}


static status_t
checksumfs_fsync(fs_volume* fsVolume, fs_vnode* vnode)
{
        Node* node = (Node*)vnode->private_node;

        NodeReadLocker nodeLocker(node);

        return node->Sync();
}


static status_t
checksumfs_read_symlink(fs_volume* fsVolume, fs_vnode* vnode, char* buffer,
        size_t* _bufferSize)
{
        SymLink* symLink = dynamic_cast<SymLink*>((Node*)vnode->private_node);
        if (symLink == NULL)
                RETURN_ERROR(B_BAD_VALUE);

        status_t error = check_access(symLink, R_OK);
        if (error != B_OK)
                return error;

        return symLink->ReadSymLink(buffer, *_bufferSize, *_bufferSize);
}


static status_t
checksumfs_create_symlink(fs_volume* fsVolume, fs_vnode* parent,
        const char* name, const char* path, int mode)
{
        Volume* volume = (Volume*)fsVolume->private_volume;
        Directory* directory
                = dynamic_cast<Directory*>((Node*)parent->private_node);
        if (directory == NULL)
                return B_NOT_A_DIRECTORY;

        if (volume->IsReadOnly())
                return B_READ_ONLY_DEVICE;

        status_t error = check_access(directory, W_OK);
        if (error != B_OK)
                return error;

        // start a transaction and add the directory (write locks it, too)
        Transaction transaction(volume);
        error = transaction.StartAndAddNode(directory);
        if (error != B_OK)
                return error;

        // don't create an entry in an unlinked directory
        if (directory->HardLinks() == 0)
                RETURN_ERROR(B_ENTRY_NOT_FOUND);

        // create a symlink node
        SymLink* newSymLink;
        error = volume->CreateSymLink(mode, transaction, newSymLink);
        if (error != B_OK)
                return error;

        // write it
        error = newSymLink->WriteSymLink(path, strlen(path), transaction);
        if (error != B_OK)
                return error;

        // insert the new symlink
        error = directory->InsertEntry(name, newSymLink->BlockIndex(), transaction);
        if (error != B_OK)
                return error;

        // update stat data
        newSymLink->SetHardLinks(1);

        directory->Touched(NODE_MODIFIED);

        // commit the transaction
        return transaction.Commit(EntryCreatedNotification(directory, name,
                newSymLink));
}


static status_t
checksumfs_link(fs_volume* fsVolume, fs_vnode* dir, const char* name,
        fs_vnode* vnode)
{
        Volume* volume = (Volume*)fsVolume->private_volume;
        Node* node = (Node*)vnode->private_node;
        Directory* directory = dynamic_cast<Directory*>((Node*)dir->private_node);
        if (directory == NULL)
                return B_NOT_A_DIRECTORY;

        if (volume->IsReadOnly())
                return B_READ_ONLY_DEVICE;

        // don't allow hardlinking directories
        if (S_ISDIR(node->Mode()))
                RETURN_ERROR(B_NOT_ALLOWED);

        // start a transaction and lock the nodes
        Transaction transaction(volume);
        status_t error = transaction.Start();
        if (error != B_OK)
                RETURN_ERROR(error);

        error = transaction.AddNodes(directory, node);
        if (error != B_OK)
                RETURN_ERROR(error);

        // check permissions
        error = check_access(directory, W_OK);
        if (error != B_OK)
                RETURN_ERROR(error);

        // don't create an entry in an unlinked directory
        if (directory->HardLinks() == 0)
                RETURN_ERROR(B_ENTRY_NOT_FOUND);

        // insert the new entry
        error = directory->InsertEntry(name, node->BlockIndex(), transaction);
        if (error != B_OK)
                RETURN_ERROR(error);

        // update stat data
        node->SetHardLinks(node->HardLinks() + 1);
        directory->Touched(NODE_MODIFIED);

        // commit the transaction
        return transaction.Commit(EntryCreatedNotification(directory, name, node));
}


static status_t
checksumfs_unlink(fs_volume* fsVolume, fs_vnode* dir, const char* name)
{
        return remove_entry(fsVolume, dir, name, false);
}


static status_t
checksumfs_rename(fs_volume* fsVolume, fs_vnode* fromDir, const char* fromName,
        fs_vnode* toDir, const char* toName)
{
        Volume* volume = (Volume*)fsVolume->private_volume;
        Directory* fromDirectory
                = dynamic_cast<Directory*>((Node*)fromDir->private_node);
        Directory* toDirectory
                = dynamic_cast<Directory*>((Node*)toDir->private_node);
        if (fromDirectory == NULL || toDirectory == NULL)
                return B_NOT_A_DIRECTORY;

        if (volume->IsReadOnly())
                return B_READ_ONLY_DEVICE;

        // We need to write-lock all three nodes (both directories and the moved
        // node). To make that atomic, we have to lock the source directory, look up
        // the entry, unlock the directory, get the node, re-lock all, and look up
        // the entry again to check for changes.
        Transaction transaction(volume);
        Node* node;
        NodePutter nodePutter;

        while (true) {
                // look up the entry
                NodeReadLocker directoryLocker(fromDirectory);

                uint64 blockIndex;
                status_t error = fromDirectory->LookupEntry(fromName, blockIndex);
                if (error != B_OK)
                        RETURN_ERROR(error);

                directoryLocker.Unlock();

                // get the entry's node
                error = volume->GetNode(blockIndex, node);
                if (error != B_OK)
                        RETURN_ERROR(error);
                nodePutter.SetTo(node);

                // start the transaction
                error = transaction.Start();
                if (error != B_OK)
                        RETURN_ERROR(error);

                // write-lock the nodes
                error = fromDirectory != toDirectory
                        ? transaction.AddNodes(fromDirectory, toDirectory, node)
                        : transaction.AddNodes(fromDirectory, node);
                if (error != B_OK)
                        RETURN_ERROR(error);

                // check the situation again
                error = fromDirectory->LookupEntry(fromName, blockIndex);
                if (error != B_OK)
                        RETURN_ERROR(error);
                if (blockIndex != node->BlockIndex()) {
                        transaction.Abort();
                        continue;
                }

                break;
        }

        // check permissions
        status_t error = check_access(fromDirectory, W_OK);
        if (error != B_OK)
                RETURN_ERROR(error);

        error = check_access(toDirectory, W_OK);
        if (error != B_OK)
                RETURN_ERROR(error);

        // don't create an entry in an unlinked directory
        if (toDirectory->HardLinks() == 0)
                RETURN_ERROR(B_ENTRY_NOT_FOUND);

        // Check whether this operation would move a directory into one of its
        // descendents. We iterate upwards, checking whether any ancestor of the
        // target directory is the moved directory (if it is a directory that is).
        if (fromDirectory != toDirectory && S_ISDIR(node->Mode())) {
                NodePutter ancestorPutter;
                Node* ancestor = toDirectory;

                while (ancestor != volume->RootDirectory()
                        || ancestor == fromDirectory) {
                        if (ancestor == node)
                                RETURN_ERROR(B_BAD_VALUE);

                        error = volume->GetNode(ancestor->ParentDirectory(), ancestor);
                        if (error != B_OK)
                                RETURN_ERROR(error);
                        ancestorPutter.SetTo(ancestor);
                }
        }

        // Everything looks good -- insert a new entry in the target directory and
        // remove the old entry from the source directory.
        error = toDirectory->InsertEntry(toName, node->BlockIndex(), transaction);
        if (error != B_OK)
                RETURN_ERROR(error);

        error = fromDirectory->RemoveEntry(fromName, transaction);
        if (error != B_OK)
                RETURN_ERROR(error);

        // update stat data
        node->SetParentDirectory(toDirectory->BlockIndex());
        fromDirectory->Touched(NODE_MODIFIED);
        toDirectory->Touched(NODE_MODIFIED);

        // commit the transaction
        return transaction.Commit(EntryMovedNotification(fromDirectory, fromName,
                toDirectory, toName, node));
}


static status_t
checksumfs_access(fs_volume* fsVolume, fs_vnode* vnode, int mode)
{
        Node* node = (Node*)vnode->private_node;

        NodeReadLocker nodeLocker(node);

        return check_access(node, mode);
}


static status_t
checksumfs_read_stat(fs_volume* fsVolume, fs_vnode* vnode, struct stat* st)
{
        Node* node = (Node*)vnode->private_node;

        NodeReadLocker nodeLocker(node);

    st->st_mode = node->Mode();
    st->st_nlink = node->HardLinks();
    st->st_uid = node->UID();
    st->st_gid = node->GID();
    st->st_size = node->Size();
    st->st_blksize = B_PAGE_SIZE * 16;  // random number
    set_timespec(st->st_mtim, node->ModificationTime());
    set_timespec(st->st_ctim, node->ChangeTime());
    set_timespec(st->st_crtim, node->CreationTime());
    set_timespec(st->st_atim, node->AccessedTime());
    st->st_type = 0;        /* attribute/index type */
    st->st_blocks = 1 + (st->st_size + B_PAGE_SIZE - 1) / B_PAGE_SIZE;
                // TODO: That does neither count management structures for the content
                // (for files) nor attributes.

        return B_OK;
}


static status_t
checksumfs_write_stat(fs_volume* fsVolume, fs_vnode* vnode,
        const struct stat* st, uint32 statMask)
{
        Volume* volume = (Volume*)fsVolume->private_volume;
        Node* node = (Node*)vnode->private_node;

        if (volume->IsReadOnly())
                return B_READ_ONLY_DEVICE;

        // start a transaction and add the node to it (write locks the node, too)
        Transaction transaction(volume);
        status_t error = transaction.StartAndAddNode(node);
        if (error != B_OK)
                return error;

        uid_t uid = geteuid();
        bool isOwnerOrRoot = uid == 0 || uid == node->UID();
        bool hasWriteAccess = check_access(node, W_OK) == B_OK;

        bool updateModified = false;
        bool updateChanged = false;

        if ((statMask & B_STAT_SIZE) != 0 && (uint64)st->st_size != node->Size()) {
                if (!hasWriteAccess)
                        RETURN_ERROR(B_NOT_ALLOWED);

                error = node->Resize(st->st_size, true, transaction);
                if (error != B_OK)
                        RETURN_ERROR(error);

                updateModified = updateChanged = true;
        }

        if ((statMask & B_STAT_UID) != 0 && st->st_uid != node->UID()) {
                // only root can do that
                if (uid != 0)
                        RETURN_ERROR(B_NOT_ALLOWED);

                node->SetUID(st->st_uid);
                updateChanged = true;
        }

        if ((statMask & B_STAT_GID) != 0 && st->st_gid != node->GID()) {
                // only the user or root can do that
                if (!isOwnerOrRoot)
                        RETURN_ERROR(B_NOT_ALLOWED);

                node->SetGID(st->st_gid);
                updateChanged = true;
        }

        if ((statMask & B_STAT_MODE) != 0) {
                // only the user or root can do that
                if (!isOwnerOrRoot)
                        RETURN_ERROR(B_NOT_ALLOWED);

                node->SetMode((node->Mode() & ~(mode_t)S_IUMSK)
                        | (st->st_mode & S_IUMSK));
                updateChanged = true;
        }

        if ((statMask & B_STAT_CREATION_TIME) != 0) {
                // the user or root can do that or any user with write access
                if (!isOwnerOrRoot && !hasWriteAccess)
                        RETURN_ERROR(B_NOT_ALLOWED);

                node->SetCreationTime(timespec_to_nsecs(st->st_crtim));
                updateChanged = true;
        }

        if ((statMask & B_STAT_MODIFICATION_TIME) != 0) {
                // the user or root can do that or any user with write access
                if (!isOwnerOrRoot && !hasWriteAccess)
                        RETURN_ERROR(B_NOT_ALLOWED);

                node->SetModificationTime(timespec_to_nsecs(st->st_mtim));
                updateModified = false;
                updateChanged = true;
        }

        if ((statMask & B_STAT_CHANGE_TIME) != 0) {
                // the user or root can do that or any user with write access
                if (!isOwnerOrRoot && !hasWriteAccess)
                        RETURN_ERROR(B_NOT_ALLOWED);

                node->SetModificationTime(timespec_to_nsecs(st->st_mtim));
                updateModified = false;
                updateChanged = false;
        }

        // update access/change/modification time
        if (updateModified)
                node->Touched(NODE_MODIFIED);
        else if (updateChanged)
                node->Touched(NODE_STAT_CHANGED);
        else
                node->Touched(NODE_ACCESSED);

        // commit the transaction
        return transaction.Commit(StatChangedNotification(node, statMask));
}


// #pragma mark - file operations


static status_t
checksumfs_create(fs_volume* fsVolume, fs_vnode* parent, const char* name,
        int openMode, int permissions, void** _cookie, ino_t* _newVnodeID)
{
        Volume* volume = (Volume*)fsVolume->private_volume;
        Directory* directory
                = dynamic_cast<Directory*>((Node*)parent->private_node);
        if (directory == NULL)
                return B_NOT_A_DIRECTORY;

        if (volume->IsReadOnly())
                return B_READ_ONLY_DEVICE;

        Transaction transaction(volume);
        FileCookie* cookie;
        Node* node;
        bool created;
        status_t error = create_file(volume, directory, name, openMode, permissions,
                transaction, true, cookie, node, created);
        if (error != B_OK)
                RETURN_ERROR(error);

        *_cookie = cookie;
        *_newVnodeID = node->BlockIndex();

        return B_OK;
}


static status_t
checksumfs_open(fs_volume* fsVolume, fs_vnode* vnode, int openMode,
        void** _cookie)
{
        Volume* volume = (Volume*)fsVolume->private_volume;
        Node* node = (Node*)vnode->private_node;

        // don't allow opening an attribute this way
        if ((node->Mode() & S_ATTR) != 0)
                RETURN_ERROR(B_BAD_VALUE);

        Transaction transaction(volume);
        FileCookie* cookie;
        status_t error = open_file(volume, node, openMode, transaction, true,
                cookie);
        if (error != B_OK)
                RETURN_ERROR(error);

        *_cookie = cookie;
        return B_OK;
}


static status_t
checksumfs_close(fs_volume* fsVolume, fs_vnode* vnode, void* cookie)
{
        return B_OK;
}


static status_t
checksumfs_free_cookie(fs_volume* fsVolume, fs_vnode* vnode, void* _cookie)
{
        FileCookie* cookie = (FileCookie*)_cookie;
        Node* node = (Node*)vnode->private_node;

        cookie->UpdateModifiedIfNecessary(node, true);

        delete cookie;
        return B_OK;
}


static status_t
checksumfs_read(fs_volume* fsVolume, fs_vnode* vnode, void* _cookie, off_t pos,
        void* buffer, size_t* _length)
{
        FileCookie* cookie = (FileCookie*)_cookie;
        Node* node = (Node*)vnode->private_node;

        switch (cookie->openMode & O_RWMASK) {
                case O_RDONLY:
                case O_RDWR:
                        break;
                case O_WRONLY:
                default:
                        RETURN_ERROR(EBADF);
        }

        return node->Read(pos, buffer, *_length, *_length);
}


static status_t
checksumfs_write(fs_volume* fsVolume, fs_vnode* vnode, void* _cookie, off_t pos,
        const void* buffer, size_t* _length)
{
        FileCookie* cookie = (FileCookie*)_cookie;
        Node* node = (Node*)vnode->private_node;

        switch (cookie->openMode & O_RWMASK) {
                case O_WRONLY:
                case O_RDWR:
                        break;
                case O_RDONLY:
                default:
                        RETURN_ERROR(EBADF);
        }

        if (pos < 0)
                RETURN_ERROR(B_BAD_VALUE);

        if ((cookie->openMode & O_APPEND) != 0) {
                pos = -1;
                        // special value handled by Write()
        }

        bool sizeChanged;
        status_t error = node->Write(pos, buffer, *_length, *_length, sizeChanged);
        if (error != B_OK)
                RETURN_ERROR(error);

        // update the modification time and send out a notification from time to
        // time
        cookie->FileModified(node, sizeChanged);

        return B_OK;
}


// #pragma mark - directory operations


status_t
checksumfs_create_dir(fs_volume* fsVolume, fs_vnode* parent, const char* name,
        int perms)
{
        Volume* volume = (Volume*)fsVolume->private_volume;
        Directory* directory
                = dynamic_cast<Directory*>((Node*)parent->private_node);
        if (directory == NULL)
                return B_NOT_A_DIRECTORY;

        if (volume->IsReadOnly())
                return B_READ_ONLY_DEVICE;

        status_t error = check_access(directory, W_OK);
        if (error != B_OK)
                return error;

        // start a transaction and attach the directory (write locks it, too)
        Transaction transaction(volume);
        error = transaction.StartAndAddNode(directory);
        if (error != B_OK)
                return error;

        // don't create an entry in an unlinked directory
        if (directory->HardLinks() == 0)
                RETURN_ERROR(B_ENTRY_NOT_FOUND);

        // create a directory node
        Directory* newDirectory;
        error = volume->CreateDirectory(perms, transaction, newDirectory);
        if (error != B_OK)
                return error;

        // insert the new directory
        error = directory->InsertEntry(name, newDirectory->BlockIndex(),
                transaction);
        if (error != B_OK)
                return error;

        // update stat data
        newDirectory->SetHardLinks(1);
        newDirectory->SetParentDirectory(directory->BlockIndex());

        directory->Touched(NODE_MODIFIED);

        // commit the transaction
        return transaction.Commit(EntryCreatedNotification(directory, name,
                newDirectory));
}


status_t
checksumfs_remove_dir(fs_volume* volume, fs_vnode* parent, const char* name)
{
        return remove_entry(volume, parent, name, true);
}


static status_t
checksumfs_open_dir(fs_volume* fsVolume, fs_vnode* vnode, void** _cookie)
{
        Directory* directory = dynamic_cast<Directory*>((Node*)vnode->private_node);
        if (directory == NULL)
                return B_NOT_A_DIRECTORY;

        NodeReadLocker nodeLocker(directory);

        // don't allow opening an attribute directory this way
        if ((directory->Mode() & S_ATTR_DIR) != 0)
                RETURN_ERROR(B_BAD_VALUE);

        status_t error = check_access(directory, R_OK);
        if (error != B_OK)
                return error;

        DirCookie* cookie = new(std::nothrow) DirCookie(directory);
        if (cookie == NULL)
                return B_NO_MEMORY;

        *_cookie = cookie;
        return B_OK;
}


static status_t
checksumfs_close_dir(fs_volume* fsVolume, fs_vnode* vnode, void* cookie)
{
        return B_OK;
}


static status_t
checksumfs_free_dir_cookie(fs_volume* fsVolume, fs_vnode* vnode, void* _cookie)
{
        DirCookie* cookie = (DirCookie*)_cookie;
        delete cookie;
        return B_OK;
}


static status_t
checksumfs_read_dir(fs_volume* fsVolume, fs_vnode* vnode, void* _cookie,
        struct dirent* buffer, size_t bufferSize, uint32* _num)
{
        if (*_num == 0)
                return B_OK;

        DirCookie* cookie = (DirCookie*)_cookie;

        NodeReadLocker nodeLocker(cookie->GetDirectory());

        return cookie->ReadNextEntry(buffer, bufferSize, *_num);
}


static status_t
checksumfs_rewind_dir(fs_volume* fsVolume, fs_vnode* vnode, void* _cookie)
{
        DirCookie* cookie = (DirCookie*)_cookie;

        NodeReadLocker nodeLocker(cookie->GetDirectory());

        cookie->Rewind();
        return B_OK;
}


// #pragma mark - attribute directory operations


static status_t
checksumfs_open_attr_dir(fs_volume* volume, fs_vnode* vnode, void** _cookie)
{
        Node* node = (Node*)vnode->private_node;

        NodeReadLocker nodeLocker(node);

        status_t error = check_access(node, R_OK);
        if (error != B_OK)
                return error;

        AttrDirCookie* cookie = new(std::nothrow) AttrDirCookie(node);
        if (cookie == NULL)
                return B_NO_MEMORY;

        *_cookie = cookie;
        return B_OK;
}


static status_t
checksumfs_close_attr_dir(fs_volume* volume, fs_vnode* vnode, void* cookie)
{
        return B_OK;
}


static status_t
checksumfs_free_attr_dir_cookie(fs_volume* volume, fs_vnode* vnode,
        void* _cookie)
{
        AttrDirCookie* cookie = (AttrDirCookie*)_cookie;
        delete cookie;
        return B_OK;
}


static status_t
checksumfs_read_attr_dir(fs_volume* volume, fs_vnode* vnode, void* _cookie,
        struct dirent* buffer, size_t bufferSize, uint32* _num)
{
        if (*_num == 0)
                return B_OK;

        Node* node = (Node*)vnode->private_node;
        AttrDirCookie* cookie = (AttrDirCookie*)_cookie;

        NodeReadLocker nodeLocker(node);

        return cookie->ReadNextEntry(buffer, bufferSize, *_num);
}


static status_t
checksumfs_rewind_attr_dir(fs_volume* volume, fs_vnode* vnode, void* _cookie)
{
        Node* node = (Node*)vnode->private_node;
        AttrDirCookie* cookie = (AttrDirCookie*)_cookie;

        NodeReadLocker nodeLocker(node);

        cookie->Rewind();
        return B_OK;
}


// #pragma mark - attribute operations


static status_t
checksumfs_create_attr(fs_volume* fsVolume, fs_vnode* vnode, const char* name,
        uint32 type, int openMode, void** _cookie)
{
        Volume* volume = (Volume*)fsVolume->private_volume;
        Node* node = (Node*)vnode->private_node;
        if (node == NULL)
                return B_NOT_A_DIRECTORY;

        if (volume->IsReadOnly())
                return B_READ_ONLY_DEVICE;

        // create the attribute cookie
        AttributeCookie* cookie = new(std::nothrow) AttributeCookie(name);
        if (cookie == NULL || cookie->name == NULL) {
                delete cookie;
                return B_NO_MEMORY;
        }
        ObjectDeleter<AttributeCookie> cookieDeleter(cookie);

        // Start a transaction and lock the node.
        // Note: Other than for ordinary nodes the locking order when attributes
        // are involved is: node -> attribute directory -> attribute.
        Transaction transaction(volume);
        status_t error = transaction.StartAndAddNode(node);
        if (error != B_OK)
                RETURN_ERROR(error);

        // check permissions
        error = check_access(node, W_OK);
        if (error != B_OK)
                return error;

        // get the attribute directory (create, if necessary)
        Directory* attributeDirectory;
        error = get_attribute_directory(node, &transaction, attributeDirectory);
        if (error != B_OK)
                RETURN_ERROR(error);
        NodePutter attributeDirectoryPutter(attributeDirectory);

        // open/create the attribute
        bool created;
        error = create_file(volume, attributeDirectory, name, openMode,
                S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH, transaction,
                false, cookie->fileCookie, cookie->attribute, created);
        if (error != B_OK)
                RETURN_ERROR(error);

        if (created) {
                cookie->attribute->SetMode(cookie->attribute->Mode() | S_ATTR);
                cookie->attribute->SetAttributeType(type);
        }

        // commit the transaction
        if (transaction.IsActive()) {
                if (created || (openMode & O_TRUNC) != 0) {
                        node->Touched(NODE_STAT_CHANGED);

                        AttributeChangedNotification attributeNotification(node, name,
                                created ? B_ATTR_CREATED : B_ATTR_CHANGED);
                        StatChangedNotification statNotification(node, B_STAT_CHANGE_TIME);
                        error = transaction.Commit(&attributeNotification,
                                &statNotification);
                } else
                        error = transaction.Commit();
        }

        *_cookie = cookieDeleter.Detach();
        return B_OK;
}


static status_t
checksumfs_open_attr(fs_volume* fsVolume, fs_vnode* vnode, const char* name,
        int openMode, void** _cookie)
{
        Volume* volume = (Volume*)fsVolume->private_volume;
        Node* node = (Node*)vnode->private_node;

        // create the attribute cookie
        AttributeCookie* cookie = new(std::nothrow) AttributeCookie(name);
        if (cookie == NULL || cookie->name == NULL) {
                delete cookie;
                return B_NO_MEMORY;
        }
        ObjectDeleter<AttributeCookie> cookieDeleter(cookie);

        // Get the node's attribute directory (don't create it, if it doesn't exist
        // yet). We only need to read-lock the node for that, but when O_TRUNC is
        // given, we already start the transaction and write-lock the node, so we
        // don't get a locking order inversion later. The locking order when
        // attributes are involved is: node -> attribute directory -> attribute.
        Transaction transaction(volume);
        NodeReadLocker readLocker;
        if ((openMode & O_TRUNC) != 0) {
                status_t error = transaction.StartAndAddNode(node);
                if (error != B_OK)
                        RETURN_ERROR(error);
        } else
                readLocker.SetTo(node, false);

        Directory* attributeDirectory;
        status_t error = get_attribute_directory(node, NULL, attributeDirectory);
        if (error != B_OK)
                RETURN_ERROR(error);
        NodePutter attributeDirectoryPutter(attributeDirectory);

        // look up the attribute
        readLocker.SetTo(attributeDirectory, false);
        uint64 blockIndex;
        error = attributeDirectory->LookupEntry(name, blockIndex);
        if (error != B_OK)
                RETURN_ERROR(error);

        error = volume->GetNode(blockIndex, cookie->attribute);
                // the vnode reference directly goes to the cookie in case of success
        if (error != B_OK)
                RETURN_ERROR(error);

        // open the attribute
        error = open_file(volume, cookie->attribute, openMode, transaction, false,
                cookie->fileCookie);
        if (error != B_OK)
                RETURN_ERROR(error);

        // commit the transaction
        if (transaction.IsActive()) {
                if ((openMode & O_TRUNC) != 0) {
                        node->Touched(NODE_STAT_CHANGED);

                        AttributeChangedNotification attributeNotification(node, name,
                                B_ATTR_CHANGED);
                        StatChangedNotification statNotification(node, B_STAT_CHANGE_TIME);
                        error = transaction.Commit(&attributeNotification,
                                &statNotification);
                } else
                        error = transaction.Commit();
        }

        *_cookie = cookieDeleter.Detach();
        return B_OK;
}


static status_t
checksumfs_close_attr(fs_volume* fsVolume, fs_vnode* vnode, void* cookie)
{
        return B_OK;
}


static status_t
checksumfs_free_attr_cookie(fs_volume* fsVolume, fs_vnode* vnode, void* _cookie)
{
        AttributeCookie* cookie = (AttributeCookie*)_cookie;
        delete cookie;
        return B_OK;
}


static status_t
checksumfs_read_attr(fs_volume* fsVolume, fs_vnode* vnode, void* _cookie,
        off_t pos, void* buffer, size_t* _length)
{
        AttributeCookie* cookie = (AttributeCookie*)_cookie;

        switch (cookie->fileCookie->openMode & O_RWMASK) {
                case O_RDONLY:
                case O_RDWR:
                        break;
                case O_WRONLY:
                default:
                        RETURN_ERROR(EBADF);
        }

        return cookie->attribute->Read(pos, buffer, *_length, *_length);
}


static status_t
checksumfs_write_attr(fs_volume* fsVolume, fs_vnode* vnode, void* _cookie,
        off_t pos, const void* buffer, size_t* _length)
{
        Volume* volume = (Volume*)fsVolume->private_volume;
        Node* node = (Node*)vnode->private_node;
        AttributeCookie* cookie = (AttributeCookie*)_cookie;

        switch (cookie->fileCookie->openMode & O_RWMASK) {
                case O_WRONLY:
                case O_RDWR:
                        break;
                case O_RDONLY:
                default:
                        RETURN_ERROR(EBADF);
        }

        if (pos < 0)
                RETURN_ERROR(B_BAD_VALUE);

        if ((cookie->fileCookie->openMode & O_APPEND) != 0) {
                pos = -1;
                        // special value handled by Write()
        }

        bool sizeChanged;
        status_t error = cookie->attribute->Write(pos, buffer, *_length, *_length,
                sizeChanged);
        if (error != B_OK)
                RETURN_ERROR(error);

        // update the node changed time and send out a notifications (don't fail,
        // if any of this fails)
        Transaction transaction(volume);
        if (transaction.StartAndAddNode(node) != B_OK)
                return B_OK;
        if (transaction.AddNode(cookie->attribute) != B_OK)
                return B_OK;

        cookie->attribute->Touched(NODE_MODIFIED);

        // commit the transaction
        if (cookie->attribute->ParentDirectory() != 0) {
                node->Touched(NODE_STAT_CHANGED);

                AttributeChangedNotification attributeNotification(node, cookie->name,
                        B_ATTR_CHANGED);
                StatChangedNotification statNotification(node, B_STAT_CHANGE_TIME);
                transaction.Commit(&attributeNotification, &statNotification);
        } else {
                // attribute has been removed -- no notifications needed
                transaction.Commit();
        }

        return B_OK;
}


static status_t
checksumfs_read_attr_stat(fs_volume* fsVolume, fs_vnode* vnode, void* _cookie,
        struct stat* st)
{
        AttributeCookie* cookie = (AttributeCookie*)_cookie;

        // not many fields needed ATM
        st->st_size = cookie->attribute->Size();
    st->st_type = cookie->attribute->AttributeType();

        return B_OK;
}


static status_t
checksumfs_remove_attr(fs_volume* fsVolume, fs_vnode* vnode, const char* name)
{
        Volume* volume = (Volume*)fsVolume->private_volume;
        Node* node = (Node*)vnode->private_node;

        if (volume->IsReadOnly())
                return B_READ_ONLY_DEVICE;

        // start a transaction
        Transaction transaction(volume);
        status_t error = transaction.StartAndAddNode(node);
        if (error != B_OK)
                RETURN_ERROR(error);

        // check permissions
        error = check_access(node, W_OK);
        if (error != B_OK)
                RETURN_ERROR(error);

        // get the attribute directory
        Directory* attributeDirectory;
        error = get_attribute_directory(node, NULL, attributeDirectory);
        if (error != B_OK)
                RETURN_ERROR(error);
        NodePutter attributeDirectoryPutter(attributeDirectory);

        error = transaction.AddNode(attributeDirectory);
        if (error != B_OK)
                RETURN_ERROR(error);

        // look up the entry
        uint64 blockIndex;
        error = attributeDirectory->LookupEntry(name, blockIndex);
        if (error != B_OK)
                RETURN_ERROR(error);

        // get the attribute node
        Node* attribute;
        error = volume->GetNode(blockIndex, attribute);
        if (error != B_OK)
                RETURN_ERROR(error);
        NodePutter attributePutter(attribute);

        error = transaction.AddNode(attribute);
        if (error != B_OK) {
                volume->PutNode(attribute);
                RETURN_ERROR(error);
        }

        // remove the entry
        bool attrDirEmpty;
        error = attributeDirectory->RemoveEntry(name, transaction, &attrDirEmpty);
        if (error != B_OK)
                RETURN_ERROR(error);

        // remove the attribute node
        error = volume->RemoveNode(attribute);
        if (error != B_OK)
                return error;
        transaction.UpdateNodeFlags(attribute, TRANSACTION_UNREMOVE_NODE_ON_ERROR);

        // if the attribute directory is empty now, remove it too
        if (attrDirEmpty) {
                error = volume->RemoveNode(attributeDirectory);
                if (error != B_OK)
                        return error;
                transaction.UpdateNodeFlags(attributeDirectory,
                        TRANSACTION_UNREMOVE_NODE_ON_ERROR);

                node->SetAttributeDirectory(0);
        }

        // update stat data
        attribute->SetHardLinks(0);

        node->Touched(NODE_STAT_CHANGED);

        // commit the transaction
        AttributeChangedNotification attributeNotification(node, name,
                B_ATTR_REMOVED);
        StatChangedNotification statNotification(node, B_STAT_CHANGE_TIME);
        return transaction.Commit(&attributeNotification, &statNotification);
}


// #pragma mark - module


static status_t
checksumfs_std_ops(int32 operation, ...)
{
        switch (operation) {
                case B_MODULE_INIT:
                        init_debugging();
                        PRINT("checksumfs_std_ops(): B_MODULE_INIT\n");
                        return B_OK;

                case B_MODULE_UNINIT:
                        PRINT("checksumfs_std_ops(): B_MODULE_UNINIT\n");
                        exit_debugging();
                        return B_OK;

                default:
                        return B_BAD_VALUE;
        }
}


static file_system_module_info sFSModule = {
        {
                kCheckSumFSModuleName,
                0,
                checksumfs_std_ops
        },
        kCheckSumFSShortName,
        CHECK_SUM_FS_PRETTY_NAME,
        // DDM flags
        B_DISK_SYSTEM_SUPPORTS_INITIALIZING
                | B_DISK_SYSTEM_SUPPORTS_CONTENT_NAME
                | B_DISK_SYSTEM_SUPPORTS_WRITING,

        /* scanning (the device is write locked) */
        checksumfs_identify_partition,
        checksumfs_scan_partition,
        checksumfs_free_identify_partition_cookie,
        NULL,   // free_partition_content_cookie

        /* general operations */
        checksumfs_mount,

        /* capability querying (the device is read locked) */
        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 (device is write locked) */
        NULL,   // shadow_changed

        /* writing (the device is NOT locked) */
        NULL,   // defragment
        NULL,   // repair
        NULL,   // resize
        NULL,   // move
        checksumfs_set_content_name,
        NULL,   // set_content_parameters
        checksumfs_initialize
};


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


fs_volume_ops gCheckSumFSVolumeOps = {
        checksumfs_unmount,

        checksumfs_read_fs_info,
        checksumfs_write_fs_info,
        checksumfs_sync,

        checksumfs_get_vnode,

        /* index directory & index operations */
        NULL,   // open_index_dir
        NULL,   // close_index_dir
        NULL,   // free_index_dir_cookie
        NULL,   // read_index_dir
        NULL,   // rewind_index_dir

        NULL,   // create_index
        NULL,   // remove_index
        NULL,   // read_index_stat

        /* query operations */
        NULL,   // open_query
        NULL,   // close_query
        NULL,   // free_query_cookie
        NULL,   // read_query
        NULL,   // rewind_query

        /* support for FS layers */
        NULL,   // all_layers_mounted
        NULL,   // create_sub_vnode
        NULL,   // delete_sub_vnode
};


fs_vnode_ops gCheckSumFSVnodeOps = {
        /* vnode operations */
        checksumfs_lookup,
        NULL,   // get_vnode_name

        checksumfs_put_vnode,
        checksumfs_remove_vnode,

        /* VM file access */
        NULL,   // can_page
        NULL,   // read_pages
        NULL,   // write_pages

        /* asynchronous I/O */
        checksumfs_io,
        NULL,   // cancel_io

        /* cache file access */
        checksumfs_get_file_map,

        /* common operations */
        NULL,   // ioctl
        checksumfs_set_flags,
        NULL,   // select
        NULL,   // deselect
        checksumfs_fsync,

        checksumfs_read_symlink,
        checksumfs_create_symlink,

        checksumfs_link,
        checksumfs_unlink,
        checksumfs_rename,

        checksumfs_access,
        checksumfs_read_stat,
        checksumfs_write_stat,
        NULL,   // preallocate

        /* file operations */
        checksumfs_create,
        checksumfs_open,
        checksumfs_close,
        checksumfs_free_cookie,
        checksumfs_read,
        checksumfs_write,

        /* directory operations */
        checksumfs_create_dir,
        checksumfs_remove_dir,
        checksumfs_open_dir,
        checksumfs_close_dir,
        checksumfs_free_dir_cookie,
        checksumfs_read_dir,
        checksumfs_rewind_dir,

        /* attribute directory operations */
        checksumfs_open_attr_dir,
        checksumfs_close_attr_dir,
        checksumfs_free_attr_dir_cookie,
        checksumfs_read_attr_dir,
        checksumfs_rewind_attr_dir,

        /* attribute operations */
        checksumfs_create_attr,
        checksumfs_open_attr,
        checksumfs_close_attr,
        checksumfs_free_attr_cookie,
        checksumfs_read_attr,
        checksumfs_write_attr,

        checksumfs_read_attr_stat,
        NULL,   // write_attr_stat
        NULL,   // rename_attr
        checksumfs_remove_attr,

        /* support for node and FS layers */
        NULL,   // create_special_node
        NULL    // get_super_vnode
};