libctf: failure to open parent dicts that exist should be an error

CTF archive member opening (via ctf_arc_open_by_name, ctf_archive_iter, et
al) attempts to be helpful and auto-open and import any needed parent dict
in the same archive.  But if this fails, the error is not reported but
simply discarded, and you silently get back a dict with no parent, that
*you* suddenly have to remember to import.

This is not helpful behaviour: if the parent is corrupted or we run out of
memory or something, the caller is going to want to know!  Split it in two:
if the dict cites a parent that doesn't exist at all (a lot of historic
dicts name "PARENT" as their parent, even when they're not even children, or
perhaps the parent dict is stored separately and you plan to manually
associate it), we skip it as now, but if the import fails with an actual
error other than ECTF_ARNNAME, return the error and fail the open.

libctf/
	* ctf-archive.c (ctf_arc_import_parent):  Return failure if
        parent opening fails for reasons other thnn nonexistence.
	(ctf_dict_open_sections): Adjust.

diff --git a/libctf/ctf-archive.c b/libctf/ctf-archive.c
index 3f12c0da85d853edca63a52a5d1e8929d3469864..451d6c697355e1e538f3d17a51c64bdcd78ffd86 100644 (file)
--- a/libctf/ctf-archive.c
+++ b/libctf/ctf-archive.c
@@ -44,7 +44,8 @@ static void *arc_mmap_file (int fd, size_t size);
 static int arc_mmap_writeout (int fd, void *header, size_t headersz,
                              const char **errmsg);
 static int arc_mmap_unmap (void *header, size_t headersz, const char **errmsg);
-static void ctf_arc_import_parent (const ctf_archive_t *arc, ctf_dict_t *fp);
+static int ctf_arc_import_parent (const ctf_archive_t *arc, ctf_dict_t *fp,
+                                 int *errp);
 
 /* Flag to indicate "symbol not present" in ctf_archive_internal.ctfi_symdicts
    and ctfi_symnamedicts.  Never initialized.  */
@@ -602,7 +603,11 @@ ctf_dict_open_sections (const ctf_archive_t *arc,
       if (ret)
        {
          ret->ctf_archive = (ctf_archive_t *) arc;
-         ctf_arc_import_parent (arc, ret);
+         if (ctf_arc_import_parent (arc, ret, errp) < 0)
+           {
+             ctf_dict_close (ret);
+             return NULL;
+           }
        }
       return ret;
     }
@@ -757,19 +762,26 @@ ctf_arc_open_by_name_sections (const ctf_archive_t *arc,
    already set, and a suitable archive member exists.  No error is raised if
    this is not possible: this is just a best-effort helper operation to give
    people useful dicts to start with.  */
-static void
-ctf_arc_import_parent (const ctf_archive_t *arc, ctf_dict_t *fp)
+static int
+ctf_arc_import_parent (const ctf_archive_t *arc, ctf_dict_t *fp, int *errp)
 {
   if ((fp->ctf_flags & LCTF_CHILD) && fp->ctf_parname && !fp->ctf_parent)
     {
+      int err;
       ctf_dict_t *parent = ctf_dict_open_cached ((ctf_archive_t *) arc,
-                                                fp->ctf_parname, NULL);
+                                                fp->ctf_parname, &err);
+      if (errp)
+       *errp = err;
+
       if (parent)
        {
          ctf_import (fp, parent);
          ctf_dict_close (parent);
        }
+      else if (err != ECTF_ARNNAME)
+       return -1;                              /* errno is set for us.  */
     }
+  return 0;
 }
 
 /* Return the number of members in an archive.  */