[v4,33/35,NEW] libctf: remove ctf_malloc, ctf_free and ctf_strdup

Message ID 20190924135131.441906-34-nick.alcock@oracle.com
State New
Headers show
Series
  • CTF linking support
Related show

Commit Message

Nick Alcock Sept. 24, 2019, 1:51 p.m.
These just get in the way of auditing for erroneous usage of strdup and
add a huge irregular surface of "ctf_malloc or malloc? ctf_free or free?
ctf_strdup or strdup?"

ctf_malloc and ctf_free usage has not reliably matched up for many
years, if ever, making the whole game pointless.

Go back to malloc, free, and strdup like everyone else: while we're at
it, fix a bunch of places where we weren't properly checking for OOM.
This changes the interface of ctf_cuname_set and ctf_parent_name_set,
which could strdup but could not return errors (like ENOMEM).

New in v4.

include/
	* ctf-api.h (ctf_cuname_set): Can now fail, returning int.
	(ctf_parent_name_set): Likewise.
libctf/
	* ctf-impl.h (ctf_alloc): Remove.
	(ctf_free): Likewise.
	(ctf_strdup): Likewise.
	* ctf-subr.c (ctf_alloc): Remove.
	(ctf_free): Likewise.
	* ctf-util.c (ctf_strdup): Remove.

	* ctf-create.c (ctf_serialize): Use malloc, not ctf_alloc; free, not
	ctf_free; strdup, not ctf_strdup.
	(ctf_dtd_delete): Likewise.
	(ctf_dvd_delete): Likewise.
	(ctf_add_generic): Likewise.
	(ctf_add_function): Likewise.
	(ctf_add_enumerator): Likewise.
	(ctf_add_member_offset): Likewise.
	(ctf_add_variable): Likewise.
	(membadd): Likewise.
	(ctf_compress_write): Likewise.
	(ctf_write_mem): Likewise.
	* ctf-decl.c (ctf_decl_push): Likewise.
	(ctf_decl_fini): Likewise.
	(ctf_decl_sprintf): Likewise.  Check for OOM.
	* ctf-dump.c (ctf_dump_append): Use malloc, not ctf_alloc; free, not
	ctf_free; strdup, not ctf_strdup.
	(ctf_dump_free): Likewise.
	(ctf_dump): Likewise.
	* ctf-open.c (upgrade_types_v1): Likewise.
	(init_types): Likewise.
	(ctf_file_close): Likewise.
	(ctf_bufopen_internal): Likewise.  Check for OOM.
	(ctf_parent_name_set): Likewise: report the OOM to the caller.
	(ctf_cuname_set): Likewise.
	(ctf_import): Likewise.
	* ctf-string.c (ctf_str_purge_atom_refs): Use malloc, not ctf_alloc;
	free, not ctf_free; strdup, not ctf_strdup.
	(ctf_str_free_atom): Likewise.
	(ctf_str_create_atoms): Likewise.
	(ctf_str_add_ref_internal): Likewise.
	(ctf_str_remove_ref): Likewise.
	(ctf_str_write_strtab): Likewise.
---
 include/ctf-api.h   |  4 +-
 libctf/ctf-create.c | 65 ++++++++++++++++----------------
 libctf/ctf-decl.c   | 12 ++++--
 libctf/ctf-dump.c   |  8 ++--
 libctf/ctf-impl.h   |  6 ---
 libctf/ctf-open.c   | 92 ++++++++++++++++++++++++++++-----------------
 libctf/ctf-string.c | 22 +++++------
 libctf/ctf-subr.c   | 12 ------
 libctf/ctf-util.c   | 13 -------
 9 files changed, 115 insertions(+), 119 deletions(-)

-- 
2.23.0.239.g28aa4420fd

Patch

diff --git a/include/ctf-api.h b/include/ctf-api.h
index b83ddc7a3be..d15b7342103 100644
--- a/include/ctf-api.h
+++ b/include/ctf-api.h
@@ -286,10 +286,10 @@  extern int ctf_arc_write_fd (int, ctf_file_t **, size_t, const char **,
 			     size_t);
 
 extern const char *ctf_cuname (ctf_file_t *);
-extern void ctf_cuname_set (ctf_file_t *, const char *);
+extern int ctf_cuname_set (ctf_file_t *, const char *);
 extern ctf_file_t *ctf_parent_file (ctf_file_t *);
 extern const char *ctf_parent_name (ctf_file_t *);
