DynamicLinker.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 DYNAMIC_LINKER_H
#define DYNAMIC_LINKER_H

#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/processor/PageFaultHandler.h"
#include "pedigree/kernel/processor/state_forward.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/RadixTree.h"
#include "pedigree/kernel/utilities/String.h"
#include "pedigree/kernel/utilities/Tree.h"

class Elf;
class File;
class MemoryMappedObject;

class EXPORTED_PUBLIC DynamicLinker
{
  public:
    DynamicLinker();

    ~DynamicLinker();

    DynamicLinker(DynamicLinker &other);

    bool checkInterpreter(File *pFile, String &actualFilename)
    {
        return loadProgram(pFile, true, true, &actualFilename);
    }

    bool checkDependencies(File *pFile)
    {
        return loadProgram(pFile, true);
    }

    bool loadProgram(
        File *pFile, bool bDryRun = false, bool bInterpreter = false,
        String *sInterpreter = 0);

    bool loadObject(File *pFile, bool bDryRun = false);

    static uintptr_t resolvePlt(SyscallState &state);

    bool trap(uintptr_t address);

    Elf *getProgramElf()
    {
        return m_pProgramElf;
    }

    uintptr_t resolve(String name);

  private:
    DynamicLinker &operator=(const DynamicLinker &);

    struct SharedObject
    {
        SharedObject(
            Elf *e, MemoryMappedObject *f, uintptr_t b, uintptr_t a, size_t s)
            : elf(e), file(f), buffer(b), address(a), size(s)
        {
        }
        Elf *elf;
        MemoryMappedObject *file;
        uintptr_t buffer;
        uintptr_t address;
        size_t size;
    };

    uintptr_t resolvePltSymbol(uintptr_t libraryId, uintptr_t symIdx);

    void initPlt(Elf *pElf, uintptr_t value);

    Elf *m_pProgramElf;
    uintptr_t m_ProgramStart;
    size_t m_ProgramSize;
    uintptr_t m_ProgramBuffer;
    RadixTree<void *> m_LoadedObjects;

    Tree<uintptr_t, SharedObject *> m_Objects;
};

class DLTrapHandler : public MemoryTrapHandler
{
  public:
    static DLTrapHandler &instance()
    {
        return m_Instance;
    }

    //
    // MemoryTrapHandler interface.
    //
    virtual bool trap(InterruptState &state, uintptr_t address, bool bIsWrite);

  private:
    DLTrapHandler();
    ~DLTrapHandler();

    static DLTrapHandler m_Instance;
};

#endif