AuroraRuntime/Source/Process/AuProcessMap.Linux.cpp

/***
    Copyright (C) 2022 J Reece Wilson (a/k/a "Reece"). All rights reserved.

    File: ModuleInfo.Linux.cpp
    Date: 2022-4-20
    Author: Reece
***/
#include <Source/RuntimeInternal.hpp>
#include "AuProcessMap.Linux.hpp"
#include "AuProcessMap.hpp"
#include <link.h>

#if defined(AURORA_IS_64BIT)
    using Elf_Ehdr = Elf64_Ehdr;
    using Elf_Shdr = Elf64_Shdr;
#else
    using Elf_Ehdr = Elf32_Ehdr;
    using Elf_Shdr = Elf32_Shdr;
#endif

namespace Aurora::Process
{
    void InitProcessMapLinux()
    {

    }

    void DeinitProcessMapLinux()
    {

    }

    static AuHashMap<AuUInt, AuTuple<AuString, AuList<AuTuple<AuUInt, AuUInt, AuUInt, AuUInt>>>> gModuleMap;

    static int LdDlIIterateCallback(struct dl_phdr_info *info,
                                    size_t size,
                                    void *data)
    {
        AuString fileName = info->dlpi_name[0] ? info->dlpi_name : AuString{};
        if (fileName.empty())
        {
            GetProcFullPath(fileName);
        }

        if (!AuIOFS::FileExists(fileName))
        {
            return 0;
        }

        AuList<AuTuple<AuUInt, AuUInt, AuUInt, AuUInt>> sections;
        for (int j = 0; j < info->dlpi_phnum; j++)
        {
            AuTryInsert(sections, AuMakeTuple((AuUInt)info->dlpi_phdr[j].p_vaddr, (AuUInt)info->dlpi_phdr[j].p_offset, (AuUInt)info->dlpi_phdr[j].p_memsz, (AuUInt)info->dlpi_phdr[j].p_flags));
        }

        AuTryInsert(gModuleMap, info->dlpi_addr, AuMakeTuple(fileName, sections));
        
        return 0;
    }

    static void PassOneScanLd()
    {
        ::dl_iterate_phdr(LdDlIIterateCallback, NULL);
    }

    static void PassTwoScanMaps()
    {
        AuString map;

        if (!AuIOFS::ReadString("/proc/self/maps", map))
        {
            return;
        }

        Sections sections;
        AuParse::SplitNewlines(map, [&](const AuString &line)
        {
            bool bIsSpecialFile {};
            char *endPtr;
            auto base = strtoll(line.c_str(), &endPtr, 16);
            if (errno == ERANGE) return;
            if (*endPtr != '-') return;

            auto end = strtoll(endPtr + 1, &endPtr, 16);
            if (errno == ERANGE) return;
            if (*endPtr != ' ') return;

            auto perms = endPtr + 1;

            auto A = line.find_first_of(':');
            if (A == AuString::npos) return;

            auto offsetStart = perms + 5;
            auto uFileOffset = strtoll(offsetStart, &endPtr, 16);
            if (errno == ERANGE) uFileOffset = 0;

            A += 4;
            auto gross = line.substr(A);

            AuString name;
            auto B = gross.find_first_of(' ');
            if (B != AuString::npos) 
            {
                auto C = gross.find_first_not_of(' ', B);
                if (C != AuString::npos)
                {
                    name = gross.substr(C);
                }
            }

            if (name == "[stack]")
            {
                name = kSectionNameStack;
            }
            else if (name == "[heap]")
            {
                name = kSectionNameHeap;
            }
            else if (name == "[vdso]")
            {
                name = kSectionNameFile;
            }

            if (name.size())
            {
                bIsSpecialFile = AuIOFS::FileExists(name);

                if (bIsSpecialFile)
                {
                    for (const auto &[uBaseAddress, pathSectionPair] : gModuleMap)
                    {
                        if (uBaseAddress == base)
                        {
                            return;
                        }

                        for (auto &[a, b, c, d] : AuGet<1>(pathSectionPair))
                        {
                            if ((uBaseAddress + a) <= base &&
                                (uBaseAddress + a + c) > base)
                            {
                                return;
                            }
                        }
                    }
                }
            }

            Section sect {};

            sect.origVa      = 0;
            sect.baseVa      = base;
            sect.size        = end - base;
            sect.fsOff       = uFileOffset;

            sect.pt.readable = perms[0] == 'r';
            sect.pt.writable = perms[1] == 'w';
            sect.pt.NX       = perms[2] != 'x';

            if (bIsSpecialFile)
            {
                // edge case: these are like windows nt section views
                // insert these as their own modules
                // (we cant present Sections of weakly owned files )
                static AuMutex gLock;
                static AuHashMap<AuString, AuSPtr<PublicModule>> gMap;

                sect.name = kSectionNameFile;

                AU_LOCK_GUARD(gLock);

                auto &refMod = gMap[name];
                if (refMod)
                {
                    // already cached
                } 
                else
                {
                    refMod = AuMakeShared<PublicModule>();
                    if (!refMod) return;

                    refMod->moduleMeta = AuMakeShared<ModuleMeta>();
                    if (!refMod->moduleMeta) return;

                    AuString fileName;
                    AuIOFS::GetFileFromPath(fileName, name);
                    refMod->moduleMeta->moduleBase = base;
                    refMod->moduleMeta->moduleName = fileName;
                    refMod->moduleMeta->modulePath = name;
                    refMod->moduleMeta->origVa = 0;
                }

                sect.moduleMeta = refMod;
            }
            else
            {
                // most likely
                sect.name = AuMove(name);
            }

            AuTryInsert(sections, sect);
        }, false);

        BorrowOtherSectionArray([&](AuList<Section> &out)
        {
            out.clear();
            out.insert(out.end(), sections.begin(), sections.end());
        });
    }

