libctf: add mechanism to prohibit most operations without a strtab

We are about to add machinery that deduplicates a child dict's strtab
against its parent.  Obviously if you open such a dict but do not import its
parent, all strtab lookups must fail: so add an LCTF_NO_STR flag that is set
in that window and make most operations fail if it's not set.  (Two more
that will be set in future commits are serialization and string lookup
itself.)

Notably, not all symbol lookup is impossible in this window: you can still
look up by symbol index, as long as this dict is not using an indexed
strtypetab (which obviously requires string lookups to get the symbol name).

include/
	* ctf-api.h (_CTF_ERRORS) [ECTF_HASPARENT]: New.
        [ECTF_WRONGPARENT]: Likewise.
	(ECTF_NERR): Update.
        Update comments to note the new limitations on ctf_import et al.

libctf/
	* ctf-impl.h (LCTF_NO_STR): New.
	* ctf-create.c (ctf_rollback): Error out when LCTF_NO_STR.
	(ctf_add_generic): Likewise.
	(ctf_add_struct_sized): Likewise.
	(ctf_add_union_sized): Likewise.
	(ctf_add_enum): Likewise.
	(ctf_add_forward): Likewise.
	(ctf_add_unknown): Likewise.
	(ctf_add_enumerator): Likewise.
	(ctf_add_member_offset): Likewise.
	(ctf_add_variable): Likewise.
	(ctf_add_funcobjt_sym_forced): Likewise.
	(ctf_add_type): Likewise (on either dict).
	* ctf-dump.c (ctf_dump): Likewise.
	* ctf-lookup.c (ctf_lookup_by_name): Likewise.
	(ctf_lookup_variable): Likewise. Likewise.
	(ctf_lookup_enumerator): Likewise.
	(ctf_lookup_enumerator_next): Likewise.
	(ctf_symbol_next): Likewise.
	(ctf_lookup_by_sym_or_name): Likewise, if doing indexed lookups.
	* ctf-types.c (ctf_member_next): Likewise.
	(ctf_enum_next): Likewise.
	(ctf_type_aname): Likewise.
	(ctf_type_name_raw): Likewise.
	(ctf_type_compat): Likewise, for either dict.
	(ctf_member_info): Likewise.
	(ctf_enum_name): Likewise.
	(ctf_enum_value): Likewise.
	(ctf_type_rvisit): Likewise.
	(ctf_variable_next): Note that we don't need to test LCTF_NO_STR.

diff --git a/include/ctf-api.h b/include/ctf-api.h
index ed01a885392574c416b601c57dc832d6e346416b..07a652987b5f5d78beff55af2a6b1d536b504685 100644 (file)
--- a/include/ctf-api.h
+++ b/include/ctf-api.h
@@ -246,7 +246,9 @@ typedef struct ctf_snapshot_id
   _CTF_ITEM (ECTF_NONAME, "Type name must not be empty.") \
   _CTF_ITEM (ECTF_BADFLAG, "Invalid CTF dict flag specified.") \
   _CTF_ITEM (ECTF_CTFVERS_NO_SERIALIZE, "CTFv1 dicts are too old to serialize.") \
-  _CTF_ITEM (ECTF_UNSTABLE, "Attempt to write unstable file format version: set I_KNOW_LIBCTF_IS_UNSTABLE in the environment.")
+  _CTF_ITEM (ECTF_UNSTABLE, "Attempt to write unstable file format version: set I_KNOW_LIBCTF_IS_UNSTABLE in the environment.") \
+  _CTF_ITEM (ECTF_HASPARENT, "Cannot ctf_import: dict already has a parent.") \
+  _CTF_ITEM (ECTF_WRONGPARENT, "Cannot ctf_import: incorrect parent provided.")
 
 #define        ECTF_BASE       1000    /* Base value for libctf errnos.  */
 
@@ -259,7 +261,7 @@ _CTF_ERRORS
 #undef _CTF_FIRST
   };
 
