diff options
Diffstat (limited to 'libctf/ctf-string.c')
-rw-r--r-- | libctf/ctf-string.c | 165 |
1 files changed, 129 insertions, 36 deletions
diff --git a/libctf/ctf-string.c b/libctf/ctf-string.c index 27bd7c2..44cd447 100644 --- a/libctf/ctf-string.c +++ b/libctf/ctf-string.c @@ -20,13 +20,24 @@ #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. */ +/* 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 (ctf_file_t *fp, uint32_t name) +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 (ctsp->cts_strs != NULL && CTF_NAME_OFFSET (name) < ctsp->cts_len) return (ctsp->cts_strs + CTF_NAME_OFFSET (name)); @@ -34,6 +45,14 @@ ctf_strraw (ctf_file_t *fp, uint32_t name) 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 * @@ -88,11 +107,11 @@ 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 * +/* 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. */ +static ctf_str_atom_t * ctf_str_add_ref_internal (ctf_file_t *fp, const char *str, int add_ref, uint32_t *ref) { @@ -116,7 +135,7 @@ ctf_str_add_ref_internal (ctf_file_t *fp, const char *str, ctf_list_append (&atom->csa_refs, aref); fp->ctf_str_num_refs++; } - return atom->csa_str; + return atom; } if ((atom = ctf_alloc (sizeof (struct ctf_str_atom))) == NULL) @@ -136,7 +155,7 @@ ctf_str_add_ref_internal (ctf_file_t *fp, const char *str, ctf_list_append (&atom->csa_refs, aref); fp->ctf_str_num_refs++; } - return newstr; + return atom; oom: ctf_free (atom); @@ -150,9 +169,48 @@ ctf_str_add_ref_internal (ctf_file_t *fp, const char *str, 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; + ctf_str_atom_t *atom; + if (!str) + return NULL; + + atom = ctf_str_add_ref_internal (fp, str, FALSE, 0); + if (!atom) + return NULL; + + return atom->csa_str; +} + +/* 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) +{ + ctf_str_atom_t *atom; + if (!str) + return NULL; + + atom = ctf_str_add_ref_internal (fp, str, TRUE, ref); + if (!atom) + return NULL; + + return atom->csa_str; +} + +/* Add an external strtab reference at OFFSET. */ +const char * +ctf_str_add_external (ctf_file_t *fp, const char *str, uint32_t offset) +{ + ctf_str_atom_t *atom; + if (!str) + return NULL; + + atom = ctf_str_add_ref_internal (fp, str, FALSE, 0); + if (!atom) + return NULL; + + atom->csa_offset = CTF_SET_STID (offset, CTF_STRTAB_1); + return atom->csa_str; } /* A ctf_dynhash_iter_remove() callback that removes atoms later than a given @@ -173,17 +231,6 @@ 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, @@ -238,7 +285,11 @@ ctf_str_count_strtab (void *key _libctf_unused_, void *value, 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; + /* We only factor in the length of items that have no offset: + other items are in the external strtab. They still contribute to the + total count, though, because we still have to sort them. */ + if (!atom->csa_offset) + s->strtab->cts_len += strlen (atom->csa_str) + 1; s->strtab_count++; } @@ -268,8 +319,10 @@ ctf_str_sort_strtab (const void *a, const void *b) } /* 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. */ + 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) { @@ -279,6 +332,7 @@ ctf_str_write_strtab (ctf_file_t *fp) 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)); @@ -300,7 +354,7 @@ ctf_str_write_strtab (ctf_file_t *fp) /* Sort the strtab. Force the null string to be first. */ sorttab = calloc (s.strtab_count, sizeof (ctf_str_atom_t *)); if (!sorttab) - return strtab; + goto oom; sorttab[0] = nullstr; s.i = 1; @@ -312,19 +366,58 @@ ctf_str_write_strtab (ctf_file_t *fp) ctf_str_sort_strtab); if ((strtab.cts_strs = ctf_alloc (strtab.cts_len)) == NULL) - { - free (sorttab); - return strtab; - } + 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 the strtab, and all refs. */ + /* Update all refs: also update the strtab appropriately. */ 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; + if (sorttab[i]->csa_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_offset); + if (ctf_dynhash_insert (fp->ctf_syn_ext_strtab, + (void *) (uintptr_t) sorttab[i]->csa_offset, + (void *) sorttab[i]->csa_str) < 0) + goto oom_strtab; + } + else + { + /* Internal strtab entry: actually add to the string table. */ + + ctf_str_update_refs (sorttab[i], 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; + } + + return strtab; + + oom_strtab: + free (strtab.cts_strs); + strtab.cts_strs = NULL; + oom_sorttab: + free (sorttab); + oom: return strtab; } |