-extern void ctf_parent_name_set (ctf_file_t *, const char *);
+extern int ctf_parent_name_set (ctf_file_t *, const char *);
 extern int ctf_type_isparent (ctf_file_t *, ctf_id_t);
 extern int ctf_type_ischild (ctf_file_t *, ctf_id_t);
 
diff --git a/libctf/ctf-create.c b/libctf/ctf-create.c
index 1969600b7f1..8a42ff966bb 100644
--- a/libctf/ctf-create.c
+++ b/libctf/ctf-create.c
@@ -479,7 +479,7 @@  ctf_serialize (ctf_file_t *fp)
 
   if (strtab.cts_strs == NULL)
     {
-      ctf_free (buf);
+      free (buf);
       return (ctf_set_errno (fp, EAGAIN));
     }
 
@@ -491,8 +491,8 @@  ctf_serialize (ctf_file_t *fp)
 
   if ((newbuf = ctf_realloc (fp, buf, buf_size + strtab.cts_len)) == NULL)
     {
-      ctf_free (buf);
-      ctf_free (strtab.cts_strs);
+      free (buf);
+      free (strtab.cts_strs);
       return (ctf_set_errno (fp, EAGAIN));
     }
   buf = newbuf;
@@ -500,7 +500,7 @@  ctf_serialize (ctf_file_t *fp)
   hdrp = (ctf_header_t *) buf;
   hdrp->cth_strlen = strtab.cts_len;
   buf_size += hdrp->cth_strlen;
-  ctf_free (strtab.cts_strs);
+  free (strtab.cts_strs);
 
   /* Finally, we are ready to ctf_simple_open() the new container.  If this
      is successful, we then switch nfp and fp and free the old container.  */
@@ -509,7 +509,7 @@  ctf_serialize (ctf_file_t *fp)
 				       0, NULL, 0, fp->ctf_syn_ext_strtab,
 				       1, &err)) == NULL)
     {
-      ctf_free (buf);
+      free (buf);
       return (ctf_set_errno (fp, err));
     }
 
@@ -635,13 +635,13 @@  ctf_dtd_delete (ctf_file_t *fp, ctf_dtdef_t *dtd)
 	   dmd != NULL; dmd = nmd)
 	{
 	  if (dmd->dmd_name != NULL)
-	      ctf_free (dmd->dmd_name);
+	      free (dmd->dmd_name);
 	  nmd = ctf_list_next (dmd);
-	  ctf_free (dmd);
+	  free (dmd);
 	}
       break;
     case CTF_K_FUNCTION:
-      ctf_free (dtd->dtd_u.dtu_argv);
+      free (dtd->dtd_u.dtu_argv);
       break;
     }
 
@@ -654,7 +654,7 @@  ctf_dtd_delete (ctf_file_t *fp, ctf_dtdef_t *dtd)
     }
 
   ctf_list_delete (&fp->ctf_dtdefs, dtd);
-  ctf_free (dtd);
+  free (dtd);
 }
 
 ctf_dtdef_t *
@@ -694,10 +694,10 @@  void
 ctf_dvd_delete (ctf_file_t *fp, ctf_dvdef_t *dvd)
 {
   ctf_dynhash_remove (fp->ctf_dvhash, dvd->dvd_name);
-  ctf_free (dvd->dvd_name);
+  free (dvd->dvd_name);
 
   ctf_list_delete (&fp->ctf_dvdefs, dvd);
-  ctf_free (dvd);
+  free (dvd);
 }
 
 ctf_dvdef_t *
