MemoryMappedFile.h

Go to the documentation of this file.

/*
 * 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 MEMORY_MAPPED_FILE_H
#define MEMORY_MAPPED_FILE_H

#include "pedigree/kernel/Spinlock.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/process/MemoryPressureManager.h"
#include "pedigree/kernel/processor/PageFaultHandler.h"
#include "pedigree/kernel/processor/state_forward.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/List.h"
#include "pedigree/kernel/utilities/String.h"
#include "pedigree/kernel/utilities/Tree.h"
#include "pedigree/kernel/utilities/new"

class File;
class Process;
class VirtualAddressSpace;

class MemoryMappedObject
{
    friend class MemoryMapManager;

  private:
    MemoryMappedObject();

  public:
    typedef int Permissions;

    static const int None = 0x0;
    static const int Read = 0x1;
    static const int Write = 0x2;
    static const int Exec = 0x4;

    MemoryMappedObject(
        uintptr_t address, bool bCopyOnWrite, size_t length, Permissions perms)
        : m_bCopyOnWrite(bCopyOnWrite), m_Address(address), m_Length(length),
          m_Permissions(perms)
    {
    }

    virtual ~MemoryMappedObject();

    virtual MemoryMappedObject *clone() = 0;

    virtual MemoryMappedObject *split(uintptr_t at) = 0;

    virtual bool remove(size_t length) = 0;

    virtual void setPermissions(Permissions perms) = 0;

    virtual void sync(uintptr_t at, bool async)
    {
    }

    virtual void invalidate(uintptr_t at)
    {
    }

    virtual void unmap() = 0;

    virtual bool trap(uintptr_t address, bool bWrite) = 0;

    virtual bool compact()
    {
        return false;
    }

    bool matches(uintptr_t address)
    {
        return (m_Address <= address) && (address < (m_Address + m_Length));
    }

    uintptr_t address() const
    {
        return m_Address;
    }

    size_t length() const
    {
        return m_Length;
    }

  protected:
    bool m_bCopyOnWrite;

    uintptr_t m_Address;

    size_t m_Length;

    Permissions m_Permissions;
};

class AnonymousMemoryMap : public MemoryMappedObject
{
  public:
    AnonymousMemoryMap(uintptr_t address, size_t length, Permissions perms);

    virtual ~AnonymousMemoryMap()
    {
    }

    virtual MemoryMappedObject *clone();
    virtual MemoryMappedObject *split(uintptr_t at);
    virtual bool remove(size_t length);

    virtual void setPermissions(MemoryMappedObject::Permissions perms);

    virtual void unmap();

    virtual bool trap(uintptr_t address, bool bWrite);

  private:
    static physical_uintptr_t m_Zero;

    void unmapUnlocked();

    List<void *> m_Mappings;

    Spinlock m_Lock;
};

class MemoryMappedFile : public MemoryMappedObject
{
  public:
    MemoryMappedFile(
        uintptr_t address, size_t length, size_t offset, File *backing,
        bool bCopyOnWrite, Permissions perms);

    virtual ~MemoryMappedFile();

    virtual MemoryMappedObject *clone();
    virtual MemoryMappedObject *split(uintptr_t at);
    virtual bool remove(size_t length);

    virtual void setPermissions(MemoryMappedObject::Permissions perms);

    virtual void sync(uintptr_t at, bool async);
    virtual void invalidate(uintptr_t at);

    virtual void unmap();

    virtual bool trap(uintptr_t address, bool bWrite);

    virtual bool compact();

  private:
    void unmapUnlocked();

    void trackMapping(uintptr_t, physical_uintptr_t);

    void untrackMapping(uintptr_t);

    physical_uintptr_t getMapping(uintptr_t);

    size_t getMappingCount();

    void clearMappings();

    File *m_pBacking;

    size_t m_Offset;

    Tree<uintptr_t, physical_uintptr_t> m_Mappings;

    Spinlock m_Lock;
};

class EXPORTED_PUBLIC MemoryMapManager : public MemoryTrapHandler,
                                         public MemoryPressureHandler
{
    friend class PosixSubsystem;

  public:
    static MemoryMapManager &instance()
    {
        return m_Instance;
    }

    MemoryMappedObject *mapFile(
        File *pFile, uintptr_t &address, size_t length,
        MemoryMappedObject::Permissions perms, size_t offset = 0,
        bool bCopyOnWrite = true);

    MemoryMappedObject *mapAnon(
        uintptr_t &address, size_t length,
        MemoryMappedObject::Permissions perms);

    void clone(Process *pTarget);

    size_t remove(uintptr_t base, size_t length);

    size_t setPermissions(
        uintptr_t base, size_t length, MemoryMappedObject::Permissions perms);

    bool contains(uintptr_t base, size_t length);

    void sync(uintptr_t base, size_t length, bool async);

    void invalidate(uintptr_t base, size_t length);

    void unmap(MemoryMappedObject *pObj);

    void unmapAll();

    virtual bool trap(InterruptState &state, uintptr_t address, bool bIsWrite);

    virtual bool compact();

    virtual const String getMemoryPressureDescription()
    {
        return String("Unmap safe pages from memory mapped files.");
    }

  protected:
    void unmapAllUnlocked();

    bool acquireLock();

    void releaseLock();

  private:
    MemoryMapManager();
    ~MemoryMapManager();

    bool sanitiseAddress(uintptr_t &address, size_t length);

    enum Ops
    {
        Sync,
        Invalidate,
    };

    void op(Ops what, uintptr_t base, size_t length, bool async);

    static MemoryMapManager m_Instance;

    typedef List<MemoryMappedObject *> MmObjectList;

    Tree<VirtualAddressSpace *, MmObjectList *> m_MmObjectLists;

    Spinlock m_Lock;
};

#endif