-#define ECTF_NERR (ECTF_UNSTABLE - ECTF_BASE + 1) /* Count of CTF errors.  */
+#define ECTF_NERR (ECTF_WRONGPARENT - ECTF_BASE + 1) /* Count of CTF errors.  */
 
 /* The CTF data model is inferred to be the caller's data model or the data
    model of the given object, unless ctf_setmodel is explicitly called.  */
@@ -461,7 +463,11 @@ extern void ctf_dict_close (ctf_dict_t *);
    contain the name of their originating compilation unit and the name of
    their parent.  Dicts opened from CTF archives have this relationship set
    up already, but if opening via raw low-level calls, you need to figure
-   out which dict is the parent and set it on the child via ctf_import(). */
+   out which dict is the parent and set it on the child via ctf_import().
+
+   Almost all operations other than ctf_import and ctf_close do not work on
+   child dicts that have not yet had ctf_import called on them; in particular,
+   name lookups and type lookup in general are broken, as is type addition.  */
 
 extern const char *ctf_cuname (ctf_dict_t *);
 extern ctf_dict_t *ctf_parent_dict (ctf_dict_t *);

diff --git a/libctf/ctf-create.c b/libctf/ctf-create.c
index a4d8e7c25284686511be23c1c0be3cc5050663d3..31bf3299a8668054c07b8a36e845a592090e049e 100644 (file)
--- a/libctf/ctf-create.c
+++ b/libctf/ctf-create.c
@@ -365,6 +365,9 @@ ctf_rollback (ctf_dict_t *fp, ctf_snapshot_id_t id)
   ctf_dtdef_t *dtd, *ntd;
   ctf_dvdef_t *dvd, *nvd;
 
+  if (fp->ctf_flags & LCTF_NO_STR)
+    return (ctf_set_errno (fp, ECTF_NOPARENT));
+
   if (id.snapshot_id < fp->ctf_stypes)
     return (ctf_set_errno (fp, ECTF_RDONLY));
 
