Commit 01ef6b9e authored by Alex Bennée's avatar Alex Bennée
Browse files

linux-user: factor out reading of /proc/self/maps 



Unfortunately reading /proc/self/maps is still considered the gold
standard for a process finding out about it's own memory layout. As we
will want this data in other contexts soon factor out the code to read
and parse the data. Rather than just blindly copying the existing
sscanf based code we use a more modern glib version of the parsing
code to make a more general purpose map structure.

Signed-off-by: default avatarAlex Bennée <alex.bennee@linaro.org>
Message-Id: <20200403191150.863-9-alex.bennee@linaro.org>
parent 2f311075

include/qemu/selfmap.h

0 → 100644
+44 −0
Original line number Diff line number Diff line 
/*

 * Utility functions to read our own memory map

 *

 * Copyright (c) 2020 Linaro Ltd

 *

 * SPDX-License-Identifier: GPL-2.0-or-later

 */



#ifndef _SELFMAP_H_

#define _SELFMAP_H_



typedef struct {

    unsigned long start;

    unsigned long end;



    /* flags */

    bool is_read;

    bool is_write;

    bool is_exec;

    bool is_priv;



    unsigned long offset;

    gchar *dev;

    uint64_t inode;

    gchar *path;

} MapInfo;





/**

 * read_self_maps:

 *

 * Read /proc/self/maps and return a list of MapInfo structures.

 */

GSList *read_self_maps(void);



/**

 * free_self_maps:

 * @info: a GSlist

 *

 * Free a list of MapInfo structures.

 */

void free_self_maps(GSList *info);



#endif /* _SELFMAP_H_ */

linux-user/syscall.c

+28 −30
Original line number Diff line number Diff line
@@ -117,6 +117,7 @@ 


#include "qemu.h"

#include "qemu/guest-random.h"

#include "qemu/selfmap.h"

#include "user/syscall-trace.h"

#include "qapi/error.h"

