e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * CDDL HEADER START
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * The contents of this file are subject to the terms of the
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * Common Development and Distribution License, Version 1.0 only
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * (the "License"). You may not use this file except in compliance
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * with the License.
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * See the License for the specific language governing permissions
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * and limitations under the License.
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * When distributing Covered Code, include this CDDL HEADER in each
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * If applicable, add the following below this CDDL HEADER, with the
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * fields enclosed by brackets "[]" replaced with your own identifying
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * information: Portions Copyright [yyyy] [name of copyright owner]
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * CDDL HEADER END
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * Use is subject to license terms.
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync#pragma ident "%Z%%M% %I% %E% SMI"
d11c725a6a076f607c240f98ff03ca3166b581c9vboxsync#else /* VBOX */
d11c725a6a076f607c240f98ff03ca3166b581c9vboxsync#endif /* VBOX */
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * This static string is used as the template for initially populating a
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * dynamic container's string table. We always store \0 in the first byte,
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * and we use the generic string "PARENT" to mark this container's parent
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * if one is associated with the container using ctf_import().
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsyncstatic const char _CTF_STRTAB_TEMPLATE[] = "\0PARENT";
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * To create an empty CTF container, we just declare a zeroed header and call
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * ctf_bufopen() on it. If ctf_bufopen succeeds, we mark the new container r/w
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * and initialize the dynamic members. We set dtstrlen to 1 to reserve the
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * first byte of the string table for a \0 byte, and we start assigning type
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * IDs at 1 because type ID 0 is used as a sentinel.
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync static const ctf_header_t hdr = { { CTF_MAGIC, CTF_VERSION, 0 } };
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync ctf_dtdef_t **hash = ctf_alloc(hashlen * sizeof (ctf_dtdef_t *));
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if ((fp = ctf_bufopen(&cts, NULL, NULL, errp)) == NULL) {
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsyncctf_copy_smembers(ctf_dtdef_t *dtd, uint_t soff, uchar_t *t)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync ctf_dmdef_t *dmd = ctf_list_next(&dtd->dtd_u.dtu_members);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync t += sizeof (ctm);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync return (t);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsyncctf_copy_lmembers(ctf_dtdef_t *dtd, uint_t soff, uchar_t *t)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync ctf_dmdef_t *dmd = ctf_list_next(&dtd->dtd_u.dtu_members);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync ctlm.ctlm_offsethi = CTF_OFFSET_TO_LMEMHI(dmd->dmd_offset);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync ctlm.ctlm_offsetlo = CTF_OFFSET_TO_LMEMLO(dmd->dmd_offset);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync t += sizeof (ctlm);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync return (t);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsyncctf_copy_emembers(ctf_dtdef_t *dtd, uint_t soff, uchar_t *t)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync ctf_dmdef_t *dmd = ctf_list_next(&dtd->dtd_u.dtu_members);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync t += sizeof (cte);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync return (t);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync ctf_dmdef_t *dmd = ctf_list_next(&dtd->dtd_u.dtu_members);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync continue; /* skip anonymous members */
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync return (s);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * If the specified CTF container is writable and has been modified, reload
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * this container with the updated type definitions. In order to make this
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * code and the rest of libctf as simple as possible, we perform updates by
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * taking the dynamic type definitions and creating an in-memory CTF file
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * containing the definitions, and then call ctf_bufopen() on it. This not
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * only leverages ctf_bufopen(), but also avoids having to bifurcate the rest
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * of the library code with different lookup paths for static and dynamic
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * type definitions. We are therefore optimizing greatly for lookup over
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * update, which we assume will be an uncommon operation. We perform one
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * extra trick here for the benefit of callers and to keep our code simple:
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * ctf_bufopen() will return a new ctf_file_t, but we want to keep the fp
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * constant for the caller, so after ctf_bufopen() returns, we use bcopy to
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * swap the interior of the old and new ctf_file_t's, and then free the old.
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync return (0); /* no update required */
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * Fill in an initial CTF header. We will leave the label, object,
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * and function sections empty and only output a header, type section,
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * and string table. The type section begins at a 4-byte aligned
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * boundary past the CTF header itself (at relative offset zero).
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync hdr.cth_parname = 1; /* i.e. _CTF_STRTAB_TEMPLATE[1] */
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * Iterate through the dynamic type definition list and compute the
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * size of the CTF type section we will need to generate.
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync for (size = 0, dtd = ctf_list_next(&fp->ctf_dtdefs);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync uint_t kind = CTF_INFO_KIND(dtd->dtd_data.ctt_info);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync uint_t vlen = CTF_INFO_VLEN(dtd->dtd_data.ctt_info);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * Fill in the string table offset and size, compute the size of the
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * entire CTF buffer we need, and then allocate a new buffer and
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * bcopy the finished header to the start of the buffer.
d11c725a6a076f607c240f98ff03ca3166b581c9vboxsync hdr.cth_stroff = hdr.cth_typeoff + VBDTCAST(uint_t)size;
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync size = sizeof (ctf_header_t) + hdr.cth_stroff + hdr.cth_strlen;
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync s = s0 = (uchar_t *)buf + sizeof (ctf_header_t) + hdr.cth_stroff;
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync bcopy(_CTF_STRTAB_TEMPLATE, s, sizeof (_CTF_STRTAB_TEMPLATE));
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * We now take a final lap through the dynamic type definition list and
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * copy the appropriate type records and strings to the output buffer.
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync uint_t kind = CTF_INFO_KIND(dtd->dtd_data.ctt_info);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync uint_t vlen = CTF_INFO_VLEN(dtd->dtd_data.ctt_info);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync t += sizeof (encoding);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync t += sizeof (cta);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * Finally, we are ready to ctf_bufopen() the new container. If this
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * is successful, we then switch nfp and fp and free the old container.
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if ((nfp = ctf_bufopen(&cts, NULL, NULL, &err)) == NULL) {
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync nfp->ctf_data.cts_data = NULL; /* force ctf_data_free() on close */
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * Initialize the ctf_lookup_by_name top-level dictionary. We keep an
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * array of type name prefixes and the corresponding ctf_hash to use.
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * NOTE: This code must be kept in sync with the code in ctf_bufopen().
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync return (0);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync ulong_t h = dtd->dtd_type & (fp->ctf_dthashlen - 1);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync ulong_t h = dtd->dtd_type & (fp->ctf_dthashlen - 1);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync for (dtd = fp->ctf_dthash[h]; dtd != NULL; dtd = dtd->dtd_hash) {
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * Discard all of the dynamic type definitions that have been added to the
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * container since the last call to ctf_update(). We locate such types by
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * scanning the list and deleting elements that have type IDs greater than
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * ctf_dtoldid, which is set by ctf_update(), above.
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync return (0); /* no update required */
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync for (dtd = ctf_list_next(&fp->ctf_dtdefs); dtd != NULL; dtd = ntd) {
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync continue; /* skip types that have been committed */
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync return (0);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsyncctf_add_generic(ctf_file_t *fp, uint_t flag, const char *name, ctf_dtdef_t **rp)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if (flag != CTF_ADD_NONROOT && flag != CTF_ADD_ROOT)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if (CTF_INDEX_TO_TYPE(fp->ctf_dtnextid, 1) > CTF_MAX_TYPE)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if ((dtd = ctf_alloc(sizeof (ctf_dtdef_t))) == NULL)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if (name != NULL && (s = ctf_strdup(name)) == NULL) {
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync type = CTF_INDEX_TO_TYPE(type, (fp->ctf_flags & LCTF_CHILD));
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * When encoding integer sizes, we want to convert a byte count in the range
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * 1-8 to the closest power of 2 (e.g. 3->4, 5->8, etc). The clp2() function
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * is a clever implementation from "Hacker's Delight" by Henry Warren, Jr.
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync x |= (x >> 1);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync x |= (x >> 2);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync x |= (x >> 4);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync x |= (x >> 8);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync x |= (x >> 16);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync return (x + 1);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync const char *name, const ctf_encoding_t *ep, uint_t kind)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if ((type = ctf_add_generic(fp, flag, name, &dtd)) == CTF_ERR)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync dtd->dtd_data.ctt_info = CTF_TYPE_INFO(kind, flag, 0);
d11c725a6a076f607c240f98ff03ca3166b581c9vboxsync dtd->dtd_data.ctt_size = VBDTCAST(ushort_t)clp2(P2ROUNDUP(ep->cte_bits, NBBY) / NBBY);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsyncctf_add_reftype(ctf_file_t *fp, uint_t flag, ctf_id_t ref, uint_t kind)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if (ref == CTF_ERR || ref < 0 || ref > CTF_MAX_TYPE)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if ((type = ctf_add_generic(fp, flag, NULL, &dtd)) == CTF_ERR)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync dtd->dtd_data.ctt_info = CTF_TYPE_INFO(kind, flag, 0);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync return (ctf_add_encoded(fp, flag, name, ep, CTF_K_INTEGER));
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync return (ctf_add_encoded(fp, flag, name, ep, CTF_K_FLOAT));
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsyncctf_add_pointer(ctf_file_t *fp, uint_t flag, ctf_id_t ref)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync return (ctf_add_reftype(fp, flag, ref, CTF_K_POINTER));
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsyncctf_add_array(ctf_file_t *fp, uint_t flag, const ctf_arinfo_t *arp)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if ((type = ctf_add_generic(fp, flag, NULL, &dtd)) == CTF_ERR)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync dtd->dtd_data.ctt_info = CTF_TYPE_INFO(CTF_K_ARRAY, flag, 0);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsyncctf_set_array(ctf_file_t *fp, ctf_id_t type, const ctf_arinfo_t *arp)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if (dtd == NULL || CTF_INFO_KIND(dtd->dtd_data.ctt_info) != CTF_K_ARRAY)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync return (0);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if (ctc == NULL || (ctc->ctc_flags & ~CTF_FUNC_VARARG) != 0 ||
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync vlen++; /* add trailing zero to indicate varargs (see below) */
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if (vlen != 0 && (vdat = ctf_alloc(sizeof (ctf_id_t) * vlen)) == NULL)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if ((type = ctf_add_generic(fp, flag, NULL, &dtd)) == CTF_ERR) {
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync dtd->dtd_data.ctt_info = CTF_TYPE_INFO(CTF_K_FUNCTION, flag, vlen);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync dtd->dtd_data.ctt_type = (ushort_t)ctc->ctc_return;
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync bcopy(argv, vdat, sizeof (ctf_id_t) * ctc->ctc_argc);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync vdat[vlen - 1] = 0; /* add trailing zero to indicate varargs */
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsyncctf_add_struct(ctf_file_t *fp, uint_t flag, const char *name)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if (hep != NULL && ctf_type_kind(fp, hep->h_type) == CTF_K_FORWARD)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync else if ((type = ctf_add_generic(fp, flag, name, &dtd)) == CTF_ERR)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync dtd->dtd_data.ctt_info = CTF_TYPE_INFO(CTF_K_STRUCT, flag, 0);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsyncctf_add_union(ctf_file_t *fp, uint_t flag, const char *name)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if (hep != NULL && ctf_type_kind(fp, hep->h_type) == CTF_K_FORWARD)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync else if ((type = ctf_add_generic(fp, flag, name, &dtd)) == CTF_ERR)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync dtd->dtd_data.ctt_info = CTF_TYPE_INFO(CTF_K_UNION, flag, 0);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsyncctf_add_enum(ctf_file_t *fp, uint_t flag, const char *name)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if (hep != NULL && ctf_type_kind(fp, hep->h_type) == CTF_K_FORWARD)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync else if ((type = ctf_add_generic(fp, flag, name, &dtd)) == CTF_ERR)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync dtd->dtd_data.ctt_info = CTF_TYPE_INFO(CTF_K_ENUM, flag, 0);
d11c725a6a076f607c240f98ff03ca3166b581c9vboxsync dtd->dtd_data.ctt_size = VBDTCAST(ushort_t)fp->ctf_dmodel->ctd_int;
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsyncctf_add_forward(ctf_file_t *fp, uint_t flag, const char *name, uint_t kind)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * If the type is already defined or exists as a forward tag, just
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * return the ctf_id_t of the existing definition.
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if ((type = ctf_add_generic(fp, flag, name, &dtd)) == CTF_ERR)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync dtd->dtd_data.ctt_info = CTF_TYPE_INFO(CTF_K_FORWARD, flag, 0);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsyncctf_add_typedef(ctf_file_t *fp, uint_t flag, const char *name, ctf_id_t ref)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if (ref == CTF_ERR || ref < 0 || ref > CTF_MAX_TYPE)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if ((type = ctf_add_generic(fp, flag, name, &dtd)) == CTF_ERR)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync dtd->dtd_data.ctt_info = CTF_TYPE_INFO(CTF_K_TYPEDEF, flag, 0);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsyncctf_add_volatile(ctf_file_t *fp, uint_t flag, ctf_id_t ref)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync return (ctf_add_reftype(fp, flag, ref, CTF_K_VOLATILE));
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsyncctf_add_const(ctf_file_t *fp, uint_t flag, ctf_id_t ref)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync return (ctf_add_reftype(fp, flag, ref, CTF_K_CONST));
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsyncctf_add_restrict(ctf_file_t *fp, uint_t flag, ctf_id_t ref)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync return (ctf_add_reftype(fp, flag, ref, CTF_K_RESTRICT));
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsyncctf_add_enumerator(ctf_file_t *fp, ctf_id_t enid, const char *name, int value)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if ((dmd = ctf_alloc(sizeof (ctf_dmdef_t))) == NULL)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync dtd->dtd_data.ctt_info = CTF_TYPE_INFO(kind, root, vlen + 1);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync return (0);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsyncctf_add_member(ctf_file_t *fp, ctf_id_t souid, const char *name, ctf_id_t type)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if ((msize = ctf_type_size(fp, type)) == CTF_ERR ||
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if ((dmd = ctf_alloc(sizeof (ctf_dmdef_t))) == NULL)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if (name != NULL && (s = ctf_strdup(name)) == NULL) {
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync ctf_dmdef_t *lmd = ctf_list_prev(&dtd->dtd_u.dtu_members);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync ctf_id_t ltype = ctf_type_resolve(fp, lmd->dmd_type);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if (ctf_type_encoding(fp, ltype, &linfo) != CTF_ERR)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync else if ((lsize = ctf_type_size(fp, ltype)) != CTF_ERR)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * Round up the offset of the end of the last member to the
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * next byte boundary, convert 'off' to bytes, and then round
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * it up again to the next multiple of the alignment required
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * by the new member. Finally, convert back to bits and store
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * the result in dmd_offset. Technically we could do more
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * efficient packing if the new member is a bit-field, but
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * we're the "compiler" and ANSI says we can do as we choose.
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync ssize = ctf_get_ctt_size(fp, &dtd->dtd_data, NULL, NULL);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync dtd->dtd_data.ctt_lsizehi = CTF_SIZE_TO_LSIZE_HI(ssize);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync dtd->dtd_data.ctt_lsizelo = CTF_SIZE_TO_LSIZE_LO(ssize);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync dtd->dtd_data.ctt_info = CTF_TYPE_INFO(kind, root, vlen + 1);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync return (0);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync return (ctf_enum_value(ctb->ctb_file, ctb->ctb_type,
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync return (ctf_add_enumerator(ctb->ctb_file, ctb->ctb_type,
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync/*ARGSUSED*/
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsyncmembcmp(const char *name, ctf_id_t type, ulong_t offset, void *arg)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync return (ctf_member_info(ctb->ctb_file, ctb->ctb_type,
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync name, &ctm) == CTF_ERR || ctm.ctm_offset != offset);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsyncmembadd(const char *name, ctf_id_t type, ulong_t offset, void *arg)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if ((dmd = ctf_alloc(sizeof (ctf_dmdef_t))) == NULL)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if (name != NULL && (s = ctf_strdup(name)) == NULL) {
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * For now, dmd_type is copied as the src_fp's type; it is reset to an
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * equivalent dst_fp type by a final loop in ctf_add_type(), below.
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync ctf_list_append(&ctb->ctb_dtd->dtd_u.dtu_members, dmd);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync return (0);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * The ctf_add_type routine is used to copy a type from a source CTF container
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * to a dynamic destination container. This routine operates recursively by
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * following the source type's links and embedded member types. If the
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * destination container already contains a named type which has the same
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * attributes, then we succeed and return this type but no changes occur.
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsyncctf_add_type(ctf_file_t *dst_fp, ctf_file_t *src_fp, ctf_id_t src_type)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if ((tp = ctf_lookup_by_id(&src_fp, src_type)) == NULL)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * If the source type has a name and is a root type (visible at the
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * top-level scope), lookup the name in the destination container and
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * verify that it is of the same kind before we do anything else.
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync (hep = ctf_hash_lookup(hp, dst_fp, name, strlen(name))) != NULL) {
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * If an identically named dst_type exists, fail with ECTF_CONFLICT
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * unless dst_type is a forward declaration and src_type is a struct,
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * union, or enum (i.e. the definition of the previous forward decl).
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync dst_kind != CTF_K_FORWARD || (kind != CTF_K_ENUM &&
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * If the non-empty name was not found in the appropriate hash, search
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * the list of pending dynamic definitions that are not yet committed.
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * If a matching name and kind are found, assume this is the type that
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * we are looking for. This is necessary to permit ctf_add_type() to
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * operate recursively on entities such as a struct that contains a
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * pointer member that refers to the same struct type.
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync for (dtd = ctf_list_prev(&dst_fp->ctf_dtdefs); dtd != NULL &&
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if (CTF_INFO_KIND(dtd->dtd_data.ctt_info) == kind &&
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * Now perform kind-specific processing. If dst_type is CTF_ERR, then
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * we add a new type with the same properties as src_type to dst_fp.
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * If dst_type is not CTF_ERR, then we verify that dst_type has the
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * same attributes as src_type. We recurse for embedded references.
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if (ctf_type_encoding(src_fp, src_type, &src_en) != 0)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if (ctf_type_encoding(dst_fp, dst_type, &dst_en) != 0)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if (bcmp(&src_en, &dst_en, sizeof (ctf_encoding_t)))
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync dst_type = ctf_add_integer(dst_fp, flag, name, &src_en);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync dst_type = ctf_add_float(dst_fp, flag, name, &src_en);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync dst_type = ctf_add_reftype(dst_fp, flag, src_type, kind);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if (ctf_array_info(src_fp, src_type, &src_ar) == CTF_ERR)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if (ctf_array_info(dst_fp, dst_type, &dst_ar) != 0)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync ctc.ctc_return = ctf_add_type(dst_fp, src_fp, tp->ctt_type);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync dst_type = ctf_add_function(dst_fp, flag, &ctc, NULL);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * Technically to match a struct or union we need to check both
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * ways (src members vs. dst, dst members vs. src) but we make
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * this more optimal by only checking src vs. dst and comparing
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * the total size of the structure (which we must do anyway)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * which covers the possibility of dst members not in src.
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * This optimization can be defeated for unions, but is so
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * pathological as to render it irrelevant for our purposes.
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if (dst_type != CTF_ERR && dst_kind != CTF_K_FORWARD) {
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if (ctf_member_iter(src_fp, src_type, membcmp, &dst))
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * Unlike the other cases, copying structs and unions is done
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * manually so as to avoid repeated lookups in ctf_add_member
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * and to ensure the exact same member offsets as in src_type.
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync dst_type = ctf_add_generic(dst_fp, flag, name, &dtd);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if (ctf_member_iter(src_fp, src_type, membadd, &dst) != 0)
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync errs++; /* increment errs and fail at bottom of case */
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if ((size = ctf_type_size(src_fp, src_type)) > CTF_MAX_SIZE) {
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync dtd->dtd_data.ctt_lsizehi = CTF_SIZE_TO_LSIZE_HI(size);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync dtd->dtd_data.ctt_lsizelo = CTF_SIZE_TO_LSIZE_LO(size);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync dtd->dtd_data.ctt_info = CTF_TYPE_INFO(kind, flag, vlen);
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * Make a final pass through the members changing each dmd_type
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * (a src_fp type) to an equivalent type in dst_fp. We pass
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * through all members, leaving any that fail set to CTF_ERR.
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if (dst_type != CTF_ERR && dst_kind != CTF_K_FORWARD) {
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync if (ctf_enum_iter(src_fp, src_type, enumcmp, &dst) ||
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * If dst_type is not CTF_ERR at this point, we should check if
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * ctf_type_reference(dst_fp, dst_type) != src_type and if so
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * fail with ECTF_CONFLICT. However, this causes problems with
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * <sys/types.h> typedefs that vary based on things like if
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * _ILP32x then pid_t is int otherwise long. We therefore omit
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * this check and assume that if the identically named typedef
e083a0c2c99cea982dcf8e12ec3452cc575b5663vboxsync * already exists in dst_fp, it is correct or equivalent.