@@ -815,7 +815,7 @@  ctf_add_generic (ctf_file_t *fp, uint32_t flag, const char *name, int kind,
   if (ctf_grow_ptrtab (fp) < 0)
       return CTF_ERR;		/* errno is set for us. */
 
-  if ((dtd = ctf_alloc (sizeof (ctf_dtdef_t))) == NULL)
+  if ((dtd = malloc (sizeof (ctf_dtdef_t))) == NULL)
     return (ctf_set_errno (fp, EAGAIN));
 
   type = ++fp->ctf_typemax;
@@ -827,13 +827,13 @@  ctf_add_generic (ctf_file_t *fp, uint32_t flag, const char *name, int kind,
 
   if (dtd->dtd_data.ctt_name == 0 && name != NULL && name[0] != '\0')
     {
-      ctf_free (dtd);
+      free (dtd);
       return (ctf_set_errno (fp, EAGAIN));
     }
 
   if (ctf_dtd_insert (fp, dtd, kind) < 0)
     {
-      ctf_free (dtd);
+      free (dtd);
       return CTF_ERR;			/* errno is set for us.  */
     }
   fp->ctf_flags |= LCTF_DIRTY;
@@ -1066,13 +1066,13 @@  ctf_add_function (ctf_file_t *fp, uint32_t flag,
   if (vlen > CTF_MAX_VLEN)
     return (ctf_set_errno (fp, EOVERFLOW));
 
-  if (vlen != 0 && (vdat = ctf_alloc (sizeof (ctf_id_t) * vlen)) == NULL)
+  if (vlen != 0 && (vdat = malloc (sizeof (ctf_id_t) * vlen)) == NULL)
     return (ctf_set_errno (fp, EAGAIN));
 
   if ((type = ctf_add_generic (fp, flag, NULL, CTF_K_FUNCTION,
 			       &dtd)) == CTF_ERR)
     {
-      ctf_free (vdat);
+      free (vdat);
       return CTF_ERR;		   /* errno is set for us.  */
     }
 
@@ -1315,12 +1315,12 @@  ctf_add_enumerator (ctf_file_t *fp, ctf_id_t enid, const char *name,
 	return (ctf_set_errno (fp, ECTF_DUPLICATE));
     }
 
-  if ((dmd = ctf_alloc (sizeof (ctf_dmdef_t))) == NULL)
+  if ((dmd = malloc (sizeof (ctf_dmdef_t))) == NULL)
     return (ctf_set_errno (fp, EAGAIN));
 
-  if ((s = ctf_strdup (name)) == NULL)
+  if ((s = strdup (name)) == NULL)
     {
-      ctf_free (dmd);
+      free (dmd);
       return (ctf_set_errno (fp, EAGAIN));
     }
 
@@ -1378,12 +1378,12 @@  ctf_add_member_offset (ctf_file_t *fp, ctf_id_t souid, const char *name,
       (malign = ctf_type_align (fp, type)) < 0)
     return -1;			/* errno is set for us.  */
 
-  if ((dmd = ctf_alloc (sizeof (ctf_dmdef_t))) == NULL)
+  if ((dmd = malloc (sizeof (ctf_dmdef_t))) == NULL)
     return (ctf_set_errno (fp, EAGAIN));
 
-  if (name != NULL && (s = ctf_strdup (name)) == NULL)
+  if (name != NULL && (s = strdup (name)) == NULL)
     {
-      ctf_free (dmd);
+      free (dmd);
       return (ctf_set_errno (fp, EAGAIN));
     }
 
@@ -1500,12 +1500,12 @@  ctf_add_variable (ctf_file_t *fp, const char *name, ctf_id_t ref)
       && (ctf_errno (fp) == ECTF_NONREPRESENTABLE))
     return -1;
 
-  if ((dvd = ctf_alloc (sizeof (ctf_dvdef_t))) == NULL)
+  if ((dvd = malloc (sizeof (ctf_dvdef_t))) == NULL)
     return (ctf_set_errno (fp, EAGAIN));
 
-  if (name != NULL && (dvd->dvd_name = ctf_strdup (name)) == NULL)
+  if (name != NULL && (dvd->dvd_name = strdup (name)) == NULL)
     {
-      ctf_free (dvd);
+      free (dvd);
       return (ctf_set_errno (fp, EAGAIN));
     }
   dvd->dvd_type = ref;
@@ -1513,7 +1513,8 @@  ctf_add_variable (ctf_file_t *fp, const char *name, ctf_id_t ref)
 
   if (ctf_dvd_insert (fp, dvd) < 0)
     {
-      ctf_free (dvd);
+      free (dvd->dvd_name);
+      free (dvd);
       return -1;			/* errno is set for us.  */
     }
 
@@ -1580,12 +1581,12 @@  membadd (const char *name, ctf_id_t type, unsigned long offset, void *arg)
   ctf_dmdef_t *dmd;
   char *s = NULL;
 
-  if ((dmd = ctf_alloc (sizeof (ctf_dmdef_t))) == NULL)
+  if ((dmd = malloc (sizeof (ctf_dmdef_t))) == NULL)
     return (ctf_set_errno (ctb->ctb_file, EAGAIN));
 
-  if (name != NULL && (s = ctf_strdup (name)) == NULL)
+  if (name != NULL && (s = strdup (name)) == NULL)
     {
-      ctf_free (dmd);
+      free (dmd);
       return (ctf_set_errno (ctb->ctb_file, EAGAIN));
     }
 
@@ -2115,7 +2116,7 @@  ctf_compress_write (ctf_file_t *fp, int fd)
   hp->cth_flags |= CTF_F_COMPRESS;
   compress_len = compressBound (fp->ctf_size);
 
-  if ((buf = ctf_alloc (compress_len)) == NULL)
+  if ((buf = malloc (compress_len)) == NULL)
     return (ctf_set_errno (fp, ECTF_ZALLOC));
 
   if ((rc = compress (buf, (uLongf *) &compress_len,
@@ -2150,7 +2151,7 @@  ctf_compress_write (ctf_file_t *fp, int fd)
     }
 
 ret:
-  ctf_free (buf);
+  free (buf);
   return err;
 }
 
@@ -2198,7 +2199,7 @@  ctf_write_mem (ctf_file_t *fp, size_t *size, size_t threshold)
 	{
 	  ctf_dprintf ("zlib deflate err: %s\n", zError (rc));
 	  ctf_set_errno (fp, ECTF_COMPRESS);
-	  ctf_free (buf);
+	  free (buf);
 	  return NULL;
 	}
       *size += compress_len;
diff --git a/libctf/ctf-decl.c b/libctf/ctf-decl.c
index c85982e4a3f..584bd5ed40b 100644
--- a/libctf/ctf-decl.c
+++ b/libctf/ctf-decl.c
@@ -65,7 +65,7 @@  ctf_decl_fini (ctf_decl_t *cd)
       for (cdp = ctf_list_next (&cd->cd_nodes[i]); cdp != NULL; cdp = ndp)
 	{
 	  ndp = ctf_list_next (cdp);
-	  ctf_free (cdp);
+	  free (cdp);
 	}
     }
 }
@@ -132,7 +132,7 @@  ctf_decl_push (ctf_decl_t *cd, ctf_file_t *fp, ctf_id_t type)
       prec = CTF_PREC_BASE;
     }
 
