diff options
Diffstat (limited to 'libctf/ctf-string.c')
| -rw-r--r-- | libctf/ctf-string.c | 330 |
1 files changed, 330 insertions, 0 deletions
diff --git a/libctf/ctf-string.c b/libctf/ctf-string.c new file mode 100644 index 0000000..27bd7c2 --- /dev/null +++ b/libctf/ctf-string.c @@ -0,0 +1,330 @@ +/* CTF string table management. + Copyright (C) 2019 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 by looking + up the appropriate string table buffer and then adding the offset. */ +const char * +ctf_strraw (ctf_file_t *fp, uint32_t name) +{ + ctf_strs_t *ctsp = &fp->ctf_str[CTF_NAME_STID (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; +} + +/* 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); + ctf_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); + ctf_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, + ctf_free, ctf_str_free_atom); + if (fp->ctf_str_atoms == NULL) + return -ENOMEM; + + ctf_str_add (fp, ""); + return 0; +} + +/* Destroy the atoms table. */ +void +ctf_str_free_atoms (ctf_file_t *fp) +{ + ctf_dynhash_destroy (fp->ctf_str_atoms); +} + +/* Add a string to the atoms table and return it, or return an existing string + if present, copying the passed-in string. Returns 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. */ +static const char * +ctf_str_add_ref_internal (ctf_file_t *fp, const char *str, + int add_ref, 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 = ctf_alloc (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->csa_str; + } + + if ((atom = ctf_alloc (sizeof (struct ctf_str_atom))) == NULL) + goto oom; + memset (atom, 0, sizeof (struct ctf_str_atom)); + + if ((newstr = ctf_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 (add_ref) + { + ctf_list_append (&atom->csa_refs, aref); + fp->ctf_str_num_refs++; + } + return newstr; + + oom: + ctf_free (atom); + ctf_free (aref); + ctf_free (newstr); + return NULL; +} + +/* Add a string to the atoms table and return it, without augmenting the ref + list for this string. */ +const char * +ctf_str_add (ctf_file_t *fp, const char *str) +{ + if (str) + return ctf_str_add_ref_internal (fp, str, FALSE, 0); + return NULL; +} + +/* 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); +} + +/* 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). */ +const char * +ctf_str_add_ref (ctf_file_t *fp, const char *str, uint32_t *ref) +{ + if (str) + return ctf_str_add_ref_internal (fp, str, TRUE, ref); + return NULL; +} + +/* 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; + + 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; + + 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. */ +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; + + 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_dprintf ("Internal error: null string not found in strtab.\n"); + strtab.cts_strs = NULL; + return strtab; + } + + ctf_dynhash_iter (fp->ctf_str_atoms, ctf_str_count_strtab, &s); + + 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) + return strtab; + + sorttab[0] = nullstr; + s.i = 1; + s.sorttab = sorttab; + s.nullstr = nullstr; + 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 = ctf_alloc (strtab.cts_len)) == NULL) + { + free (sorttab); + return strtab; + } + + /* Update the strtab, and all refs. */ + for (i = 0; i < s.strtab_count; i++) + { + strcpy (&strtab.cts_strs[cur_stroff], sorttab[i]->csa_str); + ctf_str_update_refs (sorttab[i], cur_stroff); + cur_stroff += strlen (sorttab[i]->csa_str) + 1; + } + free (sorttab); + + return strtab; +} |