4474 DTrace Userland CTF Support
4475 DTrace userland Keyword
4476 DTrace tests should be better citizens
4479 pid provider types
4480 dof emulation missing checks
Reviewed by: Bryan Cantrill <bryan@joyent.com>

*** 23,33 ****
  /*
   * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
   * Use is subject to license terms.
   */
  /*
!  * Copyright (c) 2012, Joyent, Inc.  All rights reserved.
   */
  
  #include <ctf_impl.h>
  #include <sys/mman.h>
  #include <sys/zmod.h>
--- 23,33 ----
  /*
   * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
   * Use is subject to license terms.
   */
  /*
!  * Copyright (c) 2013, Joyent, Inc.  All rights reserved.
   */
  
  #include <ctf_impl.h>
  #include <sys/mman.h>
  #include <sys/zmod.h>
*** 786,795 ****
--- 786,881 ----
          ctf_close(fp);
          return (NULL);
  }
  
  /*
+  * Dupliate a ctf_file_t and its underlying section information into a new
+  * container. This works by copying the three ctf_sect_t's of the original
+  * container if they exist and passing those into ctf_bufopen. To copy those, we
+  * mmap anonymous memory with ctf_data_alloc and bcopy the data across. It's not
+  * the cheapest thing, but it's what we've got.
+  */
+ ctf_file_t *
+ ctf_dup(ctf_file_t *ofp)
+ {
+         ctf_file_t *fp;
+         ctf_sect_t ctfsect, symsect, strsect;
+         ctf_sect_t *ctp, *symp, *strp;
+         void *cbuf, *symbuf, *strbuf;
+         int err;
+ 
+         cbuf = symbuf = strbuf = NULL;
+         /*
+          * The ctfsect isn't allowed to not exist, but the symbol and string
+          * section might not. We only need to copy the data of the section, not
+          * the name, as ctf_bufopen will take care of that.
+          */
+         bcopy(&ofp->ctf_data, &ctfsect, sizeof (ctf_sect_t));
+         cbuf = ctf_data_alloc(ctfsect.cts_size);
+         if (cbuf == NULL) {
+                 (void) ctf_set_errno(ofp, ECTF_MMAP);
+                 return (NULL);
+         }
+ 
+         bcopy(ctfsect.cts_data, cbuf, ctfsect.cts_size);
+         ctf_data_protect(cbuf, ctfsect.cts_size);
+         ctfsect.cts_data = cbuf;
+         ctfsect.cts_offset = 0;
+         ctp = &ctfsect;
+ 
+         if (ofp->ctf_symtab.cts_data != NULL) {
+                 bcopy(&ofp->ctf_symtab, &symsect, sizeof (ctf_sect_t));
+                 symbuf = ctf_data_alloc(symsect.cts_size);
+                 if (symbuf == NULL) {
+                         (void) ctf_set_errno(ofp, ECTF_MMAP);
+                         goto err;
+                 }
+                 bcopy(symsect.cts_data, symbuf, symsect.cts_size);
+                 ctf_data_protect(symbuf, symsect.cts_size);
+                 symsect.cts_data = symbuf;
+                 symsect.cts_offset = 0;
+                 symp = &symsect;
+         } else {
+                 symp = NULL;
+         }
+ 
+         if (ofp->ctf_strtab.cts_data != NULL) {
+                 bcopy(&ofp->ctf_strtab, &strsect, sizeof (ctf_sect_t));
+                 strbuf = ctf_data_alloc(strsect.cts_size);
+                 if (strbuf == NULL) {
+                         (void) ctf_set_errno(ofp, ECTF_MMAP);
+                         goto err;
+                 }
+                 bcopy(strsect.cts_data, strbuf, strsect.cts_size);
+                 ctf_data_protect(strbuf, strsect.cts_size);
+                 strsect.cts_data = strbuf;
+                 strsect.cts_offset = 0;
+                 strp = &strsect;
+         } else {
+                 strp = NULL;
+         }
+ 
+         fp = ctf_bufopen(ctp, symp, strp, &err);
+         if (fp == NULL) {
+                 (void) ctf_set_errno(ofp, err);
+                 goto err;
+         }
+ 
+         fp->ctf_flags |= LCTF_MMAP;
+ 
+         return (fp);
+ 
+ err:
+         ctf_data_free(cbuf, ctfsect.cts_size);
+         if (symbuf != NULL)
+                 ctf_data_free(symbuf, symsect.cts_size);
+         if (strbuf != NULL)
+                 ctf_data_free(strbuf, strsect.cts_size);
+         return (NULL);
+ }
+ 
+ /*
   * Close the specified CTF container and free associated data structures.  Note
   * that ctf_close() is a reference counted operation: if the specified file is
   * the parent of other active containers, its reference count will be greater
   * than one and it will be freed later when no active children exist.
   */