GNU/Linux >> LINUX-Kenntnisse >  >> Linux

/proc/[pid]/pagemaps und /proc/[pid]/maps | Linux

F**/proc/<pid>/pagemap + /proc/<pid>/maps dump-Beispielprogramm**

Hier ist ein pagemap Beispiel, das virtuelle Adressen in physische umwandelt:Gibt es eine API zur Bestimmung der physischen Adresse aus der virtuellen Adresse in Linux?

Das folgende Programm verwendet beide /proc/<pid>/pagemap + /proc/<pid>/maps um Seitentabelleninformationen auszugeben, um zu zeigen, wie sie zusammen verwendet werden können. Verwendung:

sudo ./pagemap_dump.out <pid>

Beispielausgabe:

addr pfn soft-dirty file/shared swapped present library
400000 12845d 0 1 0 1 /bin/bash
401000 12845e 0 1 0 1 /bin/bash
402000 12845f 0 1 0 1 /bin/bash

Das sagt uns zum Beispiel, dass die virtuelle Adresse 0x400000 wird auf die physikalische Adresse 0x12845d000 abgebildet .

Warum sudo ist erforderlich:https://unix.stackexchange.com/questions/345915/how-to-change-permission-of-proc-self-pagemap-file/383838#383838

Dieses Programm arbeitet in zwei Schritten:

  • Analysieren Sie die für Menschen lesbaren Zeilen Zeilen von /proc/<pid>/maps . Diese Datei enthält Zeilen der Form:

    7ffff7b6d000-7ffff7bdd000 r-xp 00000000 fe:00 658                        /lib/libuClibc-1.0.22.so
    

    was uns gibt:

    • 7f8af99f8000-7f8af99ff000 :ein virtueller Adressbereich, der zum Prozess gehört und möglicherweise mehrere Seiten enthält.
    • /lib/libuClibc-1.0.22.so der Name der Bibliothek, die diesen Speicher besitzt.
  • Durchlaufen Sie jede Seite jedes Adressbereichs und fragen Sie /proc/<pid>/pagemap für weitere Informationen über diese Seite, einschließlich der physischen Adresse.

pagemap_dump.c

#define _XOPEN_SOURCE 700
#include <errno.h>
#include <fcntl.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>

typedef struct {
    uint64_t pfn : 55;
    unsigned int soft_dirty : 1;
    unsigned int file_page : 1;
    unsigned int swapped : 1;
    unsigned int present : 1;
} PagemapEntry;

/* Parse the pagemap entry for the given virtual address.
 *
 * @param[out] entry      the parsed entry
 * @param[in]  pagemap_fd file descriptor to an open /proc/pid/pagemap file
 * @param[in]  vaddr      virtual address to get entry for
 * @return 0 for success, 1 for failure
 */
int pagemap_get_entry(PagemapEntry *entry, int pagemap_fd, uintptr_t vaddr)
{
    size_t nread;
    ssize_t ret;
    uint64_t data;

    nread = 0;
    while (nread < sizeof(data)) {
        ret = pread(pagemap_fd, ((uint8_t*)&data) + nread, sizeof(data) - nread,
                (vaddr / sysconf(_SC_PAGE_SIZE)) * sizeof(data) + nread);
        nread += ret;
        if (ret <= 0) {
            return 1;
        }
    }
    entry->pfn = data & (((uint64_t)1 << 55) - 1);
    entry->soft_dirty = (data >> 55) & 1;
    entry->file_page = (data >> 61) & 1;
    entry->swapped = (data >> 62) & 1;
    entry->present = (data >> 63) & 1;
    return 0;
}

/* Convert the given virtual address to physical using /proc/PID/pagemap.
 *
 * @param[out] paddr physical address
 * @param[in]  pid   process to convert for
 * @param[in] vaddr virtual address to get entry for
 * @return 0 for success, 1 for failure
 */
int virt_to_phys_user(uintptr_t *paddr, pid_t pid, uintptr_t vaddr)
{
    char pagemap_file[BUFSIZ];
    int pagemap_fd;

    snprintf(pagemap_file, sizeof(pagemap_file), "/proc/%ju/pagemap", (uintmax_t)pid);
    pagemap_fd = open(pagemap_file, O_RDONLY);
    if (pagemap_fd < 0) {
        return 1;
    }
    PagemapEntry entry;
    if (pagemap_get_entry(&entry, pagemap_fd, vaddr)) {
        return 1;
    }
    close(pagemap_fd);
    *paddr = (entry.pfn * sysconf(_SC_PAGE_SIZE)) + (vaddr % sysconf(_SC_PAGE_SIZE));
    return 0;
}