    static void PassThreeGatherMissingProgNames()
    {
        for (const auto & [baseAddress, pair] : gModuleMap)
        {
            auto & [path, sections] = pair;

            AuString file;
            AuIOFS::GetFileFromPath(file, path);
            auto object = AuIOFS::OpenReadUnique(path);
            if (!object)
            {
                SysPushErrorIO();
                continue;
            }

            Elf_Ehdr header;
            AuUInt read;
            if (!object->Read(AuMemoryViewStreamWrite(AuMemoryViewWrite(&header, sizeof(header)), read)))
            {
                SysPushErrorIO();
                continue;
            }

            AuList<Elf_Shdr> elfSections;
            if (!AuTryResize(elfSections, header.e_shnum))
            {
                SysPushErrorMem();
                continue;
            }

            object->SetOffset(header.e_shoff);
            if (!object->Read(AuMemoryViewStreamWrite(AuMemoryViewWrite(elfSections.data(),
                                                                        elfSections.size() * sizeof(Elf_Shdr)
                                                                        ),
                                                      read)))
            {
                SysPushErrorIO();
                continue;
            }

            auto &strtab = elfSections[header.e_shstrndx];

            AuList<AuUInt8> strHeap;
            if (strtab.sh_size > 80 * 1024 * 1024)
            {
                SysPushErrorMem();
                continue;
            }

            if (!AuTryResize(strHeap, strtab.sh_size))
            {
                SysPushErrorMem();
                continue;
            }

            object->SetOffset(strtab.sh_offset);
            if (!object->Read(AuMemoryViewStreamWrite(AuMemoryViewWrite(strHeap.data(),
                                                                        strHeap.size()
                                                                        ),
                                                      read)))
            {
                SysPushErrorIO();
                continue;
            }

            Sections modSections;
            for (const auto & section : elfSections)
            {
                if (section.sh_name > strHeap.size())
                {
                    continue;
                }
                
                auto len = strnlen((const char *)strHeap.data() + section.sh_name, strHeap.size() - section.sh_name);
                AuString sectionName((const char *)strHeap.data() + section.sh_name, len);
                AuUInt fileOffset = section.sh_offset;
                AuUInt programOffset = section.sh_addr;

                Section sect {};
                sect.origVa = section.sh_addr;
                sect.baseVa = 0;

                for (const auto & [base, offset, size, flags] : sections)
                {
                    if ((offset <= fileOffset) &&
                       ((offset + size) > fileOffset) && fileOffset && offset)
                    {
                        sect.pt.readable = section.sh_addr ? (section.sh_flags & SHF_ALLOC) : false;//?

                        auto baseOfMap = baseAddress;
                        auto offsetInMap = fileOffset - offset;

                        sect.baseVa = (baseOfMap + base) + offsetInMap;
                    }
                }

                sect.size   = section.sh_size;
                sect.fsOff  = fileOffset;

                sect.pt.NX       = !(section.sh_flags & SHF_EXECINSTR);
                sect.pt.writable = section.sh_flags & SHF_WRITE;

                if (!sect.pt.readable)
                {
                    sect.baseVa = 0;
                }

                sect.name = sectionName;

                if (sect.fsOff || sect.size)
                {
                    AuTryInsert(modSections, sect);
                }
            }

            auto pub = AuMakeShared<PublicModule>();
            if (!pub) return;

            pub->moduleMeta = AuMakeShared<ModuleMeta>();
            if (!pub->moduleMeta) return;

            pub->moduleMeta->moduleBase = baseAddress;
            pub->moduleMeta->moduleName = AuMove(file);
            pub->moduleMeta->modulePath = AuMove(path);
            pub->moduleMeta->origVa = 0;

            pub->sections = AuMove(modSections);

            // TODO: ...
            InsertModuleCache(ModuleBasePair{pub->moduleMeta->moduleName, baseAddress + AuGet<0>(sections[0])}, pub);
        }
    }

    static void PassFourAdd()
    {
        // TODO: ?
    }

    void RescanMaps()
    {
        PassOneScanLd();
        PassTwoScanMaps();
        PassThreeGatherMissingProgNames();
        PassFourAdd();
    }
}