@@ -432,6 +435,9 @@ ctf_add_generic (ctf_dict_t *fp, uint32_t flag, const char *name, int kind,
   if (LCTF_INDEX_TO_TYPE (fp, fp->ctf_typemax, 1) == (CTF_MAX_PTYPE - 1))
     return (ctf_set_typed_errno (fp, ECTF_FULL));
 
+  if (fp->ctf_flags & LCTF_NO_STR)
+    return (ctf_set_errno (fp, ECTF_NOPARENT));
+
   /* Prohibit addition of a root-visible type that is already present
      in the non-dynamic portion. */
 
@@ -788,6 +794,9 @@ ctf_add_struct_sized (ctf_dict_t *fp, uint32_t flag, const char *name,
   ctf_id_t type = 0;
   size_t initial_vlen = sizeof (ctf_lmember_t) * INITIAL_VLEN;
 
+  if (fp->ctf_flags & LCTF_NO_STR)
+    return (ctf_set_errno (fp, ECTF_NOPARENT));
+
   /* Promote root-visible forwards to structs.  */
   if (name != NULL)
     type = ctf_lookup_by_rawname (fp, CTF_K_STRUCT, name);
@@ -832,6 +841,9 @@ ctf_add_union_sized (ctf_dict_t *fp, uint32_t flag, const char *name,
   ctf_id_t type = 0;
   size_t initial_vlen = sizeof (ctf_lmember_t) * INITIAL_VLEN;
 
+  if (fp->ctf_flags & LCTF_NO_STR)
+    return (ctf_set_errno (fp, ECTF_NOPARENT));
+
   /* Promote root-visible forwards to unions.  */
   if (name != NULL)
     type = ctf_lookup_by_rawname (fp, CTF_K_UNION, name);
@@ -875,6 +887,9 @@ ctf_add_enum (ctf_dict_t *fp, uint32_t flag, const char *name)
   ctf_id_t type = 0;
   size_t initial_vlen = sizeof (ctf_enum_t) * INITIAL_VLEN;
 
+  if (fp->ctf_flags & LCTF_NO_STR)
+    return (ctf_set_errno (fp, ECTF_NOPARENT));
+
   /* Promote root-visible forwards to enums.  */
   if (name != NULL)
     type = ctf_lookup_by_rawname (fp, CTF_K_ENUM, name);
@@ -944,6 +959,9 @@ ctf_add_forward (ctf_dict_t *fp, uint32_t flag, const char *name,
   if (name == NULL || name[0] == '\0')
     return (ctf_set_typed_errno (fp, ECTF_NONAME));
 
+  if (fp->ctf_flags & LCTF_NO_STR)
+    return (ctf_set_errno (fp, ECTF_NOPARENT));
+
   /* If the type is already defined or exists as a forward tag, just return
      the ctf_id_t of the existing definition.  Since this changes nothing,
      it's safe to do even on the read-only portion of the dict.  */
@@ -968,6 +986,9 @@ ctf_add_unknown (ctf_dict_t *fp, uint32_t flag, const char *name)
   ctf_dtdef_t *dtd;
   ctf_id_t type = 0;
 
+  if (fp->ctf_flags & LCTF_NO_STR)
+    return (ctf_set_errno (fp, ECTF_NOPARENT));
+
   /* If a type is already defined with this name, error (if not CTF_K_UNKNOWN)
      or just return it.  */
 
@@ -1060,6 +1081,9 @@ ctf_add_enumerator (ctf_dict_t *fp, ctf_id_t enid, const char *name,
   if (enid < fp->ctf_stypes)
     return (ctf_set_errno (ofp, ECTF_RDONLY));
 
+  if (fp->ctf_flags & LCTF_NO_STR)
+    return (ctf_set_errno (fp, ECTF_NOPARENT));
+
   if (dtd == NULL)
     return (ctf_set_errno (ofp, ECTF_BADID));
 
@@ -1145,6 +1169,9 @@ ctf_add_member_offset (ctf_dict_t *fp, ctf_id_t souid, const char *name,
   unsigned char *old_vlen;
   ctf_lmember_t *memb;
 
+  if (fp->ctf_flags & LCTF_NO_STR)
+    return (ctf_set_errno (fp, ECTF_NOPARENT));
+
   if ((fp->ctf_flags & LCTF_CHILD) && LCTF_TYPE_ISPARENT (fp, souid))
     {
       /* Adding a child type to a parent, even via the child, is prohibited.
@@ -1377,6 +1404,9 @@ ctf_add_variable_forced (ctf_dict_t *fp, const char *name, ctf_id_t ref)
 int
 ctf_add_variable (ctf_dict_t *fp, const char *name, ctf_id_t ref)
 {
+  if (fp->ctf_flags & LCTF_NO_STR)
+    return (ctf_set_errno (fp, ECTF_NOPARENT));
+
   if (ctf_lookup_variable_here (fp, name) != CTF_ERR)
     return (ctf_set_errno (fp, ECTF_DUPLICATE));
 
@@ -1397,6 +1427,9 @@ ctf_add_funcobjt_sym_forced (ctf_dict_t *fp, int is_function, const char *name,
   char *dupname;
   ctf_dynhash_t *h = is_function ? fp->ctf_funchash : fp->ctf_objthash;
 
+  if (fp->ctf_flags & LCTF_NO_STR)
+    return (ctf_set_errno (fp, ECTF_NOPARENT));
+
   if (ctf_lookup_by_id (&tmp, id) == NULL)
     return -1;                         /* errno is set for us.  */
 
@@ -2065,6 +2098,9 @@ ctf_add_type (ctf_dict_t *dst_fp, ctf_dict_t *src_fp, ctf_id_t src_type)
 {
   ctf_id_t id;
 
+  if ((src_fp->ctf_flags & LCTF_NO_STR) || (dst_fp->ctf_flags & LCTF_NO_STR))
+    return (ctf_set_errno (dst_fp, ECTF_NOPARENT));
+
   if (!src_fp->ctf_add_processing)
     src_fp->ctf_add_processing = ctf_dynhash_create (ctf_hash_integer,
                                                     ctf_hash_eq_integer,

diff --git a/libctf/ctf-dump.c b/libctf/ctf-dump.c
index 0c0228fdff279d8d3baa3636c146b98be723980d..be615deb66a7c53af126fbfc47344efc841c98a6 100644 (file)
--- a/libctf/ctf-dump.c
+++ b/libctf/ctf-dump.c
@@ -700,6 +700,12 @@ ctf_dump (ctf_dict_t *fp, ctf_dump_state_t **statep, ctf_sect_names_t sect,
   char *line;
   ctf_dump_state_t *state = NULL;
 
+  if (fp->ctf_flags & LCTF_NO_STR)
+    {
+      ctf_set_errno (fp, ECTF_NOPARENT);
+      return NULL;
+    }
+
   if (*statep == NULL)
     {
       /* Data collection.  Transforming a call-at-a-time iterator into a

diff --git a/libctf/ctf-impl.h b/libctf/ctf-impl.h
index c4eeb9e50929ae65d000154f813f7ea7707a5702..ce0e186e08a96ce69545587715980f8c3862290d 100644 (file)
--- a/libctf/ctf-impl.h
+++ b/libctf/ctf-impl.h
@@ -601,8 +601,10 @@ struct ctf_next
 #define LCTF_VBYTES(fp, kind, size, vlen) \
   ((fp)->ctf_dictops->ctfo_get_vbytes(fp, kind, size, vlen))
 
-#define LCTF_CHILD     0x0001  /* CTF dict is a child.  */
+#define LCTF_CHILD             0x0001  /* CTF dict is a child.  */
+#define LCTF_LINKING           0x0002  /* CTF link is underway: respect ctf_link_flags.  */
 #define LCTF_STRICT_NO_DUP_ENUMERATORS 0x0004 /* Duplicate enums prohibited.  */
+#define LCTF_NO_STR            0x0008  /* No string lookup possible yet.  */
 #define LCTF_NO_SERIALIZE      0x0010  /* Serialization of this dict prohibited.  */
 
 extern ctf_dynhash_t *ctf_name_table (ctf_dict_t *, int);

diff --git a/libctf/ctf-lookup.c b/libctf/ctf-lookup.c
index af35be0167113d727dd4f50d534bbec386a081ee..c3ffeb05b791c4dfb1cf55f6a3ed321d757c4bd0 100644 (file)
--- a/libctf/ctf-lookup.c
+++ b/libctf/ctf-lookup.c
@@ -319,6 +319,9 @@ ctf_lookup_by_name_internal (ctf_dict_t *fp, ctf_dict_t *child,
 ctf_id_t
 ctf_lookup_by_name (ctf_dict_t *fp, const char *name)
 {
+  if (fp->ctf_flags & LCTF_NO_STR)
+    return (ctf_set_typed_errno (fp, ECTF_NOPARENT));
+
   return ctf_lookup_by_name_internal (fp, NULL, name);
 }
 
@@ -398,6 +401,9 @@ ctf_lookup_variable (ctf_dict_t *fp, const char *name)
 {
   ctf_id_t type;
 
+  if (fp->ctf_flags & LCTF_NO_STR)
+    return (ctf_set_typed_errno (fp, ECTF_NOPARENT));
+
   if ((type = ctf_lookup_variable_here (fp, name)) == CTF_ERR)
     {
       if (ctf_errno (fp) == ECTF_NOTYPEDAT && fp->ctf_parent != NULL)
@@ -426,6 +432,9 @@ ctf_lookup_enumerator (ctf_dict_t *fp, const char *name, int64_t *enum_value)
   ctf_id_t type;
   int enum_int_value;
 
+  if (fp->ctf_flags & LCTF_NO_STR)
+    return (ctf_set_typed_errno (fp, ECTF_NOPARENT));
+
   if (ctf_dynset_lookup (fp->ctf_conflicting_enums, name))
     return (ctf_set_typed_errno (fp, ECTF_DUPLICATE));
 
@@ -467,6 +476,9 @@ ctf_lookup_enumerator_next (ctf_dict_t *fp, const char *name,
   ctf_next_t *i = *it;
   int found = 0;
 
+  if (fp->ctf_flags & LCTF_NO_STR)
+    return (ctf_set_typed_errno (fp, ECTF_NOPARENT));
+
   /* We use ctf_type_next() to iterate across all types, but then traverse each
      enumerator found by hand: traversing enumerators is very easy, and it would
      probably be more confusing to use two nested iterators than to do it this
@@ -836,6 +848,9 @@ ctf_symbol_next (ctf_dict_t *fp, ctf_next_t **it, const char **name,
   ctf_next_t *i = *it;
   int err;
 
+  if (fp->ctf_flags & LCTF_NO_STR)
+    return (ctf_set_typed_errno (fp, ECTF_NOPARENT));
+
   if (!i)
     {
       if ((i = ctf_next_create ()) == NULL)
@@ -1201,15 +1216,22 @@ ctf_lookup_by_sym_or_name (ctf_dict_t *fp, unsigned long symidx,
   if (symname == NULL && symidx >= fp->ctf_nsyms)
     goto try_parent;
 
-  /* Try an indexed lookup.  */
+  /* Try an indexed lookup.  We can only do indexed lookups if we have a string
+     table.  */
 
   if (fp->ctf_objtidx_names && is_function != 1)
     {
+      if (fp->ctf_flags & LCTF_NO_STR)
+       return (ctf_set_typed_errno (fp, ECTF_NOPARENT));
+
       if ((type = ctf_try_lookup_indexed (fp, symidx, symname, 0)) == CTF_ERR)
        return CTF_ERR;                         /* errno is set for us.  */
     }
   if (type == 0 && fp->ctf_funcidx_names && is_function != 0)
     {
+      if (fp->ctf_flags & LCTF_NO_STR)
+       return (ctf_set_typed_errno (fp, ECTF_NOPARENT));
+
       if ((type = ctf_try_lookup_indexed (fp, symidx, symname, 1)) == CTF_ERR)
        return CTF_ERR;                         /* errno is set for us.  */
     }

diff --git a/libctf/ctf-types.c b/libctf/ctf-types.c
index 45200b78d79173877ca89c7afd1049bb46ffe85e..fa68e928afdae0cd7a957a50176ea56867c80bcc 100644 (file)
--- a/libctf/ctf-types.c
+++ b/libctf/ctf-types.c
@@ -105,6 +105,9 @@ ctf_member_next (ctf_dict_t *fp, ctf_id_t type, ctf_next_t **it,
   uint32_t max_vlen;
   ctf_next_t *i = *it;
 
+  if (fp->ctf_flags & LCTF_NO_STR)
+    return (ctf_set_errno (fp, ECTF_NOPARENT));
+
   if (!i)
     {
       const ctf_type_t *tp;
@@ -274,6 +277,12 @@ ctf_enum_next (ctf_dict_t *fp, ctf_id_t type, ctf_next_t **it,
   const char *name;
   ctf_next_t *i = *it;
 
+  if (fp->ctf_flags & LCTF_NO_STR)
+    {
+      ctf_set_errno (fp, ECTF_NOPARENT);
+      return NULL;
+    }
+
   if (!i)
     {
       const ctf_type_t *tp;
@@ -494,6 +503,9 @@ ctf_variable_next (ctf_dict_t *fp, ctf_next_t **it, const char **name)
   ctf_next_t *i = *it;
   ctf_id_t id;
 
+  /* (No need for a LCTF_NO_STR check: checking for a missing parent covers more
+     cases, and we need to do that anyway.)  */
+
   if ((fp->ctf_flags & LCTF_CHILD) && (fp->ctf_parent == NULL))
     return (ctf_set_typed_errno (fp, ECTF_NOPARENT));
 
@@ -649,6 +661,12 @@ ctf_type_aname (ctf_dict_t *fp, ctf_id_t type)
   if (fp == NULL && type == CTF_ERR)
     return NULL;       /* Simplify caller code by permitting CTF_ERR.  */
 
+  if (fp->ctf_flags & LCTF_NO_STR)
+    {
+      ctf_set_errno (fp, ECTF_NOPARENT);
+      return NULL;
+    }
+
   ctf_decl_init (&cd);
   ctf_decl_push (&cd, fp, type);
 
@@ -867,6 +885,12 @@ ctf_type_name_raw (ctf_dict_t *fp, ctf_id_t type)
 {
   const ctf_type_t *tp;
 
+  if (fp->ctf_flags & LCTF_NO_STR)
+    {
+      ctf_set_errno (fp, ECTF_NOPARENT);
+      return NULL;
+    }
+
   if ((tp = ctf_lookup_by_id (&fp, type)) == NULL)
     return NULL;               /* errno is set for us.  */
 
@@ -1268,6 +1292,12 @@ ctf_type_compat (ctf_dict_t *lfp, ctf_id_t ltype,
   uint32_t lkind, rkind;
   int same_names = 0;
 
+  if (lfp->ctf_flags & LCTF_NO_STR)
+    return (ctf_set_errno (lfp, ECTF_NOPARENT));
+
+  if (rfp->ctf_flags & LCTF_NO_STR)
+    return (ctf_set_errno (rfp, ECTF_NOPARENT));
+
   if (ctf_type_cmp (lfp, ltype, rfp, rtype) == 0)
     return 1;
 
@@ -1368,6 +1398,9 @@ ctf_member_info (ctf_dict_t *fp, ctf_id_t type, const char *name,
   ssize_t size, increment, vbytes;
   uint32_t kind, n, i = 0;
 
+  if (fp->ctf_flags & LCTF_NO_STR)
+    return (ctf_set_errno (fp, ECTF_NOPARENT));
+
   if ((type = ctf_type_resolve (fp, type)) == CTF_ERR)
     return -1;                 /* errno is set for us.  */
 
@@ -1466,6 +1499,12 @@ ctf_enum_name (ctf_dict_t *fp, ctf_id_t type, int value)
   ssize_t increment;
   uint32_t n;
 
+  if (fp->ctf_flags & LCTF_NO_STR)
+    {
+      ctf_set_errno (fp, ECTF_NOPARENT);
+      return NULL;
+    }
+
   if ((type = ctf_type_resolve_unsliced (fp, type)) == CTF_ERR)
     return NULL;               /* errno is set for us.  */
 
@@ -1508,6 +1547,9 @@ ctf_enum_value (ctf_dict_t *fp, ctf_id_t type, const char *name, int *valp)
   ssize_t increment;
   uint32_t n;
 
+  if (fp->ctf_flags & LCTF_NO_STR)
+    return (ctf_set_errno (fp, ECTF_NOPARENT));
+
   if ((type = ctf_type_resolve_unsliced (fp, type)) == CTF_ERR)
     return -1;                 /* errno is set for us.  */
 
@@ -1634,6 +1676,9 @@ ctf_type_rvisit (ctf_dict_t *fp, ctf_id_t type, ctf_visit_f *func,
   int nonrepresentable = 0;
   int rc;
 
+  if (fp->ctf_flags & LCTF_NO_STR)
+    return (ctf_set_errno (fp, ECTF_NOPARENT));
+
   if ((type = ctf_type_resolve (fp, type)) == CTF_ERR) {
     if (ctf_errno (fp) != ECTF_NONREPRESENTABLE)
       return -1;               /* errno is set for us.  */