File.h

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#ifndef FILE_H
#define FILE_H

#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/process/Mutex.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/time/Time.h"
#include "pedigree/kernel/utilities/Cache.h"
#include "pedigree/kernel/utilities/CacheConstants.h"
#include "pedigree/kernel/utilities/HashTable.h"
#include "pedigree/kernel/utilities/List.h"
#include "pedigree/kernel/utilities/StaticString.h"
#include "pedigree/kernel/utilities/String.h"
#include "pedigree/kernel/utilities/new"

class Event;
class Filesystem;
class Thread;

// RWX for owner.
#define FILE_UR 0001
#define FILE_UW 0002
#define FILE_UX 0004
#define FILE_UMASK 0007
#define FILE_UBITS 0
// RWX for group.
#define FILE_GR 0010
#define FILE_GW 0020
#define FILE_GX 0040
#define FILE_GMASK 0070
#define FILE_GBITS 3
// RWX for others.
#define FILE_OR 0100
#define FILE_OW 0200
#define FILE_OX 0400
#define FILE_OMASK 0700
#define FILE_OBITS 6
// Ancillary file bits.
#define FILE_STICKY 01000
#define FILE_AMASK 07000
#define FILE_ABITS 9

#define FILE_BAD_BLOCK static_cast<uintptr_t>(-1)

class EXPORTED_PUBLIC File
{
    friend class Filesystem;

  public:
    File();

  private:
    File(const File &file);
    File &operator=(const File &);

  public:
    File(
        const String &name, Time::Timestamp accessedTime,
        Time::Timestamp modifiedTime, Time::Timestamp creationTime,
        uintptr_t inode, class Filesystem *pFs, size_t size, File *pParent);
    virtual ~File();

    virtual uint64_t read(
        uint64_t location, uint64_t size, uintptr_t buffer,
        bool bCanBlock = true) final;
    virtual uint64_t write(
        uint64_t location, uint64_t size, uintptr_t buffer,
        bool bCanBlock = true) final;

    virtual physical_uintptr_t getPhysicalPage(size_t offset);

    virtual void returnPhysicalPage(size_t offset);

    virtual void sync();

    virtual void sync(size_t offset, bool async);

    Time::Timestamp getCreationTime();
    void setCreationTime(Time::Timestamp t);

    Time::Timestamp getAccessedTime();
    void setAccessedTime(Time::Timestamp t);

    Time::Timestamp getModifiedTime();
    void setModifiedTime(Time::Timestamp t);

    String getName() const;
    void getName(String &s) const;
    // File names cannot be changed.

    virtual String getFullPath(bool bWithLabel = true);

    virtual void truncate();

    size_t getSize();
    void setSize(size_t sz);

    virtual bool isSymlink();

    virtual bool isDirectory();

    virtual bool isPipe() const;

    virtual bool isFifo() const;

    virtual bool isSocket() const;

    uintptr_t getInode() const;
    virtual void setInode(uintptr_t inode);

    Filesystem *getFilesystem() const;
    void setFilesystem(Filesystem *pFs);

    virtual void fileAttributeChanged();

    virtual void increaseRefCount(bool bIsWriter);
    virtual void decreaseRefCount(bool bIsWriter);

    void setPermissions(uint32_t perms);
    uint32_t getPermissions() const;

    void setUid(size_t uid);
    size_t getUid() const;

    void setGid(size_t gid);
    size_t getGid() const;

    File *getParent() const;

    virtual int select(bool bWriting = false, int timeout = 0);

    void monitor(Thread *pThread, Event *pEvent);

    void cullMonitorTargets(Thread *pThread);

    virtual bool supports(const size_t command) const;

    virtual int command(const size_t command, void *buffer);

    virtual size_t getBlockSize() const;

    void enableDirect();

    void disableDirect();

    virtual void preallocate(size_t expectedSize, bool zero=true);

    virtual File *open();

  protected:
    virtual bool isBytewise() const;

    virtual uint64_t readBytewise(
        uint64_t location, uint64_t size, uintptr_t buffer,
        bool bCanBlock = true);
    virtual uint64_t writeBytewise(
        uint64_t location, uint64_t size, uintptr_t buffer,
        bool bCanBlock = true);

    virtual uintptr_t readBlock(uint64_t location);
    virtual void writeBlock(uint64_t location, uintptr_t addr);

    virtual void extend(size_t newSize);

    virtual void extend(size_t newSize, uint64_t location, uint64_t size);

    void dataChanged();

    void getFilesystemLabel(HugeStaticString &s);

    static void writeCallback(
        CacheConstants::CallbackCause cause, uintptr_t loc, uintptr_t page,
        void *meta);

    virtual void pinBlock(uint64_t location);

    virtual void unpinBlock(uint64_t location);

    void evict(uint64_t location);

    void setPermissionsOnly(uint32_t perms);

    void setUidOnly(size_t uid);

    void setGidOnly(size_t gid);

    String m_Name;
    Time::Timestamp m_AccessedTime;
    Time::Timestamp m_ModifiedTime;
    Time::Timestamp m_CreationTime;
    uintptr_t m_Inode;

    class Filesystem *m_pFilesystem;
    size_t m_Size;

    File *m_pParent;

    size_t m_nWriters, m_nReaders;

    size_t m_Uid;
    size_t m_Gid;
    uint32_t m_Permissions;

    class DataCacheKey
    {
      public:
        DataCacheKey() = default;
        DataCacheKey(size_t block) : m_Block(block)
        {
        }
        ~DataCacheKey() = default;

        size_t hash() const
        {
            return m_Block;
        }

        bool operator==(const DataCacheKey &other) const
        {
            return m_Block == other.m_Block;
        }

      private:
        size_t m_Block = ~static_cast<size_t>(0);
    };

    HashTable<DataCacheKey, uintptr_t> m_DataCache;

    bool m_bDirect;

#ifndef VFS_NOMMU

    Cache m_FillCache;
#endif

#ifdef THREADS
    Mutex m_Lock;

    struct MonitorTarget
    {
        MonitorTarget(Thread *pT, Event *pE) : pThread(pT), pEvent(pE)
        {
        }
        Thread *pThread;
        Event *pEvent;
    };

    List<MonitorTarget *> m_MonitorTargets;
#endif

  private:
    uintptr_t getCachedPage(size_t block, bool locked = true);

    void setCachedPage(size_t block, uintptr_t value, bool locked = true);

    bool useFillCache() const;

    uintptr_t readIntoCache(uintptr_t block);
};

#endif