mirror of
https://github.com/varun-r-mallya/sysprof.git
synced 2025-12-31 20:36:25 +00:00
start on new resolver for paths
This commit is contained in:
Christian Hergert
@ -109,7 +109,7 @@ libsysprof_ui = shared_library(
|
||||
'sysprof-ui-@0@'.format(libsysprof_api_version),
|
||||
libsysprof_ui_public_sources + libsysprof_ui_private_sources + libsysprof_ui_resources,
|
||||
|
||||
dependencies: libsysprof_ui_deps,
|
||||
dependencies: libsysprof_ui_deps + [librax_dep],
|
||||
install_dir: get_option('libdir'),
|
||||
install: true,
|
||||
c_args: [ '-DSYSPROF_UI_COMPILATION' ],
|
||||
|
||||
@ -79,6 +79,7 @@ libsysprof_private_sources = [
|
||||
'sysprof-line-reader.c',
|
||||
'sysprof-map-lookaside.c',
|
||||
'sysprof-mountinfo.c',
|
||||
'sysprof-path-resolver.c',
|
||||
'sysprof-podman.c',
|
||||
'sysprof-polkit.c',
|
||||
'sysprof-symbol-map.c',
|
||||
@ -90,9 +91,10 @@ libsysprof_private_sources = [
|
||||
libsysprof_public_sources += libsysprof_capture_sources
|
||||
|
||||
librax = static_library('rax', ['rax.c'],
|
||||
c_args: [ '-Wno-declaration-after-statement',
|
||||
'-Wno-format-nonliteral',
|
||||
'-Wno-shadow' ],
|
||||
c_args: [ '-Wno-declaration-after-statement',
|
||||
'-Wno-format-nonliteral',
|
||||
'-Wno-shadow' ],
|
||||
gnu_symbol_visibility: 'hidden',
|
||||
)
|
||||
|
||||
librax_dep = declare_dependency(
|
||||
@ -139,10 +141,7 @@ if host_machine.system() == 'darwin'
|
||||
libsysprof_c_args += [ '-DNT_GNU_BUILD_ID=3', '-DELF_NOTE_GNU="GNU"', '-D__LIBELF_INTERNAL__' ]
|
||||
endif
|
||||
|
||||
# Meson's pkgconfig module doesn't understand this one
|
||||
libsysprof_deps = libsysprof_pkg_deps + [
|
||||
librax_dep,
|
||||
]
|
||||
libsysprof_deps = libsysprof_pkg_deps
|
||||
|
||||
libsysprof_libs_private = []
|
||||
|
||||
@ -151,8 +150,8 @@ if host_machine.system() != 'darwin'
|
||||
libsysprof_libs_private += '-lstdc++'
|
||||
endif
|
||||
|
||||
libsysprof = shared_library(
|
||||
'sysprof-@0@'.format(libsysprof_api_version),
|
||||
libsysprof_static = static_library(
|
||||
'sysprof',
|
||||
libsysprof_public_sources + libsysprof_private_sources,
|
||||
|
||||
include_directories: [include_directories('.'),
|
||||
@ -160,9 +159,19 @@ libsysprof = shared_library(
|
||||
libsysprof_capture_include_dirs],
|
||||
dependencies: libsysprof_deps,
|
||||
c_args: libsysprof_c_args,
|
||||
gnu_symbol_visibility: 'hidden',
|
||||
)
|
||||
|
||||
libsysprof_static_dep = declare_dependency(
|
||||
link_whole: libsysprof_static,
|
||||
dependencies: libsysprof_deps + [librax_dep],
|
||||
include_directories: [include_directories('.'), libsysprof_capture_include_dirs],
|
||||
)
|
||||
|
||||
libsysprof = shared_library('sysprof-@0@'.format(libsysprof_api_version),
|
||||
dependencies: libsysprof_deps + [libsysprof_static_dep],
|
||||
install: true,
|
||||
install_dir: get_option('libdir'),
|
||||
gnu_symbol_visibility: 'hidden',
|
||||
)
|
||||
|
||||
libsysprof_dep = declare_dependency(
|
||||
|
||||
@ -298,6 +298,9 @@ sysprof_mountinfo_parse_mountinfo_line (SysprofMountinfo *self,
|
||||
while (*src == '/')
|
||||
src++;
|
||||
|
||||
if (*src == 0)
|
||||
return;
|
||||
|
||||
if (prefix != NULL)
|
||||
m.host_path = g_build_filename (prefix, src, NULL);
|
||||
else
|
||||
@ -340,4 +343,10 @@ sysprof_mountinfo_parse_mountinfo (SysprofMountinfo *self,
|
||||
sysprof_mountinfo_parse_mountinfo_line (self, lines[i]);
|
||||
|
||||
g_array_sort (self->mountinfos, sort_by_length);
|
||||
|
||||
for (guint i = 0; i < self->mountinfos->len; i++)
|
||||
{
|
||||
const Mountinfo *m = &g_array_index (self->mountinfos, Mountinfo, i);
|
||||
g_print ("MM %s => %s\n", m->host_path, m->mount_path);
|
||||
}
|
||||
}
|
||||
|
||||
554
src/libsysprof/sysprof-path-resolver.c
Normal file
554
src/libsysprof/sysprof-path-resolver.c
Normal file
@ -0,0 +1,554 @@
|
||||
/* sysprof-path-resolver.c
|
||||
*
|
||||
* Copyright 2021 Christian Hergert <chergert@redhat.com>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*
|
||||
* SPDX-License-Identifier: GPL-3.0-or-later
|
||||
*/
|
||||
|
||||
#include "config.h"
|
||||
|
||||
#include <string.h>
|
||||
|
||||
#include "sysprof-path-resolver.h"
|
||||
|
||||
struct _SysprofPathResolver
|
||||
{
|
||||
GArray *mounts;
|
||||
GArray *mountpoints;
|
||||
};
|
||||
|
||||
typedef struct
|
||||
{
|
||||
/* The path on the host system */
|
||||
char *on_host;
|
||||
|
||||
/* The path inside the process domain */
|
||||
char *in_process;
|
||||
|
||||
/* The length of @in_process in bytes */
|
||||
guint in_process_len;
|
||||
|
||||
/* The depth of the mount (for FUSE overlays) */
|
||||
int depth;
|
||||
} Mountpoint;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
char *device;
|
||||
char *mountpoint;
|
||||
char *filesystem;
|
||||
char *subvolid;
|
||||
char *subvol;
|
||||
} Mount;
|
||||
|
||||
typedef struct _st_mountinfo
|
||||
{
|
||||
char *id;
|
||||
char *parent_id;
|
||||
char *st_dev;
|
||||
char *root;
|
||||
char *mount_point;
|
||||
char *mount_options;
|
||||
char *filesystem;
|
||||
char *mount_source;
|
||||
char *super_options;
|
||||
} st_mountinfo;
|
||||
|
||||
static void
|
||||
clear_st_mountinfo (st_mountinfo *st)
|
||||
{
|
||||
g_free (st->id);
|
||||
g_free (st->parent_id);
|
||||
g_free (st->st_dev);
|
||||
g_free (st->root);
|
||||
g_free (st->mount_point);
|
||||
g_free (st->mount_options);
|
||||
g_free (st->filesystem);
|
||||
g_free (st->mount_source);
|
||||
g_free (st->super_options);
|
||||
}
|
||||
|
||||
G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC (st_mountinfo, clear_st_mountinfo)
|
||||
|
||||
static void
|
||||
clear_mount (Mount *m)
|
||||
{
|
||||
g_clear_pointer (&m->device, g_free);
|
||||
g_clear_pointer (&m->mountpoint, g_free);
|
||||
g_clear_pointer (&m->subvolid, g_free);
|
||||
g_clear_pointer (&m->subvol, g_free);
|
||||
g_clear_pointer (&m->filesystem, g_free);
|
||||
}
|
||||
|
||||
static void
|
||||
clear_mountpoint (Mountpoint *mp)
|
||||
{
|
||||
g_clear_pointer (&mp->on_host, g_free);
|
||||
g_clear_pointer (&mp->in_process, g_free);
|
||||
}
|
||||
|
||||
static gboolean
|
||||
ignore_fs (const char *fs)
|
||||
{
|
||||
static gsize initialized;
|
||||
static GHashTable *ignored;
|
||||
|
||||
if (g_once_init_enter (&initialized))
|
||||
{
|
||||
ignored = g_hash_table_new (g_str_hash, g_str_equal);
|
||||
g_hash_table_add (ignored, (char *)"autofs");
|
||||
g_hash_table_add (ignored, (char *)"binfmt_misc");
|
||||
g_hash_table_add (ignored, (char *)"bpf");
|
||||
g_hash_table_add (ignored, (char *)"cgroup");
|
||||
g_hash_table_add (ignored, (char *)"cgroup2");
|
||||
g_hash_table_add (ignored, (char *)"configfs");
|
||||
g_hash_table_add (ignored, (char *)"debugfs");
|
||||
g_hash_table_add (ignored, (char *)"devpts");
|
||||
g_hash_table_add (ignored, (char *)"devtmpfs");
|
||||
g_hash_table_add (ignored, (char *)"efivarfs");
|
||||
g_hash_table_add (ignored, (char *)"fusectl");
|
||||
g_hash_table_add (ignored, (char *)"hugetlbfs");
|
||||
g_hash_table_add (ignored, (char *)"mqueue");
|
||||
g_hash_table_add (ignored, (char *)"none");
|
||||
g_hash_table_add (ignored, (char *)"portal");
|
||||
g_hash_table_add (ignored, (char *)"proc");
|
||||
g_hash_table_add (ignored, (char *)"pstore");
|
||||
g_hash_table_add (ignored, (char *)"ramfs");
|
||||
g_hash_table_add (ignored, (char *)"rpc_pipefs");
|
||||
g_hash_table_add (ignored, (char *)"securityfs");
|
||||
g_hash_table_add (ignored, (char *)"selinuxfs");
|
||||
g_hash_table_add (ignored, (char *)"sunrpc");
|
||||
g_hash_table_add (ignored, (char *)"sysfs");
|
||||
g_hash_table_add (ignored, (char *)"systemd-1");
|
||||
g_hash_table_add (ignored, (char *)"tmpfs");
|
||||
g_hash_table_add (ignored, (char *)"tracefs");
|
||||
g_once_init_leave (&initialized, (gsize)1);
|
||||
}
|
||||
|
||||
if (g_str_has_prefix (fs, "fuse."))
|
||||
return TRUE;
|
||||
|
||||
return g_hash_table_contains (ignored, fs);
|
||||
}
|
||||
|
||||
static char *
|
||||
path_copy_with_trailing_slash (const char *path)
|
||||
{
|
||||
if (g_str_has_suffix (path, "/"))
|
||||
return g_strdup (path);
|
||||
else
|
||||
return g_strdup_printf ("%s/", path);
|
||||
}
|
||||
|
||||
static void
|
||||
decode_space (char **str)
|
||||
{
|
||||
/* Replace encoded space "\040" with ' ' */
|
||||
if (strstr (*str, "\\040") != NULL)
|
||||
{
|
||||
g_auto(GStrv) parts = g_strsplit (*str, "\\040", 0);
|
||||
g_free (*str);
|
||||
*str = g_strjoinv (" ", parts);
|
||||
}
|
||||
}
|
||||
|
||||
static char *
|
||||
strdup_decode_space (const char *str)
|
||||
{
|
||||
char *copy = g_strdup (str);
|
||||
decode_space (©);
|
||||
return copy;
|
||||
}
|
||||
|
||||
static gboolean
|
||||
has_prefix_or_equal (const char *str,
|
||||
const char *prefix)
|
||||
{
|
||||
return g_str_has_prefix (str, prefix) || strcmp (str, prefix) == 0;
|
||||
}
|
||||
|
||||
static char *
|
||||
get_option (const char *options,
|
||||
const char *option)
|
||||
{
|
||||
g_auto(GStrv) parts = NULL;
|
||||
|
||||
g_assert (option != NULL);
|
||||
g_assert (g_str_has_suffix (option, "="));
|
||||
|
||||
if (options == NULL)
|
||||
return NULL;
|
||||
|
||||
parts = g_strsplit (options, ",", 0);
|
||||
|
||||
for (guint i = 0; parts[i] != NULL; i++)
|
||||
{
|
||||
if (g_str_has_prefix (parts[i], option))
|
||||
{
|
||||
const char *ret = parts[i] + strlen (option);
|
||||
|
||||
/* Easier to handle "" as NULL */
|
||||
if (*ret == 0)
|
||||
return NULL;
|
||||
|
||||
return g_strdup (ret);
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static gboolean
|
||||
parse_st_mountinfo (st_mountinfo *mi,
|
||||
const char *line)
|
||||
{
|
||||
g_auto(GStrv) parts = NULL;
|
||||
guint i;
|
||||
|
||||
g_assert (mi != NULL);
|
||||
g_assert (line != NULL);
|
||||
|
||||
memset (mi, 0, sizeof *mi);
|
||||
|
||||
parts = g_strsplit (line, " ", 0);
|
||||
if (g_strv_length (parts) < 10)
|
||||
return FALSE;
|
||||
|
||||
mi->id = g_strdup (parts[0]);
|
||||
mi->parent_id = g_strdup (parts[1]);
|
||||
mi->st_dev = g_strdup (parts[2]);
|
||||
mi->root = strdup_decode_space (parts[3]);
|
||||
mi->mount_point = strdup_decode_space (parts[4]);
|
||||
mi->mount_options = strdup_decode_space (parts[5]);
|
||||
|
||||
for (i = 6; parts[i] != NULL && !g_str_equal (parts[i], "-"); i++)
|
||||
{
|
||||
/* Do nothing. We just want to skip until after the optional tags
|
||||
* section which is finished with " - ".
|
||||
*/
|
||||
}
|
||||
|
||||
/* Skip past - if there is anything */
|
||||
if (parts[i] == NULL || parts[++i] == NULL)
|
||||
return TRUE;
|
||||
|
||||
/* Get filesystem if provided */
|
||||
mi->filesystem = g_strdup (parts[i++]);
|
||||
if (parts[i] == NULL)
|
||||
return TRUE;
|
||||
|
||||
/* Get mount source if provided */
|
||||
mi->mount_source = strdup_decode_space (parts[i++]);
|
||||
if (parts[i] == NULL)
|
||||
return TRUE;
|
||||
|
||||
/* Get super options if provided */
|
||||
mi->super_options = strdup_decode_space (parts[i++]);
|
||||
if (parts[i] == NULL)
|
||||
return TRUE;
|
||||
|
||||
/* Perhaps mountinfo will be extended once again ... */
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static void
|
||||
parse_mounts (SysprofPathResolver *self,
|
||||
const char *mounts)
|
||||
{
|
||||
g_auto(GStrv) lines = NULL;
|
||||
|
||||
g_assert (self != NULL);
|
||||
g_assert (self->mounts != NULL);
|
||||
g_assert (mounts != NULL);
|
||||
|
||||
lines = g_strsplit (mounts, "\n", 0);
|
||||
|
||||
for (guint i = 0; lines[i]; i++)
|
||||
{
|
||||
g_auto(GStrv) parts = g_strsplit (lines[i], " ", 5);
|
||||
g_autofree char *subvolid = NULL;
|
||||
g_autofree char *subvol = NULL;
|
||||
const char *filesystem;
|
||||
const char *mountpoint;
|
||||
const char *device;
|
||||
const char *options;
|
||||
Mount m;
|
||||
|
||||
/* Field 0: device
|
||||
* Field 1: mountpoint
|
||||
* Field 2: filesystem
|
||||
* Field 3: Options
|
||||
* .. Ignored ..
|
||||
*/
|
||||
if (g_strv_length (parts) != 5)
|
||||
continue;
|
||||
|
||||
filesystem = parts[2];
|
||||
if (ignore_fs (filesystem))
|
||||
continue;
|
||||
|
||||
for (guint j = 0; parts[j]; j++)
|
||||
decode_space (&parts[j]);
|
||||
|
||||
device = parts[0];
|
||||
mountpoint = parts[1];
|
||||
options = parts[3];
|
||||
|
||||
|
||||
if (g_strcmp0 (filesystem, "btrfs") == 0)
|
||||
{
|
||||
subvolid = get_option (options, "subvolid=");
|
||||
subvol = get_option (options, "subvol=");
|
||||
}
|
||||
|
||||
m.device = g_strdup (device);
|
||||
m.filesystem = g_strdup (filesystem);
|
||||
m.mountpoint = path_copy_with_trailing_slash (mountpoint);
|
||||
m.subvolid = g_steal_pointer (&subvolid);
|
||||
m.subvol = g_steal_pointer (&subvol);
|
||||
|
||||
g_array_append_val (self->mounts, m);
|
||||
}
|
||||
}
|
||||
|
||||
static const Mount *
|
||||
find_mount (SysprofPathResolver *self,
|
||||
const st_mountinfo *mi)
|
||||
{
|
||||
g_autofree char *subvolid = NULL;
|
||||
|
||||
g_assert (self != NULL);
|
||||
g_assert (mi != NULL);
|
||||
|
||||
subvolid = get_option (mi->super_options, "subvolid=");
|
||||
|
||||
for (guint i = 0; i < self->mounts->len; i++)
|
||||
{
|
||||
const Mount *mount = &g_array_index (self->mounts, Mount, i);
|
||||
|
||||
if (g_strcmp0 (mount->device, mi->mount_source) == 0)
|
||||
{
|
||||
/* Sanity check that filesystems match */
|
||||
if (g_strcmp0 (mount->filesystem, mi->filesystem) != 0)
|
||||
continue;
|
||||
|
||||
/* If we have a subvolume (btrfs) make sure they match */
|
||||
if (subvolid == NULL ||
|
||||
g_strcmp0 (subvolid, mount->subvolid) == 0)
|
||||
return mount;
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void
|
||||
parse_mountinfo_line (SysprofPathResolver *self,
|
||||
const char *line)
|
||||
{
|
||||
g_auto(st_mountinfo) st_mi = {0};
|
||||
g_autofree char *subvol = NULL;
|
||||
const char *path;
|
||||
const Mount *mount;
|
||||
Mountpoint mp = {0};
|
||||
|
||||
g_assert (self != NULL);
|
||||
g_assert (self->mounts != NULL);
|
||||
g_assert (self->mountpoints != NULL);
|
||||
|
||||
if (!parse_st_mountinfo (&st_mi, line))
|
||||
return;
|
||||
|
||||
if (ignore_fs (st_mi.filesystem))
|
||||
return;
|
||||
|
||||
if (!(mount = find_mount (self, &st_mi)))
|
||||
return;
|
||||
|
||||
subvol = get_option (st_mi.super_options, "subvol=");
|
||||
path = st_mi.root;
|
||||
|
||||
/* If the mount root has a prefix of the subvolume, then
|
||||
* subtract that from the path (as we will resolve relative
|
||||
* to the location where it is mounted via the Mount.mountpoint.
|
||||
*/
|
||||
if (subvol != NULL && has_prefix_or_equal (path, subvol))
|
||||
{
|
||||
path += strlen (subvol);
|
||||
if (*path == 0)
|
||||
path = NULL;
|
||||
}
|
||||
|
||||
if (path == NULL)
|
||||
{
|
||||
mp.on_host = g_strdup (mount->mountpoint);
|
||||
}
|
||||
else
|
||||
{
|
||||
while (*path == '/')
|
||||
path++;
|
||||
mp.on_host = g_build_filename (mount->mountpoint, path, NULL);
|
||||
}
|
||||
|
||||
if (g_str_has_suffix (mp.on_host, "/") &&
|
||||
!g_str_has_suffix (st_mi.mount_point, "/"))
|
||||
mp.in_process = g_build_filename (st_mi.mount_point, "/", NULL);
|
||||
else
|
||||
mp.in_process = g_strdup (st_mi.mount_point);
|
||||
|
||||
mp.in_process_len = strlen (mp.in_process);
|
||||
mp.depth = -1;
|
||||
|
||||
g_array_append_val (self->mountpoints, mp);
|
||||
}
|
||||
|
||||
static gint
|
||||
sort_by_length (gconstpointer a,
|
||||
gconstpointer b)
|
||||
{
|
||||
const Mountpoint *mpa = a;
|
||||
const Mountpoint *mpb = b;
|
||||
gsize alen = strlen (mpa->in_process);
|
||||
gsize blen = strlen (mpb->in_process);
|
||||
|
||||
if (alen > blen)
|
||||
return -1;
|
||||
else if (blen > alen)
|
||||
return 1;
|
||||
|
||||
if (mpa->depth < mpb->depth)
|
||||
return -1;
|
||||
else if (mpa->depth > mpb->depth)
|
||||
return 1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void
|
||||
parse_mountinfo (SysprofPathResolver *self,
|
||||
const char *mountinfo)
|
||||
{
|
||||
g_auto(GStrv) lines = NULL;
|
||||
|
||||
g_assert (self != NULL);
|
||||
g_assert (self->mounts != NULL);
|
||||
g_assert (self->mountpoints != NULL);
|
||||
g_assert (mountinfo != NULL);
|
||||
|
||||
lines = g_strsplit (mountinfo, "\n", 0);
|
||||
|
||||
for (guint i = 0; lines[i]; i++)
|
||||
parse_mountinfo_line (self, lines[i]);
|
||||
|
||||
g_array_sort (self->mountpoints, sort_by_length);
|
||||
}
|
||||
|
||||
SysprofPathResolver *
|
||||
_sysprof_path_resolver_new (const char *mounts,
|
||||
const char *mountinfo)
|
||||
{
|
||||
SysprofPathResolver *self;
|
||||
|
||||
self = g_slice_new0 (SysprofPathResolver);
|
||||
|
||||
self->mounts = g_array_new (FALSE, FALSE, sizeof (Mount));
|
||||
self->mountpoints = g_array_new (FALSE, FALSE, sizeof (Mountpoint));
|
||||
|
||||
g_array_set_clear_func (self->mounts, (GDestroyNotify)clear_mount);
|
||||
g_array_set_clear_func (self->mountpoints, (GDestroyNotify)clear_mountpoint);
|
||||
|
||||
if (mounts != NULL)
|
||||
parse_mounts (self, mounts);
|
||||
|
||||
if (mountinfo != NULL)
|
||||
parse_mountinfo (self, mountinfo);
|
||||
|
||||
return self;
|
||||
}
|
||||
|
||||
void
|
||||
_sysprof_path_resolver_free (SysprofPathResolver *self)
|
||||
{
|
||||
g_clear_pointer (&self->mountpoints, g_array_unref);
|
||||
g_clear_pointer (&self->mounts, g_array_unref);
|
||||
g_slice_free (SysprofPathResolver, self);
|
||||
}
|
||||
|
||||
void
|
||||
_sysprof_path_resolver_add_overlay (SysprofPathResolver *self,
|
||||
const char *in_process,
|
||||
const char *on_host,
|
||||
int depth)
|
||||
{
|
||||
Mountpoint mp;
|
||||
|
||||
g_return_if_fail (self != NULL);
|
||||
g_return_if_fail (in_process != NULL);
|
||||
g_return_if_fail (on_host != NULL);
|
||||
|
||||
mp.in_process = path_copy_with_trailing_slash (in_process);
|
||||
mp.in_process_len = strlen (mp.in_process);
|
||||
mp.on_host = path_copy_with_trailing_slash (on_host);
|
||||
mp.depth = depth;
|
||||
|
||||
g_array_append_val (self->mountpoints, mp);
|
||||
g_array_sort (self->mountpoints, sort_by_length);
|
||||
}
|
||||
|
||||
char *
|
||||
_sysprof_path_resolver_resolve (SysprofPathResolver *self,
|
||||
const char *path)
|
||||
{
|
||||
g_return_val_if_fail (self != NULL, NULL);
|
||||
g_return_val_if_fail (path != NULL, NULL);
|
||||
|
||||
/* TODO: Cache the directory name of @path and use that for followup
|
||||
* searches like we did in SysprofMountinfo.
|
||||
*/
|
||||
|
||||
for (guint i = 0; i < self->mountpoints->len; i++)
|
||||
{
|
||||
const Mountpoint *mp = &g_array_index (self->mountpoints, Mountpoint, i);
|
||||
|
||||
if (g_str_has_prefix (path, mp->in_process))
|
||||
{
|
||||
g_autofree char *dst = g_build_filename (mp->on_host,
|
||||
path + mp->in_process_len,
|
||||
NULL);
|
||||
|
||||
/* If the depth is > -1, then we are dealing with an overlay. We
|
||||
* unfortunately have to stat() to see if the file exists and then
|
||||
* skip over this if not.
|
||||
*
|
||||
* TODO: This is going to break when we are recording from within
|
||||
* flatpak as we'll not be able to stat files unless they are
|
||||
* within the current users home, so system containers would
|
||||
* be unlilkely to resolve.
|
||||
*/
|
||||
if (mp->depth > -1)
|
||||
{
|
||||
if (g_file_test (dst, G_FILE_TEST_EXISTS))
|
||||
return g_steal_pointer (&dst);
|
||||
continue;
|
||||
}
|
||||
|
||||
return g_steal_pointer (&dst);
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
41
src/libsysprof/sysprof-path-resolver.h
Normal file
41
src/libsysprof/sysprof-path-resolver.h
Normal file
@ -0,0 +1,41 @@
|
||||
/* sysprof-path-resolver.h
|
||||
*
|
||||
* Copyright 2021 Christian Hergert <chergert@redhat.com>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*
|
||||
* SPDX-License-Identifier: GPL-3.0-or-later
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <glib.h>
|
||||
|
||||
G_BEGIN_DECLS
|
||||
|
||||
typedef struct _SysprofPathResolver SysprofPathResolver;
|
||||
|
||||
SysprofPathResolver *_sysprof_path_resolver_new (const char *mounts,
|
||||
const char *mountinfo);
|
||||
void _sysprof_path_resolver_add_overlay (SysprofPathResolver *self,
|
||||
const char *in_process,
|
||||
const char *on_host,
|
||||
int depth);
|
||||
void _sysprof_path_resolver_free (SysprofPathResolver *self);
|
||||
char *_sysprof_path_resolver_resolve (SysprofPathResolver *self,
|
||||
const char *path);
|
||||
|
||||
G_DEFINE_AUTOPTR_CLEANUP_FUNC (SysprofPathResolver, _sysprof_path_resolver_free)
|
||||
|
||||
G_END_DECLS
|
||||
@ -22,6 +22,8 @@
|
||||
|
||||
#include "config.h"
|
||||
|
||||
#include <json-glib/json-glib.h>
|
||||
|
||||
#include "sysprof-podman.h"
|
||||
|
||||
static const char *debug_dirs[] = {
|
||||
@ -67,3 +69,163 @@ sysprof_podman_debug_dirs (void)
|
||||
g_ptr_array_add (dirs, NULL);
|
||||
return (gchar **)g_ptr_array_free (dirs, FALSE);
|
||||
}
|
||||
|
||||
struct _SysprofPodman
|
||||
{
|
||||
JsonParser *containers_parser;
|
||||
JsonParser *layers_parser;
|
||||
};
|
||||
|
||||
void
|
||||
sysprof_podman_free (SysprofPodman *self)
|
||||
{
|
||||
g_clear_object (&self->containers_parser);
|
||||
g_clear_object (&self->layers_parser);
|
||||
g_slice_free (SysprofPodman, self);
|
||||
}
|
||||
|
||||
static void
|
||||
load_containers (SysprofPodman *self)
|
||||
{
|
||||
g_autofree char *path = NULL;
|
||||
|
||||
g_assert (self != NULL);
|
||||
|
||||
path = g_build_filename (g_get_user_data_dir (),
|
||||
"containers",
|
||||
"storage",
|
||||
"overlay-containers",
|
||||
"containers.json",
|
||||
NULL);
|
||||
json_parser_load_from_file (self->containers_parser, path, NULL);
|
||||
}
|
||||
|
||||
static void
|
||||
load_layers (SysprofPodman *self)
|
||||
{
|
||||
g_autofree char *path = NULL;
|
||||
|
||||
g_assert (self != NULL);
|
||||
|
||||
path = g_build_filename (g_get_user_data_dir (),
|
||||
"containers",
|
||||
"storage",
|
||||
"overlay-layers",
|
||||
"layers.json",
|
||||
NULL);
|
||||
json_parser_load_from_file (self->layers_parser, path, NULL);
|
||||
}
|
||||
|
||||
SysprofPodman *
|
||||
sysprof_podman_snapshot_current_user (void)
|
||||
{
|
||||
SysprofPodman *self;
|
||||
|
||||
self = g_slice_new0 (SysprofPodman);
|
||||
self->containers_parser = json_parser_new ();
|
||||
self->layers_parser = json_parser_new ();
|
||||
|
||||
load_containers (self);
|
||||
load_layers (self);
|
||||
|
||||
return self;
|
||||
}
|
||||
|
||||
static const char *
|
||||
find_parent_layer (JsonParser *parser,
|
||||
const char *layer,
|
||||
GPtrArray *seen)
|
||||
{
|
||||
JsonNode *root;
|
||||
JsonArray *ar;
|
||||
guint n_items;
|
||||
|
||||
g_assert (JSON_IS_PARSER (parser));
|
||||
g_assert (layer != NULL);
|
||||
g_assert (seen != NULL);
|
||||
|
||||
if (!(root = json_parser_get_root (parser)) ||
|
||||
!JSON_NODE_HOLDS_ARRAY (root) ||
|
||||
!(ar = json_node_get_array (root)))
|
||||
return NULL;
|
||||
|
||||
n_items = json_array_get_length (ar);
|
||||
|
||||
for (guint i = 0; i < n_items; i++)
|
||||
{
|
||||
JsonObject *item = json_array_get_object_element (ar, i);
|
||||
const char *parent;
|
||||
const char *id;
|
||||
|
||||
if (item == NULL ||
|
||||
!json_object_has_member (item, "id") ||
|
||||
!json_object_has_member (item, "parent") ||
|
||||
!(id = json_object_get_string_member (item, "id")) ||
|
||||
strcmp (id, layer) != 0 ||
|
||||
!(parent = json_object_get_string_member (item, "parent")))
|
||||
continue;
|
||||
|
||||
/* Avoid cycles by checking if we've seen this parent */
|
||||
for (guint j = 0; j < seen->len; j++)
|
||||
{
|
||||
if (strcmp (parent, g_ptr_array_index (seen, j)) == 0)
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return parent;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
gchar **
|
||||
sysprof_podman_get_layers (SysprofPodman *self,
|
||||
const char *container)
|
||||
{
|
||||
const char *layer = NULL;
|
||||
GPtrArray *layers;
|
||||
JsonNode *root;
|
||||
JsonArray *ar;
|
||||
guint n_items;
|
||||
|
||||
g_return_val_if_fail (self != NULL, NULL);
|
||||
g_return_val_if_fail (container != NULL, NULL);
|
||||
|
||||
if (!(root = json_parser_get_root (self->containers_parser)) ||
|
||||
!JSON_NODE_HOLDS_ARRAY (root) ||
|
||||
!(ar = json_node_get_array (root)))
|
||||
return NULL;
|
||||
|
||||
n_items = json_array_get_length (ar);
|
||||
|
||||
/* First try to locate the "layer" identifier for the container
|
||||
* in question.
|
||||
*/
|
||||
for (guint i = 0; i < n_items; i++)
|
||||
{
|
||||
JsonObject *item = json_array_get_object_element (ar, i);
|
||||
const char *item_layer;
|
||||
const char *id;
|
||||
|
||||
if (item == NULL ||
|
||||
!(id = json_object_get_string_member (item, "id")) ||
|
||||
strcmp (id, container) != 0 ||
|
||||
!(item_layer = json_object_get_string_member (item, "layer")))
|
||||
continue;
|
||||
|
||||
layer = item_layer;
|
||||
break;
|
||||
}
|
||||
|
||||
/* Now we need to try to locate the layer and all of the parents
|
||||
* within the layers.json so that we populate from the most recent
|
||||
* layer to those beneath it.
|
||||
*/
|
||||
layers = g_ptr_array_new ();
|
||||
g_ptr_array_add (layers, g_strdup (layer));
|
||||
while ((layer = find_parent_layer (self->layers_parser, layer, layers)))
|
||||
g_ptr_array_add (layers, g_strdup (layer));
|
||||
g_ptr_array_add (layers, NULL);
|
||||
|
||||
return (char **)g_ptr_array_free (layers, FALSE);
|
||||
}
|
||||
|
||||
@ -24,6 +24,14 @@
|
||||
|
||||
G_BEGIN_DECLS
|
||||
|
||||
gchar **sysprof_podman_debug_dirs (void);
|
||||
typedef struct _SysprofPodman SysprofPodman;
|
||||
|
||||
gchar **sysprof_podman_debug_dirs (void);
|
||||
SysprofPodman *sysprof_podman_snapshot_current_user (void);
|
||||
gchar **sysprof_podman_get_layers (SysprofPodman *self,
|
||||
const char *container);
|
||||
void sysprof_podman_free (SysprofPodman *self);
|
||||
|
||||
G_DEFINE_AUTOPTR_CLEANUP_FUNC (SysprofPodman, sysprof_podman_free)
|
||||
|
||||
G_END_DECLS
|
||||
|
||||
358
src/tests/list-all-maps.c
Normal file
358
src/tests/list-all-maps.c
Normal file
@ -0,0 +1,358 @@
|
||||
/* list-all-maps.c
|
||||
*
|
||||
* Copyright 2021 Christian Hergert <chergert@redhat.com>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*
|
||||
* SPDX-License-Identifier: GPL-3.0-or-later
|
||||
*/
|
||||
|
||||
#include "config.h"
|
||||
|
||||
#include <sysprof.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#include "../libsysprof/sysprof-helpers.h"
|
||||
#include "../libsysprof/sysprof-mountinfo.h"
|
||||
#include "../libsysprof/sysprof-path-resolver.h"
|
||||
#include "../libsysprof/sysprof-podman.h"
|
||||
|
||||
typedef enum {
|
||||
PROCESS_KIND_HOST,
|
||||
PROCESS_KIND_FLATPAK,
|
||||
PROCESS_KIND_PODMAN,
|
||||
} ProcessKind;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
ProcessKind kind : 2;
|
||||
int pid : 29;
|
||||
char *kind_identifier;
|
||||
char *mountinfo;
|
||||
char *comm;
|
||||
GArray *maps;
|
||||
GArray *overlays;
|
||||
} ProcessInfo;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
char *on_host;
|
||||
char *in_process;
|
||||
} ProcessOverlay;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
char *file;
|
||||
SysprofCaptureAddress start;
|
||||
SysprofCaptureAddress end;
|
||||
SysprofCaptureAddress offset;
|
||||
ino_t inode;
|
||||
} ProcessMap;
|
||||
|
||||
static const char *
|
||||
kind_to_string (ProcessKind kind)
|
||||
{
|
||||
switch (kind)
|
||||
{
|
||||
case PROCESS_KIND_HOST:
|
||||
return "Host";
|
||||
case PROCESS_KIND_PODMAN:
|
||||
return "Podman";
|
||||
case PROCESS_KIND_FLATPAK:
|
||||
return "Flatpak";
|
||||
default:
|
||||
return "Unknown";
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
process_overlay_clear (ProcessOverlay *overlay)
|
||||
{
|
||||
g_free (overlay->on_host);
|
||||
g_free (overlay->in_process);
|
||||
}
|
||||
|
||||
static void
|
||||
process_info_clear (ProcessInfo *info)
|
||||
{
|
||||
g_free (info->kind_identifier);
|
||||
g_free (info->mountinfo);
|
||||
g_free (info->comm);
|
||||
g_clear_pointer (&info->maps, g_array_unref);
|
||||
g_clear_pointer (&info->overlays, g_array_unref);
|
||||
}
|
||||
|
||||
static void
|
||||
process_map_clear (ProcessMap *map)
|
||||
{
|
||||
g_free (map->file);
|
||||
}
|
||||
|
||||
static ProcessKind
|
||||
get_process_kind_from_cgroup (int pid,
|
||||
const char *cgroup,
|
||||
char **identifier)
|
||||
{
|
||||
static GRegex *podman_regex;
|
||||
static GRegex *flatpak_regex;
|
||||
|
||||
g_autoptr(GMatchInfo) podman_match = NULL;
|
||||
g_autoptr(GMatchInfo) flatpak_match = NULL;
|
||||
|
||||
if G_UNLIKELY (podman_regex == NULL)
|
||||
podman_regex = g_regex_new ("libpod-([a-z0-9]{64})\\.scope", G_REGEX_OPTIMIZE, 0, NULL);
|
||||
|
||||
if G_UNLIKELY (flatpak_regex == NULL)
|
||||
flatpak_regex = g_regex_new ("app-flatpak-([a-zA-Z_\\-\\.]+)-[0-9]+\\.scope", G_REGEX_OPTIMIZE, 0, NULL);
|
||||
|
||||
if (g_regex_match (podman_regex, cgroup, 0, &podman_match))
|
||||
{
|
||||
if (identifier != NULL)
|
||||
*identifier = g_match_info_fetch (podman_match, 1);
|
||||
return PROCESS_KIND_PODMAN;
|
||||
}
|
||||
else if (g_regex_match (flatpak_regex, cgroup, 0, &flatpak_match))
|
||||
{
|
||||
if (identifier != NULL)
|
||||
*identifier = g_match_info_fetch (flatpak_match, 1);
|
||||
return PROCESS_KIND_FLATPAK;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (identifier != NULL)
|
||||
*identifier = NULL;
|
||||
return PROCESS_KIND_HOST;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
process_info_populate_podman_overlays (ProcessInfo *proc,
|
||||
SysprofPodman *podman)
|
||||
{
|
||||
g_auto(GStrv) layers = NULL;
|
||||
|
||||
g_assert (proc != NULL);
|
||||
g_assert (proc->kind == PROCESS_KIND_PODMAN);
|
||||
|
||||
if ((layers = sysprof_podman_get_layers (podman, proc->kind_identifier)))
|
||||
{
|
||||
for (guint i = 0; layers[i]; i++)
|
||||
{
|
||||
ProcessOverlay overlay;
|
||||
g_autofree char *path = g_build_filename (g_get_user_data_dir (),
|
||||
"containers",
|
||||
"storage",
|
||||
"overlay",
|
||||
layers[i],
|
||||
"diff",
|
||||
NULL);
|
||||
|
||||
/* XXX: this really only supports one layer */
|
||||
overlay.in_process = g_strdup ("/");
|
||||
overlay.on_host = g_steal_pointer (&path);
|
||||
|
||||
if (proc->overlays == NULL)
|
||||
{
|
||||
proc->overlays = g_array_new (FALSE, FALSE, sizeof (ProcessOverlay));
|
||||
g_array_set_clear_func (proc->overlays, (GDestroyNotify)process_overlay_clear);
|
||||
}
|
||||
|
||||
g_array_append_val (proc->overlays, overlay);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
process_info_populate_maps (ProcessInfo *proc,
|
||||
const char *maps)
|
||||
{
|
||||
g_auto(GStrv) lines = NULL;
|
||||
|
||||
g_assert (proc != NULL);
|
||||
g_assert (maps != NULL);
|
||||
|
||||
if (proc->maps == NULL)
|
||||
{
|
||||
proc->maps = g_array_new (FALSE, FALSE, sizeof (ProcessMap));
|
||||
g_array_set_clear_func (proc->maps, (GDestroyNotify)process_map_clear);
|
||||
}
|
||||
|
||||
lines = g_strsplit (maps, "\n", 0);
|
||||
|
||||
for (guint i = 0; lines[i] != NULL; i++)
|
||||
{
|
||||
ProcessMap map;
|
||||
gchar file[512];
|
||||
gulong start;
|
||||
gulong end;
|
||||
gulong offset;
|
||||
gulong inode;
|
||||
int r;
|
||||
|
||||
r = sscanf (lines[i],
|
||||
"%lx-%lx %*15s %lx %*x:%*x %lu %512s",
|
||||
&start, &end, &offset, &inode, file);
|
||||
file[sizeof file - 1] = '\0';
|
||||
|
||||
if (r != 5)
|
||||
continue;
|
||||
|
||||
if (strcmp ("[vdso]", file) == 0)
|
||||
{
|
||||
/*
|
||||
* Søren Sandmann Pedersen says:
|
||||
*
|
||||
* For the vdso, the kernel reports 'offset' as the
|
||||
* the same as the mapping address. This doesn't make
|
||||
* any sense to me, so we just zero it here. There
|
||||
* is code in binfile.c (read_inode) that returns 0
|
||||
* for [vdso].
|
||||
*/
|
||||
offset = 0;
|
||||
inode = 0;
|
||||
}
|
||||
|
||||
map.file = g_strdup (file);
|
||||
map.start = start;
|
||||
map.end = end;
|
||||
map.offset = offset;
|
||||
map.inode = inode;
|
||||
|
||||
g_array_append_val (proc->maps, map);
|
||||
}
|
||||
}
|
||||
|
||||
static gboolean
|
||||
process_info_populate (ProcessInfo *proc,
|
||||
GVariant *variant,
|
||||
SysprofPodman *podman)
|
||||
{
|
||||
const char *str;
|
||||
int pid;
|
||||
|
||||
g_assert (proc != NULL);
|
||||
g_assert (proc->pid == 0);
|
||||
g_assert (variant != NULL);
|
||||
g_assert (g_variant_is_of_type (variant, G_VARIANT_TYPE_VARDICT));
|
||||
|
||||
if (g_variant_lookup (variant, "pid", "i", &pid))
|
||||
proc->pid = pid;
|
||||
else
|
||||
return FALSE;
|
||||
|
||||
if (g_variant_lookup (variant, "comm", "&s", &str))
|
||||
proc->comm = g_strdup (str);
|
||||
|
||||
if (g_variant_lookup (variant, "cgroup", "&s", &str))
|
||||
proc->kind = get_process_kind_from_cgroup (pid, str, &proc->kind_identifier);
|
||||
else
|
||||
proc->kind = PROCESS_KIND_HOST;
|
||||
|
||||
if (proc->kind == PROCESS_KIND_PODMAN)
|
||||
process_info_populate_podman_overlays (proc, podman);
|
||||
|
||||
if (g_variant_lookup (variant, "mountinfo", "&s", &str))
|
||||
proc->mountinfo = g_strdup (str);
|
||||
|
||||
if (g_variant_lookup (variant, "maps", "&s", &str))
|
||||
process_info_populate_maps (proc, str);
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static gboolean
|
||||
list_all_maps (GError **error)
|
||||
{
|
||||
SysprofHelpers *helpers = sysprof_helpers_get_default ();
|
||||
g_autoptr(SysprofPodman) podman = NULL;
|
||||
g_autofree char *mounts = NULL;
|
||||
g_autoptr(GVariant) info = NULL;
|
||||
g_autoptr(GArray) processes = NULL;
|
||||
GVariant *value;
|
||||
GVariantIter iter;
|
||||
|
||||
if (!sysprof_helpers_get_process_info (helpers, "pid,maps,mountinfo,cmdline,comm,cgroup", FALSE, NULL, &info, error))
|
||||
return FALSE;
|
||||
|
||||
if (!sysprof_helpers_get_proc_file (helpers, "/proc/mounts", NULL, &mounts, error))
|
||||
return FALSE;
|
||||
|
||||
podman = sysprof_podman_snapshot_current_user ();
|
||||
|
||||
processes = g_array_new (FALSE, TRUE, sizeof (ProcessInfo));
|
||||
g_array_set_clear_func (processes, (GDestroyNotify)process_info_clear);
|
||||
|
||||
g_variant_iter_init (&iter, info);
|
||||
while (g_variant_iter_loop (&iter, "@a{sv}", &value))
|
||||
{
|
||||
ProcessInfo *proc;
|
||||
|
||||
g_array_set_size (processes, processes->len + 1);
|
||||
proc = &g_array_index (processes, ProcessInfo, processes->len - 1);
|
||||
|
||||
if (!process_info_populate (proc, value, podman))
|
||||
g_array_set_size (processes, processes->len - 1);
|
||||
}
|
||||
|
||||
for (guint i = 0; i < processes->len; i++)
|
||||
{
|
||||
const ProcessInfo *proc = &g_array_index (processes, ProcessInfo, i);
|
||||
g_autoptr(SysprofPathResolver) resolver = _sysprof_path_resolver_new (mounts, proc->mountinfo);
|
||||
|
||||
if (proc->maps == NULL || proc->maps->len == 0)
|
||||
continue;
|
||||
|
||||
g_print ("Process %d", proc->pid);
|
||||
if (proc->kind != PROCESS_KIND_HOST)
|
||||
g_print (" (%s)", kind_to_string (proc->kind));
|
||||
g_print (" %s\n", proc->comm);
|
||||
|
||||
if (proc->overlays != NULL)
|
||||
{
|
||||
for (guint j = 0; j < proc->overlays->len; j++)
|
||||
{
|
||||
const ProcessOverlay *overlay = &g_array_index (proc->overlays, ProcessOverlay, j);
|
||||
_sysprof_path_resolver_add_overlay (resolver, overlay->in_process, overlay->on_host, j);
|
||||
}
|
||||
}
|
||||
|
||||
for (guint j = 0; j < proc->maps->len; j++)
|
||||
{
|
||||
const ProcessMap *map = &g_array_index (proc->maps, ProcessMap, j);
|
||||
g_autofree char *path = _sysprof_path_resolver_resolve (resolver, map->file);
|
||||
|
||||
if (path != NULL)
|
||||
{
|
||||
g_print (" %s", path);
|
||||
if (!g_file_test (path, G_FILE_TEST_EXISTS))
|
||||
g_print (" (missing)");
|
||||
g_print ("\n");
|
||||
}
|
||||
}
|
||||
|
||||
g_print ("\n");
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
int
|
||||
main (int argc,
|
||||
char *argv[])
|
||||
{
|
||||
g_autoptr(GError) error = NULL;
|
||||
if (!list_all_maps (&error))
|
||||
g_printerr ("%s\n", error->message);
|
||||
return error ? EXIT_FAILURE : EXIT_SUCCESS;
|
||||
}
|
||||
@ -113,6 +113,12 @@ show_page_usage = executable('show-page-usage',
|
||||
dependency('cairo') ],
|
||||
)
|
||||
|
||||
list_pid_maps = executable('list-all-maps', 'list-all-maps.c',
|
||||
c_args: test_cflags,
|
||||
dependencies: [libsysprof_static_dep],
|
||||
include_directories: include_directories('..'),
|
||||
)
|
||||
|
||||
if get_option('enable_gtk')
|
||||
|
||||
test_ui_deps = [
|
||||
|
||||
Reference in New Issue
Block a user