/* CTF string table management.
Copyright (C) 2019-2020 Free Software Foundation, Inc.
This file is part of libctf.
libctf 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, 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; see the file COPYING. If not see
<http://www.gnu.org/licenses/>. */
#include <ctf-impl.h>
#include <string.h>
/* Convert an encoded CTF string name into a pointer to a C string, using an
explicit internal strtab rather than the fp-based one. */
const char *
ctf_strraw_explicit (ctf_file_t *fp, uint32_t name, ctf_strs_t *strtab)
{
ctf_strs_t *ctsp = &fp->ctf_str[CTF_NAME_STID (name)];
if ((CTF_NAME_STID (name) == CTF_STRTAB_0) && (strtab != NULL))
ctsp = strtab;
/* If this name is in the external strtab, and there is a synthetic strtab,
use it in preference. */
if (CTF_NAME_STID (name) == CTF_STRTAB_1
&& fp->ctf_syn_ext_strtab != NULL)
return ctf_dynhash_lookup (fp->ctf_syn_ext_strtab,
(void *) (uintptr_t) name);
/* If the name is in the internal strtab, and the offset is beyond the end of
the ctsp->cts_len but below the ctf_str_prov_offset, this is a provisional
string added by ctf_str_add*() but not yet built into a real strtab: get
the value out of the ctf_prov_strtab. */
if (CTF_NAME_STID (name) == CTF_STRTAB_0
&& name >= ctsp->cts_len && name < fp->ctf_str_prov_offset)
return ctf_dynhash_lookup (fp->ctf_prov_strtab,
(void *) (uintptr_t) name);
if (ctsp->cts_strs != NULL && CTF_NAME_OFFSET (name) < ctsp->cts_len)
return (ctsp->cts_strs + CTF_NAME_OFFSET (name));
/* String table not loaded or corrupt offset. */
return NULL;
}
/* Convert an encoded CTF string name into a pointer to a C string by looking
up the appropriate string table buffer and then adding the offset. */
const char *
ctf_strraw (ctf_file_t *fp, uint32_t name)
{
return ctf_strraw_explicit (fp, name, NULL);
}
/* Return a guaranteed-non-NULL pointer to the string with the given CTF
name. */
const char *
ctf_strptr (ctf_file_t *fp, uint32_t name)
{
const char *s = ctf_strraw (fp, name);
return (s != NULL ? s : "(?)");
}
/* Remove all refs to a given atom. */
static void
ctf_str_purge_atom_refs (ctf_str_atom_t *atom)
{
ctf_str_atom_ref_t *ref, *next;
for (ref = ctf_list_next (&atom->csa_refs); ref != NULL; ref = next)
{
next = ctf_list_next (ref);
ctf_list_delete (&atom->csa_refs, ref);
free (ref);
}
}
/* Free an atom (only called on ctf_close().) */
static void
ctf_str_free_atom (void *a)
{
ctf_str_atom_t *atom = a;
ctf_str_purge_atom_refs (atom);
free (atom);
}
/* Create the atoms table. There is always at least one atom in it, the null
string. */
int
ctf_str_create_atoms (ctf_file_t *fp)
{
fp->ctf_str_atoms = ctf_dynhash_create (ctf_hash_string, ctf_hash_eq_string,
free, ctf_str_free_atom);
if (fp->ctf_str_atoms == NULL)
return -ENOMEM;
if (!fp->ctf_prov_strtab)
fp->ctf_prov_strtab = ctf_dynhash_create (ctf_hash_integer,
ctf_hash_eq_integer,
NULL, NULL);
if (!fp->ctf_prov_strtab)
goto oom_prov_strtab;
errno = 0;
ctf_str_add (fp, "");
if (errno == ENOMEM)
goto oom_str_add;
return 0;
oom_str_add:
ctf_dynhash_destroy (fp->ctf_prov_strtab);
fp->ctf_prov_strtab = NULL;
oom_prov_strtab:
ctf_dynhash_destroy (fp->ctf_str_atoms);
fp->ctf_str_atoms = NULL;
return -ENOMEM;
}
/* Destroy the atoms table. */
void
ctf_str_free_atoms (ctf_file_t *fp)
{
ctf_dynhash_destroy (fp->ctf_prov_strtab);
ctf_dynhash_destroy (fp->ctf_str_atoms);
}
/* Add a string to the atoms table, copying the passed-in string. Return the
atom added. Return NULL only when out of memory (and do not touch the
passed-in string in that case). Possibly augment the ref list with the
passed-in ref. Possibly add a provisional entry for this string to the
provisional strtab. */
static ctf_str_atom_t *
ctf_str_add_ref_internal (ctf_file_t *fp, const char *str,
int add_ref, int make_provisional, uint32_t *ref)
{
char *newstr = NULL;
ctf_str_atom_t *atom = NULL;
ctf_str_atom_ref_t *aref = NULL;
atom = ctf_dynhash_lookup (fp->ctf_str_atoms, str);
if (add_ref)
{
if ((aref = malloc (sizeof (struct ctf_str_atom_ref))) == NULL)
return NULL;
aref->caf_ref = ref;
}
if (atom)
{
if (add_ref)
{
ctf_list_append (&atom->csa_refs, aref);
fp->ctf_str_num_refs++;
}
return atom;
}
if ((atom = malloc (sizeof (struct ctf_str_atom))) == NULL)
goto oom;
memset (atom, 0, sizeof (struct ctf_str_atom));
if ((newstr = strdup (str)) == NULL)
goto oom;
if (ctf_dynhash_insert (fp->ctf_str_atoms, newstr, atom) < 0)
goto oom;
atom->csa_str = newstr;
atom->csa_snapshot_id = fp->ctf_snapshots;
if (make_provisional)
{
atom->csa_offset = fp->ctf_str_prov_offset;
if (ctf_dynhash_insert (fp->ctf_prov_strtab, (void *) (uintptr_t)
atom->csa_offset, (void *) atom->csa_str) < 0)
goto oom;
fp->ctf_str_prov_offset += strlen (atom->csa_str) + 1;
}
if (add_ref)
{
ctf_list_append (&atom->csa_refs, aref);
fp->ctf_str_num_refs++;
}
return atom;
oom:
if (newstr)
ctf_dynhash_remove (fp->ctf_str_atoms, newstr);
free (atom);
free (aref);
free (newstr);
return NULL;
}
/* Add a string to the atoms table, without augmenting the ref list for this
string: return a 'provisional offset' which can be used to return this string
until ctf_str_write_strtab is called, or 0 on failure. (Everywhere the
provisional offset is assigned to should be added as a ref using
ctf_str_add_ref() as well.) */
uint32_t
ctf_str_add (ctf_file_t *fp, const char *str)
{
ctf_str_atom_t *atom;
if (!str)
return 0;
atom = ctf_str_add_ref_internal (fp, str, FALSE, TRUE, 0);
if (!atom)
return 0;
return atom->csa_offset;
}
/* Like ctf_str_add(), but additionally augment the atom's refs list with the
passed-in ref, whether or not the string is already present. There is no
attempt to deduplicate the refs list (but duplicates are harmless). */
uint32_t
ctf_str_add_ref (ctf_file_t *fp, const char *str, uint32_t *ref)
{
ctf_str_atom_t *atom;
if (!str)
return 0;
atom = ctf_str_add_ref_internal (fp, str, TRUE, TRUE, ref);
if (!atom)
return 0;
return atom->csa_offset;
}
/* Add an external strtab reference at OFFSET. Returns zero if the addition
failed, nonzero otherwise. */
int
ctf_str_add_external (ctf_file_t *fp, const char *str, uint32_t offset)
{
ctf_str_atom_t *atom;
if (!str)
return 0;
atom = ctf_str_add_ref_internal (fp, str, FALSE, FALSE, 0);
if (!atom)
return 0;
atom->csa_external_offset = CTF_SET_STID (offset, CTF_STRTAB_1);
return 1;
}
/* Remove a single ref. */
void
ctf_str_remove_ref (ctf_file_t *fp, const char *str, uint32_t *ref)
{
ctf_str_atom_ref_t *aref, *anext;
ctf_str_atom_t *atom = NULL;
atom = ctf_dynhash_lookup (fp->ctf_str_atoms, str);
if (!atom)
return;
for (aref = ctf_list_next (&atom->csa_refs); aref != NULL; aref = anext)
{
anext = ctf_list_next (aref);
if (aref->caf_ref == ref)
{
ctf_list_delete (&atom->csa_refs, aref);
free (aref);
}
}
}
/* A ctf_dynhash_iter_remove() callback that removes atoms later than a given
snapshot ID. */
static int
ctf_str_rollback_atom (void *key _libctf_unused_, void *value, void *arg)
{
ctf_str_atom_t *atom = (ctf_str_atom_t *) value;
ctf_snapshot_id_t *id = (ctf_snapshot_id_t *) arg;
return (atom->csa_snapshot_id > id->snapshot_id);
}
/* Roll back, deleting all atoms created after a particular ID. */
void
ctf_str_rollback (ctf_file_t *fp, ctf_snapshot_id_t id)
{
ctf_dynhash_iter_remove (fp->ctf_str_atoms, ctf_str_rollback_atom, &id);
}
/* An adaptor around ctf_purge_atom_refs. */
static void
ctf_str_purge_one_atom_refs (void *key _libctf_unused_, void *value,
void *arg _libctf_unused_)
{
ctf_str_atom_t *atom = (ctf_str_atom_t *) value;
ctf_str_purge_atom_refs (atom);
}
/* Remove all the recorded refs from the atoms table. */
void
ctf_str_purge_refs (ctf_file_t *fp)
{
if (fp->ctf_str_num_refs > 0)
ctf_dynhash_iter (fp->ctf_str_atoms, ctf_str_purge_one_atom_refs, NULL);
fp->ctf_str_num_refs = 0;
}
/* Update a list of refs to the specified value. */
static void
ctf_str_update_refs (ctf_str_atom_t *refs, uint32_t value)
{
ctf_str_atom_ref_t *ref;
for (ref = ctf_list_next (&refs->csa_refs); ref != NULL;
ref = ctf_list_next (ref))
*(ref->caf_ref) = value;
}
/* State shared across the strtab write process. */
typedef struct ctf_strtab_write_state
{
/* Strtab we are writing, and the number of strings in it. */
ctf_strs_writable_t *strtab;
size_t strtab_count;
/* Pointers to (existing) atoms in the atoms table, for qsorting. */
ctf_str_atom_t **sorttab;
/* Loop counter for sorttab population. */
size_t i;
/* The null-string atom (skipped during population). */
ctf_str_atom_t *nullstr;
} ctf_strtab_write_state_t;
/* Count the number of entries in the strtab, and its length. */
static void
ctf_str_count_strtab (void *key _libctf_unused_, void *value,
void *arg)
{
ctf_str_atom_t *atom = (ctf_str_atom_t *) value;
ctf_strtab_write_state_t *s = (ctf_strtab_write_state_t *) arg;
/* We only factor in the length of items that have no offset and have refs:
other items are in the external strtab, or will simply not be written out
at all. They still contribute to the total count, though, because we still
have to sort them. We add in the null string's length explicitly, outside
this function, since it is explicitly written out even if it has no refs at
all. */
if (s->nullstr == atom)
{
s->strtab_count++;
return;
}
if (!ctf_list_empty_p (&atom->csa_refs))
{
if (!atom->csa_external_offset)
s->strtab->cts_len += strlen (atom->csa_str) + 1;
s->strtab_count++;
}
}
/* Populate the sorttab with pointers to the strtab atoms. */
static void
ctf_str_populate_sorttab (void *key _libctf_unused_, void *value,
void *arg)
{
ctf_str_atom_t *atom = (ctf_str_atom_t *) value;
ctf_strtab_write_state_t *s = (ctf_strtab_write_state_t *) arg;
/* Skip the null string. */
if (s->nullstr == atom)
return;
/* Skip atoms with no refs. */
if (!ctf_list_empty_p (&atom->csa_refs))
s->sorttab[s->i++] = atom;
}
/* Sort the strtab. */
static int
ctf_str_sort_strtab (const void *a, const void *b)
{
ctf_str_atom_t **one = (ctf_str_atom_t **) a;
ctf_str_atom_t **two = (ctf_str_atom_t **) b;
return (strcmp ((*one)->csa_str, (*two)->csa_str));
}
/* Write out and return a strtab containing all strings with recorded refs,
adjusting the refs to refer to the corresponding string. The returned strtab
may be NULL on error. Also populate the synthetic strtab with mappings from
external strtab offsets to names, so we can look them up with ctf_strptr().
Only external strtab offsets with references are added. */
ctf_strs_writable_t
ctf_str_write_strtab (ctf_file_t *fp)
{
ctf_strs_writable_t strtab;
ctf_str_atom_t *nullstr;
uint32_t cur_stroff = 0;
ctf_strtab_write_state_t s;
ctf_str_atom_t **sorttab;
size_t i;
int any_external = 0;
memset (&strtab, 0, sizeof (struct ctf_strs_writable));
memset (&s, 0, sizeof (struct ctf_strtab_write_state));
s.strtab = &strtab;
nullstr = ctf_dynhash_lookup (fp->ctf_str_atoms, "");
if (!nullstr)
{
ctf_err_warn (fp, 0, ECTF_INTERNAL, _("null string not found in strtab"));
strtab.cts_strs = NULL;
return strtab;
}
s.nullstr = nullstr;
ctf_dynhash_iter (fp->ctf_str_atoms, ctf_str_count_strtab, &s);
strtab.cts_len++; /* For the null string. */
ctf_dprintf ("%lu bytes of strings in strtab.\n",
(unsigned long) strtab.cts_len);
/* Sort the strtab. Force the null string to be first. */
sorttab = calloc (s.strtab_count, sizeof (ctf_str_atom_t *));
if (!sorttab)
goto oom;
sorttab[0] = nullstr;
s.i = 1;
s.sorttab = sorttab;
ctf_dynhash_iter (fp->ctf_str_atoms, ctf_str_populate_sorttab, &s);
qsort (&sorttab[1], s.strtab_count - 1, sizeof (ctf_str_atom_t *),
ctf_str_sort_strtab);
if ((strtab.cts_strs = malloc (strtab.cts_len)) == NULL)
goto oom_sorttab;
if (!fp->ctf_syn_ext_strtab)
fp->ctf_syn_ext_strtab = ctf_dynhash_create (ctf_hash_integer,
ctf_hash_eq_integer,
NULL, NULL);
if (!fp->ctf_syn_ext_strtab)
goto oom_strtab;
/* Update all refs: also update the strtab appropriately. */
for (i = 0; i < s.strtab_count; i++)
{
if (sorttab[i]->csa_external_offset)
{
/* External strtab entry: populate the synthetic external strtab.
This is safe because you cannot ctf_rollback to before the point
when a ctf_update is done, and the strtab is written at ctf_update
time. So any atoms we reference here are sure to stick around
until ctf_file_close. */
any_external = 1;
ctf_str_update_refs (sorttab[i], sorttab[i]->csa_external_offset);
if (ctf_dynhash_insert (fp->ctf_syn_ext_strtab,
(void *) (uintptr_t)
sorttab[i]->csa_external_offset,
(void *) sorttab[i]->csa_str) < 0)
goto oom_strtab;
sorttab[i]->csa_offset = sorttab[i]->csa_external_offset;
}
else
{
/* Internal strtab entry with refs: actually add to the string
table. */
ctf_str_update_refs (sorttab[i], cur_stroff);
sorttab[i]->csa_offset = cur_stroff;
strcpy (&strtab.cts_strs[cur_stroff], sorttab[i]->csa_str);
cur_stroff += strlen (sorttab[i]->csa_str) + 1;
}
}
free (sorttab);
if (!any_external)
{
ctf_dynhash_destroy (fp->ctf_syn_ext_strtab);
fp->ctf_syn_ext_strtab = NULL;
}
/* All the provisional strtab entries are now real strtab entries, and
ctf_strptr() will find them there. The provisional offset now starts right
beyond the new end of the strtab. */
ctf_dynhash_empty (fp->ctf_prov_strtab);
fp->ctf_str_prov_offset = strtab.cts_len + 1;
return strtab;
oom_strtab:
free (strtab.cts_strs);
strtab.cts_strs = NULL;
oom_sorttab:
free (sorttab);
oom:
return strtab;
}