-  if ((cdp = ctf_alloc (sizeof (ctf_decl_node_t))) == NULL)
+  if ((cdp = malloc (sizeof (ctf_decl_node_t))) == NULL)
     {
       cd->cd_err = EAGAIN;
       return;
@@ -176,10 +176,14 @@  void ctf_decl_sprintf (ctf_decl_t *cd, const char *format, ...)
   va_end (ap);
 
   if (n > 0)
-      cd->cd_buf = ctf_str_append (cd->cd_buf, str);
+    {
+      char *newbuf;
+      if ((newbuf = ctf_str_append (cd->cd_buf, str)) != NULL)
+	cd->cd_buf = newbuf;
+    }
 
   /* Sticky error condition.  */
-  if (n < 0)
+  if (n < 0 || cd->cd_buf == NULL)
     {
       free (cd->cd_buf);
       cd->cd_buf = NULL;
diff --git a/libctf/ctf-dump.c b/libctf/ctf-dump.c
index ef802cf2218..4478edc2bee 100644
--- a/libctf/ctf-dump.c
+++ b/libctf/ctf-dump.c
@@ -52,7 +52,7 @@  ctf_dump_append (ctf_dump_state_t *state, char *str)
 {
   ctf_dump_item_t *cdi;
 
-  if ((cdi = ctf_alloc (sizeof (struct ctf_dump_item))) == NULL)
+  if ((cdi = malloc (sizeof (struct ctf_dump_item))) == NULL)
     return (ctf_set_errno (state->cds_fp, ENOMEM));
 
   cdi->cdi_item = str;
@@ -73,7 +73,7 @@  ctf_dump_free (ctf_dump_state_t *state)
     {
       free (cdi->cdi_item);
       next_cdi = ctf_list_next (cdi);
-      ctf_free (cdi);
+      free (cdi);
     }
 }
 
@@ -668,7 +668,7 @@  ctf_dump (ctf_file_t *fp, ctf_dump_state_t **statep, ctf_sect_names_t sect,
 	 by bit.  The first call will take (much) longer than otherwise, but the
 	 amortized time needed is the same.  */
 
-      if ((*statep = ctf_alloc (sizeof (struct ctf_dump_state))) == NULL)
+      if ((*statep = malloc (sizeof (struct ctf_dump_state))) == NULL)
 	{
 	  ctf_set_errno (fp, ENOMEM);
 	  goto end;
@@ -779,7 +779,7 @@  ctf_dump (ctf_file_t *fp, ctf_dump_state_t **statep, ctf_sect_names_t sect,
 
  end:
   ctf_dump_free (state);
-  ctf_free (state);
+  free (state);
   ctf_set_errno (fp, 0);
   *statep = NULL;
   return NULL;
diff --git a/libctf/ctf-impl.h b/libctf/ctf-impl.h
index 90e35272c68..0485b976192 100644
--- a/libctf/ctf-impl.h
+++ b/libctf/ctf-impl.h
@@ -455,13 +455,7 @@  extern void *ctf_mmap (size_t length, size_t offset, int fd);
 extern void ctf_munmap (void *, size_t);
 extern ssize_t ctf_pread (int fd, void *buf, ssize_t count, off_t offset);
 
-_libctf_malloc_
-extern void *ctf_alloc (size_t);
-extern void ctf_free (void *);
 extern void *ctf_realloc (ctf_file_t *, void *, size_t);
-
-_libctf_malloc_
-extern char *ctf_strdup (const char *);
 extern char *ctf_str_append (char *, const char *);
 extern const char *ctf_strerror (int);
 
diff --git a/libctf/ctf-open.c b/libctf/ctf-open.c
index b6989579465..4a95b7f38a5 100644
--- a/libctf/ctf-open.c
+++ b/libctf/ctf-open.c
@@ -446,7 +446,7 @@  upgrade_types_v1 (ctf_file_t *fp, ctf_header_t *cth)
      number unchanged, so that LCTF_INFO_* still works on the
      as-yet-untranslated type info.  */
 
-  if ((ctf_base = ctf_alloc (fp->ctf_size + increase)) == NULL)
+  if ((ctf_base = malloc (fp->ctf_size + increase)) == NULL)
     return ECTF_ZALLOC;
 
   /* Start at ctf_buf, not ctf_base, to squeeze out the original header: we
@@ -613,7 +613,7 @@  upgrade_types_v1 (ctf_file_t *fp, ctf_header_t *cth)
   assert ((size_t) t2p - (size_t) fp->ctf_buf == cth->cth_stroff);
 
   ctf_set_version (fp, cth, CTF_VERSION_1_UPGRADED_3);
-  ctf_free (old_ctf_base);
+  free (old_ctf_base);
 
   return 0;
 }
@@ -746,9 +746,9 @@  init_types (ctf_file_t *fp, ctf_header_t *cth)
 			  ctf_hash_eq_string)) == NULL)
     return ENOMEM;
 
-  fp->ctf_txlate = ctf_alloc (sizeof (uint32_t) * (fp->ctf_typemax + 1));
+  fp->ctf_txlate = malloc (sizeof (uint32_t) * (fp->ctf_typemax + 1));
   fp->ctf_ptrtab_len = fp->ctf_typemax + 1;
-  fp->ctf_ptrtab = ctf_alloc (sizeof (uint32_t) * fp->ctf_ptrtab_len);
+  fp->ctf_ptrtab = malloc (sizeof (uint32_t) * fp->ctf_ptrtab_len);
 
   if (fp->ctf_txlate == NULL || fp->ctf_ptrtab == NULL)
     return ENOMEM;		/* Memory allocation failed.  */
@@ -1370,7 +1370,7 @@  ctf_bufopen_internal (const ctf_sect_t *ctfsect, const ctf_sect_t *symsect,
   if (ctfsect->cts_size < hdrsz)
     return (ctf_set_open_errno (errp, ECTF_NOCTFBUF));
 
-  if ((fp = ctf_alloc (sizeof (ctf_file_t))) == NULL)
+  if ((fp = malloc (sizeof (ctf_file_t))) == NULL)
     return (ctf_set_open_errno (errp, ENOMEM));
 
   memset (fp, 0, sizeof (ctf_file_t));
@@ -1378,9 +1378,9 @@  ctf_bufopen_internal (const ctf_sect_t *ctfsect, const ctf_sect_t *symsect,
   if (writable)
     fp->ctf_flags |= LCTF_RDWR;
 
-  if ((fp->ctf_header = ctf_alloc (sizeof (struct ctf_header))) == NULL)
+  if ((fp->ctf_header = malloc (sizeof (struct ctf_header))) == NULL)
     {
-      ctf_free (fp);
+      free (fp);
       return (ctf_set_open_errno (errp, ENOMEM));
     }
   hp = fp->ctf_header;
@@ -1435,7 +1435,7 @@  ctf_bufopen_internal (const ctf_sect_t *ctfsect, const ctf_sect_t *symsect,
       /* We are allocating this ourselves, so we can drop the ctf header
 	 copy in favour of ctf->ctf_header.  */
 
-      if ((fp->ctf_base = ctf_alloc (fp->ctf_size)) == NULL)
+      if ((fp->ctf_base = malloc (fp->ctf_size)) == NULL)
 	{
 	  err = ECTF_ZALLOC;
 	  goto bad;
@@ -1466,7 +1466,7 @@  ctf_bufopen_internal (const ctf_sect_t *ctfsect, const ctf_sect_t *symsect,
     }
   else if (foreign_endian)
     {
-      if ((fp->ctf_base = ctf_alloc (fp->ctf_size)) == NULL)
+      if ((fp->ctf_base = malloc (fp->ctf_size)) == NULL)
 	{
 	  err = ECTF_ZALLOC;
 	  goto bad;
@@ -1506,11 +1506,23 @@  ctf_bufopen_internal (const ctf_sect_t *ctfsect, const ctf_sect_t *symsect,
     }
 
   if (fp->ctf_data.cts_name != NULL)
-    fp->ctf_data.cts_name = ctf_strdup (fp->ctf_data.cts_name);
+    if ((fp->ctf_data.cts_name = strdup (fp->ctf_data.cts_name)) == NULL)
+      {
+	err = ENOMEM;
+	goto bad;
+      }
   if (fp->ctf_symtab.cts_name != NULL)
-    fp->ctf_symtab.cts_name = ctf_strdup (fp->ctf_symtab.cts_name);
+    if ((fp->ctf_symtab.cts_name = strdup (fp->ctf_symtab.cts_name)) == NULL)
+      {
+	err = ENOMEM;
+	goto bad;
+      }
   if (fp->ctf_strtab.cts_name != NULL)
-    fp->ctf_strtab.cts_name = ctf_strdup (fp->ctf_strtab.cts_name);
+    if ((fp->ctf_strtab.cts_name = strdup (fp->ctf_strtab.cts_name)) == NULL)
+      {
+	err = ENOMEM;
+	goto bad;
+      }
 
   if (fp->ctf_data.cts_name == NULL)
     fp->ctf_data.cts_name = _CTF_NULLSTR;
@@ -1558,7 +1570,7 @@  ctf_bufopen_internal (const ctf_sect_t *ctfsect, const ctf_sect_t *symsect,
   if (symsect != NULL)
     {
       fp->ctf_nsyms = symsect->cts_size / symsect->cts_entsize;
-      fp->ctf_sxlate = ctf_alloc (fp->ctf_nsyms * sizeof (uint32_t));
+      fp->ctf_sxlate = malloc (fp->ctf_nsyms * sizeof (uint32_t));
 
       if (fp->ctf_sxlate == NULL)
 	{
@@ -1613,8 +1625,8 @@  ctf_file_close (ctf_file_t *fp)
       return;
     }
 
-  ctf_free (fp->ctf_dyncuname);
-  ctf_free (fp->ctf_dynparname);
+  free (fp->ctf_dyncuname);
+  free (fp->ctf_dynparname);
   ctf_file_close (fp->ctf_parent);
 
   for (dtd = ctf_list_next (&fp->ctf_dtdefs); dtd != NULL; dtd = ntd)
@@ -1645,20 +1657,20 @@  ctf_file_close (ctf_file_t *fp)
     }
   ctf_dynhash_destroy (fp->ctf_dvhash);
   ctf_str_free_atoms (fp);
-  ctf_free (fp->ctf_tmp_typeslice);
+  free (fp->ctf_tmp_typeslice);
 
   if (fp->ctf_data.cts_name != _CTF_NULLSTR)
-    ctf_free ((char *) fp->ctf_data.cts_name);
+    free ((char *) fp->ctf_data.cts_name);
 
   if (fp->ctf_symtab.cts_name != _CTF_NULLSTR)
-    ctf_free ((char *) fp->ctf_symtab.cts_name);
+    free ((char *) fp->ctf_symtab.cts_name);
 
   if (fp->ctf_strtab.cts_name != _CTF_NULLSTR)
-    ctf_free ((char *) fp->ctf_strtab.cts_name);
+    free ((char *) fp->ctf_strtab.cts_name);
   else if (fp->ctf_data_mmapped)
     ctf_munmap (fp->ctf_data_mmapped, fp->ctf_data_mmapped_len);
 
-  ctf_free (fp->ctf_dynbase);
+  free (fp->ctf_dynbase);
 
   ctf_dynhash_destroy (fp->ctf_syn_ext_strtab);
   ctf_dynhash_destroy (fp->ctf_link_inputs);
@@ -1667,12 +1679,12 @@  ctf_file_close (ctf_file_t *fp)
   ctf_dynhash_destroy (fp->ctf_link_cu_mapping);
   ctf_dynhash_destroy (fp->ctf_add_processing);
 
-  ctf_free (fp->ctf_sxlate);
-  ctf_free (fp->ctf_txlate);
-  ctf_free (fp->ctf_ptrtab);
+  free (fp->ctf_sxlate);
+  free (fp->ctf_txlate);
+  free (fp->ctf_ptrtab);
 
-  ctf_free (fp->ctf_header);
-  ctf_free (fp);
+  free (fp->ctf_header);
+  free (fp);
 }
 
 /* The converse of ctf_open().  ctf_open() disguises whatever it opens as an
@@ -1719,14 +1731,16 @@  ctf_parent_name (ctf_file_t *fp)
 
 /* Set the parent name.  It is an error to call this routine without calling
    ctf_import() at some point.  */
-void
+int
 ctf_parent_name_set (ctf_file_t *fp, const char *name)
 {
   if (fp->ctf_dynparname != NULL)
-    ctf_free (fp->ctf_dynparname);
+    free (fp->ctf_dynparname);
 
-  fp->ctf_dynparname = ctf_strdup (name);
+  if ((fp->ctf_dynparname = strdup (name)) == NULL)
+    return (ctf_set_errno (fp, ENOMEM));
   fp->ctf_parname = fp->ctf_dynparname;
+  return 0;
 }
 
 /* Return the name of the compilation unit this CTF file applies to.  Usually
@@ -1738,14 +1752,16 @@  ctf_cuname (ctf_file_t *fp)
 }
 
 /* Set the compilation unit name.  */
-void
+int
 ctf_cuname_set (ctf_file_t *fp, const char *name)
 {
   if (fp->ctf_dyncuname != NULL)
-    ctf_free (fp->ctf_dyncuname);
+    free (fp->ctf_dyncuname);
 
-  fp->ctf_dyncuname = ctf_strdup (name);
+  if ((fp->ctf_dyncuname = strdup (name)) == NULL)
+    return (ctf_set_errno (fp, ENOMEM));
   fp->ctf_cuname = fp->ctf_dyncuname;
+  return 0;
 }
 
 /* Import the types from the specified parent container by storing a pointer
@@ -1761,15 +1777,21 @@  ctf_import (ctf_file_t *fp, ctf_file_t *pfp)
     return (ctf_set_errno (fp, ECTF_DMODEL));
 
   if (fp->ctf_parent != NULL)
-    ctf_file_close (fp->ctf_parent);
+    {
+      ctf_file_close (fp->ctf_parent);
+      fp->ctf_parent = NULL;
+    }
 
   if (pfp != NULL)
     {
-      fp->ctf_flags |= LCTF_CHILD;
-      pfp->ctf_refcnt++;
+      int err;
 
       if (fp->ctf_parname == NULL)
-	ctf_parent_name_set (fp, "PARENT");
+	if ((err = ctf_parent_name_set (fp, "PARENT")) < 0)
+	  return err;
+
+      fp->ctf_flags |= LCTF_CHILD;
+      pfp->ctf_refcnt++;
     }
   fp->ctf_parent = pfp;
   return 0;
diff --git a/libctf/ctf-string.c b/libctf/ctf-string.c
index 20f4ab9f497..e66c473cd61 100644
--- a/libctf/ctf-string.c
+++ b/libctf/ctf-string.c
@@ -82,7 +82,7 @@  ctf_str_purge_atom_refs (ctf_str_atom_t *atom)
     {
       next = ctf_list_next (ref);
       ctf_list_delete (&atom->csa_refs, ref);
-      ctf_free (ref);
+      free (ref);
     }
 }
 
@@ -93,7 +93,7 @@  ctf_str_free_atom (void *a)
   ctf_str_atom_t *atom = a;
 
   ctf_str_purge_atom_refs (atom);
-  ctf_free (atom);
+  free (atom);
 }
 
 /* Create the atoms table.  There is always at least one atom in it, the null
@@ -102,7 +102,7 @@  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);
+					  free, ctf_str_free_atom);
   if (fp->ctf_str_atoms == NULL)
     return -ENOMEM;
 
@@ -154,7 +154,7 @@  ctf_str_add_ref_internal (ctf_file_t *fp, const char *str,
 
   if (add_ref)
     {
-      if ((aref = ctf_alloc (sizeof (struct ctf_str_atom_ref))) == NULL)
+      if ((aref = malloc (sizeof (struct ctf_str_atom_ref))) == NULL)
 	return NULL;
       aref->caf_ref = ref;
     }
@@ -169,11 +169,11 @@  ctf_str_add_ref_internal (ctf_file_t *fp, const char *str,
       return atom;
     }
 
-  if ((atom = ctf_alloc (sizeof (struct ctf_str_atom))) == NULL)
+  if ((atom = malloc (sizeof (struct ctf_str_atom))) == NULL)
     goto oom;
   memset (atom, 0, sizeof (struct ctf_str_atom));
 
-  if ((newstr = ctf_strdup (str)) == NULL)
+  if ((newstr = strdup (str)) == NULL)
     goto oom;
 
   if (ctf_dynhash_insert (fp->ctf_str_atoms, newstr, atom) < 0)
@@ -203,9 +203,9 @@  ctf_str_add_ref_internal (ctf_file_t *fp, const char *str,
  oom:
   if (newstr)
     ctf_dynhash_remove (fp->ctf_str_atoms, newstr);
-  ctf_free (atom);
-  ctf_free (aref);
-  ctf_free (newstr);
+  free (atom);
+  free (aref);
+  free (newstr);
   return NULL;
 }
 
@@ -279,7 +279,7 @@  ctf_str_remove_ref (ctf_file_t *fp, const char *str, uint32_t *ref)
       if (aref->caf_ref == ref)
 	{
 	  ctf_list_delete (&atom->csa_refs, aref);
-	  ctf_free (aref);
+	  free (aref);
 	}
     }
 }
@@ -452,7 +452,7 @@  ctf_str_write_strtab (ctf_file_t *fp)
   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)
+  if ((strtab.cts_strs = malloc (strtab.cts_len)) == NULL)
     goto oom_sorttab;
 
   if (!fp->ctf_syn_ext_strtab)
diff --git a/libctf/ctf-subr.c b/libctf/ctf-subr.c
index 454716abbd5..6bd7f10aeea 100644
--- a/libctf/ctf-subr.c
+++ b/libctf/ctf-subr.c
@@ -65,18 +65,6 @@  ctf_munmap (void *buf, size_t length _libctf_unused_)
 #endif
 }
 
-_libctf_malloc_ void *
-ctf_alloc (size_t size)
-{
-  return (malloc (size));
-}
-
-void
-ctf_free (void *buf)
-{
-  free (buf);
-}
-
 ssize_t
 ctf_pread (int fd, void *buf, ssize_t count, off_t offset)
 {
diff --git a/libctf/ctf-util.c b/libctf/ctf-util.c
index f27c7685200..d10b2b53a9c 100644
--- a/libctf/ctf-util.c
+++ b/libctf/ctf-util.c
@@ -103,19 +103,6 @@  ctf_sym_to_elf64 (const Elf32_Sym *src, Elf64_Sym *dst)
   return dst;
 }
 
-/* Same as strdup(3C), but use ctf_alloc() to do the memory allocation. */
-
-_libctf_malloc_ char *
-ctf_strdup (const char *s1)
-{
-  char *s2 = ctf_alloc (strlen (s1) + 1);
-
-  if (s2 != NULL)
-    (void) strcpy (s2, s1);
-
-  return s2;
-}
-
 /* A string appender working on dynamic strings.  */
 
 char *