ladybird/Kernel/FileSystem/Plan9FileSystem.h

/*
 * Copyright (c) 2020, Sergey Bugaev <bugaevc@serenityos.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this
 *    list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#pragma once

#include <AK/Atomic.h>
#include <Kernel/FileSystem/FileBackedFileSystem.h>
#include <Kernel/FileSystem/Inode.h>
#include <Kernel/KBufferBuilder.h>

namespace Kernel {

class Plan9FSInode;

class Plan9FS final : public FileBackedFS {
    friend class Plan9FSInode;

public:
    virtual ~Plan9FS() override;
    static NonnullRefPtr<Plan9FS> create(FileDescription&);

    virtual bool initialize() override;

    virtual bool supports_watchers() const override { return false; }

    virtual NonnullRefPtr<Inode> root_inode() const override;

    u16 allocate_tag() { return m_next_tag++; }
    u32 allocate_fid() { return m_next_fid++; }

    enum class ProtocolVersion {
        v9P2000,
        v9P2000u,
        v9P2000L
    };

    struct qid {
        u8 type;
        u32 version;
        u64 path;
    };

    class Message;

private:
    Plan9FS(FileDescription&);

    class Blocker;

    class Plan9FSBlockCondition : public Thread::BlockCondition {
    public:
        Plan9FSBlockCondition(Plan9FS& fs)
            : m_fs(fs)
        {
        }

        void unblock_completed(u16);
        void unblock_all();
        void try_unblock(Blocker&);

    protected:
        virtual bool should_add_blocker(Thread::Blocker&, void*) override;

    private:
        Plan9FS& m_fs;
        mutable SpinLock<u8> m_lock;
    };

    struct ReceiveCompletion : public RefCounted<ReceiveCompletion> {
        mutable SpinLock<u8> lock;
        bool completed { false };
        const u16 tag;
        OwnPtr<Message> message;
        KResult result { KSuccess };

        ReceiveCompletion(u16 tag);
        ~ReceiveCompletion();
    };

    class Blocker final : public Thread::Blocker {
    public:
        Blocker(Plan9FS& fs, Message& message, NonnullRefPtr<ReceiveCompletion> completion)
            : m_fs(fs)
            , m_message(message)
            , m_completion(move(completion))
        {
            set_block_condition(fs.m_completion_blocker);
        }
        virtual const char* state_string() const override { return "Waiting"; }
        virtual Type blocker_type() const override { return Type::Plan9FS; }
        virtual void not_blocking(bool) override;

        const NonnullRefPtr<ReceiveCompletion>& completion() const { return m_completion; }
        u16 tag() const { return m_completion->tag; }
        bool is_completed() const;

        bool unblock()
        {
            unblock_from_blocker();
            return true;
        }

        bool unblock(u16 tag);

    private:
        Plan9FS& m_fs;
        Message& m_message;
        NonnullRefPtr<ReceiveCompletion> m_completion;
        bool m_did_unblock { false };
    };
    friend class Blocker;

    virtual const char* class_name() const override { return "Plan9FS"; }

    bool is_complete(const ReceiveCompletion&);
    KResult post_message(Message&, RefPtr<ReceiveCompletion>);
    KResult do_read(u8* buffer, size_t);
    KResult read_and_dispatch_one_message();
    KResult post_message_and_wait_for_a_reply(Message&);
    KResult post_message_and_explicitly_ignore_reply(Message&);

    ProtocolVersion parse_protocol_version(const StringView&) const;
    ssize_t adjust_buffer_size(ssize_t size) const;

    void thread_main();
    void ensure_thread();

    RefPtr<Plan9FSInode> m_root_inode;
    Atomic<u16> m_next_tag { (u16)-1 };
    Atomic<u32> m_next_fid { 1 };

    ProtocolVersion m_remote_protocol_version { ProtocolVersion::v9P2000 };
    size_t m_max_message_size { 4 * KiB };

    Lock m_send_lock { "Plan9FS send" };
    Plan9FSBlockCondition m_completion_blocker;
    HashMap<u16, NonnullRefPtr<ReceiveCompletion>> m_completions;

    SpinLock<u8> m_thread_lock;
    RefPtr<Thread> m_thread;
    Atomic<bool> m_thread_running { false };
    Atomic<bool> m_thread_shutdown { false };
};

class Plan9FSInode final : public Inode {
    friend class Plan9FS;

public:
    virtual ~Plan9FSInode() override;

    u32 fid() const { return index(); }

    // ^Inode
    virtual InodeMetadata metadata() const override;
    virtual void flush_metadata() override;
    virtual ssize_t read_bytes(off_t, ssize_t, UserOrKernelBuffer& buffer, FileDescription*) const override;
    virtual ssize_t write_bytes(off_t, ssize_t, const UserOrKernelBuffer& data, FileDescription*) override;
    virtual KResult traverse_as_directory(Function<bool(const FS::DirectoryEntryView&)>) const override;
    virtual RefPtr<Inode> lookup(StringView name) override;
    virtual KResultOr<NonnullRefPtr<Inode>> create_child(const String& name, mode_t, dev_t, uid_t, gid_t) override;
    virtual KResult add_child(Inode&, const StringView& name, mode_t) override;
    virtual KResult remove_child(const StringView& name) override;
    virtual KResultOr<size_t> directory_entry_count() const override;
    virtual KResult chmod(mode_t) override;
    virtual KResult chown(uid_t, gid_t) override;
    virtual KResult truncate(u64) override;

private:
    Plan9FSInode(Plan9FS&, u32 fid);
    static NonnullRefPtr<Plan9FSInode> create(Plan9FS&, u32 fid);

    enum class GetAttrMask : u64 {
        Mode = 0x1,
        NLink = 0x2,
        UID = 0x4,
        GID = 0x8,
        RDev = 0x10,
        ATime = 0x20,
        MTime = 0x40,
        CTime = 0x80,
        Ino = 0x100,
        Size = 0x200,
        Blocks = 0x400,

        BTime = 0x800,
        Gen = 0x1000,
        DataVersion = 0x2000,

        Basic = 0x7ff,
        All = 0x3fff
    };

    enum class SetAttrMask : u64 {
        Mode = 0x1,
        UID = 0x2,
        GID = 0x4,
        Size = 0x8,
        ATime = 0x10,
        MTime = 0x20,
        CTime = 0x40,
        ATimeSet = 0x80,
        MTimeSet = 0x100
    };

    // Mode in which the file is already open, using SerenityOS constants.
    int m_open_mode { 0 };
    KResult ensure_open_for_mode(int mode);

    Plan9FS& fs() { return reinterpret_cast<Plan9FS&>(Inode::fs()); }
    Plan9FS& fs() const
    {
        return const_cast<Plan9FS&>(reinterpret_cast<const Plan9FS&>(Inode::fs()));
    }
};

}