#include "fd-trans.h"
@@ -7232,45 +7233,45 @@ static int open_self_maps(void *cpu_env, int fd) 
{

    CPUState *cpu = env_cpu((CPUArchState *)cpu_env);

    TaskState *ts = cpu->opaque;

    FILE *fp;

    char *line = NULL;

    size_t len = 0;

    ssize_t read;

    GSList *map_info = read_self_maps();

    GSList *s;



    fp = fopen("/proc/self/maps", "r");

    if (fp == NULL) {

        return -1;

    }

    for (s = map_info; s; s = g_slist_next(s)) {

        MapInfo *e = (MapInfo *) s->data;



    while ((read = getline(&line, &len, fp)) != -1) {

        int fields, dev_maj, dev_min, inode;

        uint64_t min, max, offset;

        char flag_r, flag_w, flag_x, flag_p;

        char path[512] = "";

        fields = sscanf(line, "%"PRIx64"-%"PRIx64" %c%c%c%c %"PRIx64" %x:%x %d"

                        " %512s", &min, &max, &flag_r, &flag_w, &flag_x,

                        &flag_p, &offset, &dev_maj, &dev_min, &inode, path);



        if ((fields < 10) || (fields > 11)) {

            continue;

        }

        if (h2g_valid(min)) {

        if (h2g_valid(e->start)) {

            unsigned long min = e->start;

            unsigned long max = e->end;

            int flags = page_get_flags(h2g(min));

            max = h2g_valid(max - 1) ? max : (uintptr_t)g2h(GUEST_ADDR_MAX) + 1;

            const char *path;



            max = h2g_valid(max - 1) ?

                max : (uintptr_t) g2h(GUEST_ADDR_MAX) + 1;



            if (page_check_range(h2g(min), max - min, flags) == -1) {

                continue;

            }



            if (h2g(min) == ts->info->stack_limit) {

                pstrcpy(path, sizeof(path), "      [stack]");

                path = "      [stack]";

            } else {

                path = e->path;

            }



            dprintf(fd, TARGET_ABI_FMT_ptr "-" TARGET_ABI_FMT_ptr

                    " %c%c%c%c %08" PRIx64 " %02x:%02x %d %s%s\n",

                    h2g(min), h2g(max - 1) + 1, flag_r, flag_w,

                    flag_x, flag_p, offset, dev_maj, dev_min, inode,

                    path[0] ? "         " : "", path);

                    " %c%c%c%c %08" PRIx64 " %s %"PRId64" %s%s\n",

                    h2g(min), h2g(max - 1) + 1,

                    e->is_read ? 'r' : '-',

                    e->is_write ? 'w' : '-',

                    e->is_exec ? 'x' : '-',

                    e->is_priv ? 'p' : '-',

                    (uint64_t) e->offset, e->dev, e->inode,

                    path ? "         " : "", path ? path : "");

        }

    }



    free_self_maps(map_info);



#ifdef TARGET_VSYSCALL_PAGE

    /*

     * We only support execution from the vsyscall page.
@@ -7281,9 +7282,6 @@ static int open_self_maps(void *cpu_env, int fd) 
            TARGET_VSYSCALL_PAGE, TARGET_VSYSCALL_PAGE + TARGET_PAGE_SIZE);

#endif



    free(line);

    fclose(fp);



    return 0;

}

util/Makefile.objs

+1 −0
Original line number Diff line number Diff line
@@ -63,3 +63,4 @@ util-obj-y += guest-random.o 
util-obj-$(CONFIG_GIO) += dbus.o

dbus.o-cflags = $(GIO_CFLAGS)

dbus.o-libs = $(GIO_LIBS)

util-obj-$(CONFIG_USER_ONLY) += selfmap.o

util/selfmap.c

0 → 100644
+78 −0
Original line number Diff line number Diff line 
/*

 * Utility function to get QEMU's own process map

 *

 * Copyright (c) 2020 Linaro Ltd

 *

 * SPDX-License-Identifier: GPL-2.0-or-later

 */



#include "qemu/osdep.h"

#include "qemu/cutils.h"

#include "qemu/selfmap.h"



GSList *read_self_maps(void)

{

    gchar *maps;

    GSList *map_info = NULL;



    if (g_file_get_contents("/proc/self/maps", &maps, NULL, NULL)) {

        gchar **lines = g_strsplit(maps, "\n", 0);

        int i, entries = g_strv_length(lines);



        for (i = 0; i < entries; i++) {

            gchar **fields = g_strsplit(lines[i], " ", 6);

            if (g_strv_length(fields) > 4) {

                MapInfo *e = g_new0(MapInfo, 1);

                int errors;

                const char *end;



                errors  = qemu_strtoul(fields[0], &end, 16, &e->start);

                errors += qemu_strtoul(end + 1, NULL, 16, &e->end);



                e->is_read  = fields[1][0] == 'r';

                e->is_write = fields[1][1] == 'w';

                e->is_exec  = fields[1][2] == 'x';

                e->is_priv  = fields[1][3] == 'p';



                errors += qemu_strtoul(fields[2], NULL, 16, &e->offset);

                e->dev = g_strdup(fields[3]);

                errors += qemu_strtou64(fields[4], NULL, 10, &e->inode);



                /*

                 * The last field may have leading spaces which we

                 * need to strip.

                 */

                if (g_strv_length(fields) == 6) {

                    e->path = g_strdup(g_strchug(fields[5]));

                }

                map_info = g_slist_prepend(map_info, e);

            }



            g_strfreev(fields);

        }

        g_strfreev(lines);

        g_free(maps);

    }



    /* ensure the map data is in the same order we collected it */

    return g_slist_reverse(map_info);

}



/**

 * free_self_maps:

 * @info: a GSlist

 *

 * Free a list of MapInfo structures.

 */

static void free_info(gpointer data)

{

    MapInfo *e = (MapInfo *) data;

    g_free(e->dev);

    g_free(e->path);

    g_free(e);

}



void free_self_maps(GSList *info)

{

    g_slist_free_full(info, &free_info);

}