int main(int argc, char **argv)
{
    char buffer[BUFSIZ];
    char maps_file[BUFSIZ];
    char pagemap_file[BUFSIZ];
    int maps_fd;
    int offset = 0;
    int pagemap_fd;
    pid_t pid;

    if (argc < 2) {
        printf("Usage: %s pid\n", argv[0]);
        return EXIT_FAILURE;
    }
    pid = strtoull(argv[1], NULL, 0);
    snprintf(maps_file, sizeof(maps_file), "/proc/%ju/maps", (uintmax_t)pid);
    snprintf(pagemap_file, sizeof(pagemap_file), "/proc/%ju/pagemap", (uintmax_t)pid);
    maps_fd = open(maps_file, O_RDONLY);
    if (maps_fd < 0) {
        perror("open maps");
        return EXIT_FAILURE;
    }
    pagemap_fd = open(pagemap_file, O_RDONLY);
    if (pagemap_fd < 0) {
        perror("open pagemap");
        return EXIT_FAILURE;
    }
    printf("addr pfn soft-dirty file/shared swapped present library\n");
    for (;;) {
        ssize_t length = read(maps_fd, buffer + offset, sizeof buffer - offset);
        if (length <= 0) break;
        length += offset;
        for (size_t i = offset; i < (size_t)length; i++) {
            uintptr_t low = 0, high = 0;
            if (buffer[i] == '\n' && i) {
                const char *lib_name;
                size_t y;
                /* Parse a line from maps. Each line contains a range that contains many pages. */
                {
                    size_t x = i - 1;
                    while (x && buffer[x] != '\n') x--;
                    if (buffer[x] == '\n') x++;
                    while (buffer[x] != '-' && x < sizeof buffer) {
                        char c = buffer[x++];
                        low *= 16;
                        if (c >= '0' && c <= '9') {
                            low += c - '0';
                        } else if (c >= 'a' && c <= 'f') {
                            low += c - 'a' + 10;
                        } else {
                            break;
                        }
                    }
                    while (buffer[x] != '-' && x < sizeof buffer) x++;
                    if (buffer[x] == '-') x++;
                    while (buffer[x] != ' ' && x < sizeof buffer) {
                        char c = buffer[x++];
                        high *= 16;
                        if (c >= '0' && c <= '9') {
                            high += c - '0';
                        } else if (c >= 'a' && c <= 'f') {
                            high += c - 'a' + 10;
                        } else {
                            break;
                        }
                    }
                    lib_name = 0;
                    for (int field = 0; field < 4; field++) {
                        x++;
                        while(buffer[x] != ' ' && x < sizeof buffer) x++;
                    }
                    while (buffer[x] == ' ' && x < sizeof buffer) x++;
                    y = x;
                    while (buffer[y] != '\n' && y < sizeof buffer) y++;
                    buffer[y] = 0;
                    lib_name = buffer + x;
                }
                /* Get info about all pages in this page range with pagemap. */
                {
                    PagemapEntry entry;
                    for (uintptr_t addr = low; addr < high; addr += sysconf(_SC_PAGE_SIZE)) {
                        /* TODO always fails for the last page (vsyscall), why? pread returns 0. */
                        if (!pagemap_get_entry(&entry, pagemap_fd, addr)) {
                            printf("%jx %jx %u %u %u %u %s\n",
                                (uintmax_t)addr,
                                (uintmax_t)entry.pfn,
                                entry.soft_dirty,
                                entry.file_page,
                                entry.swapped,
                                entry.present,
                                lib_name
                            );
                        }
                    }
                }
                buffer[y] = '\n';
            }
        }
    }
    close(maps_fd);
    close(pagemap_fd);
    return EXIT_SUCCESS;
}

Oooh K, der Index war korrekt, aber der Vergleich von off64_to (8 Bytes) mit dem langen Index hat o falsch interpretiert, weshalb ich diesen Fehler bekam. Ha! das war ein dummer Fehler. Also hat das Hinzufügen des entsprechenden Headers dafür gesorgt.

Fehlender Header :-/ seufz behebt das Problem des Vergleichs von off64_t mit einem unsigned long.


Verwenden Sie page-types.c als Leitfaden für das, wonach Sie suchen, es parst den Inhalt von Pagemap und Maps:https://git.kernel.org/cgit/linux/kernel/git/stable/linux-stable. git/plain/Documentation/vm/page-types.c?h=linux-2.6.32.y


Linux
  1. Installieren Sie Binärdateien in /bin, /sbin, /usr/bin und /usr/sbin, Interaktionen mit --prefix und DESTDIR

  2. Wann sollte ich /dev/shm/ verwenden und wann sollte ich /tmp/?

  3. Gelöschte Datei wiederherstellen, in die gerade geschrieben wird

  4. Linux:Unterschied zwischen /dev/console , /dev/tty und /dev/tty0

  5. Sollten Websites gemäß der empfohlenen Verwendung in /var/ oder /usr/ leben?

/proc/cpuinfo- und /proc/meminfo-Dateien unter Linux

Die Dateien /proc/mounts, /etc/mtab und /proc/partitions verstehen

Verständnis von Linux /proc/id/maps

linux /proc/loadavg

Wie finde ich heraus, aus welchem ​​Ordner ein Prozess läuft?

Wie Linux /dev/tty und /dev/tty0 verwendet