error_t OProcessImpl::AccessProcessMemory(user_addr_t address, void * buffer, size_t length, bool read)
{
    rw_semaphore_k semaphore;
    uint32_t pages;
    page_k *page_array;
    user_addr_t start;
    uint32_t TODO;
    size_t remaining;
    size_t written;
    mm_struct_k  mm;

    if (ERROR(_int_err))
        return _int_err;

    if (length == 0)
        return kErrorIllegalArgLength;

    if (!address)
        return kErrorIllegalBadArgument;

    if (!buffer)
        return kErrorIllegalBadArgument;

    mm = (mm_struct_k)task_get_mm_size_t(_tsk);

    if (!mm)
        return kErrorInternalError;

    start = (user_addr_t)(size_t(address) & (kernel_information.LINUX_PAGE_MASK));

    pages = (length / kernel_information.LINUX_PAGE_SIZE) + 1;
    page_array = (page_k *)zalloc(pages * sizeof(page_k));

    if (!page_array)
        return kErrorInternalError;

    semaphore = (rw_semaphore_k)mm_struct_get_mmap_sem(mm); // &mm->mmap_sem
    down_read(semaphore);                                   // lock semaphore

    TODO = get_user_pages_remote(_tsk, mm, (l_unsigned_long)start, pages, FOLL_FORCE, page_array, NULL, NULL); // WHAT DOES THIS RETURN?

    remaining = length;
    written = 0;
    for (uint32_t pg = 0; pg < pages; pg++)
    {
        void * mapped;
        size_t pg_offset;
        size_t segment_length;

        segment_length = MIN(remaining, kernel_information.LINUX_PAGE_SIZE);

        if (remaining)
        {
            uint64_t pfn;
            phys_addr_t physaddr;
            void * x64_map;

            pfn = linux_page_to_pfn(page_array[pg]);
            physaddr = phys_addr_t(pfn << kernel_information.LINUX_PAGE_SHIFT);
            x64_map = (void*)(size_t(physaddr) + page_offset_base); // x86_64 only - consider iomap on other archs this if targeting such. iiirc arm supports WANT_PAGE_VIRTUALADDR

            pg_offset = 0;
            if ((pg == 0) && (start != address))
                pg_offset = size_t(address) - size_t(start);

            // i dont even care at this point
            if (read)
                memcpy((void *)(size_t(buffer) + written), (void *)(size_t(x64_map) + pg_offset), segment_length);
            else
                memcpy((void *)(size_t(x64_map) + pg_offset), (void *)(size_t(buffer) + written), segment_length);
        }

        remaining -= segment_length;
        written += segment_length;
    }

    up_read(semaphore);                                     // unlock semaphore
    free(page_array);

    return kStatusOkay;
}