xref: /illumos-gate/usr/src/common/ctf/ctf_util.c (revision 88a08813)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 /*
27  * Copyright (c) 2015, Joyent, Inc.
28  */
29 
30 #include <ctf_impl.h>
31 #include <sys/debug.h>
32 
33 /*
34  * Simple doubly-linked list append routine.  This implementation assumes that
35  * each list element contains an embedded ctf_list_t as the first member.
36  * An additional ctf_list_t is used to store the head (l_next) and tail
37  * (l_prev) pointers.  The current head and tail list elements have their
38  * previous and next pointers set to NULL, respectively.
39  */
40 void
ctf_list_append(ctf_list_t * lp,void * new)41 ctf_list_append(ctf_list_t *lp, void *new)
42 {
43 	ctf_list_t *p = lp->l_prev;	/* p = tail list element */
44 	ctf_list_t *q = new;		/* q = new list element */
45 
46 	lp->l_prev = q;
47 	q->l_prev = p;
48 	q->l_next = NULL;
49 
50 	if (p != NULL)
51 		p->l_next = q;
52 	else
53 		lp->l_next = q;
54 }
55 
56 /*
57  * Prepend the specified existing element to the given ctf_list_t.  The
58  * existing pointer should be pointing at a struct with embedded ctf_list_t.
59  */
60 void
ctf_list_prepend(ctf_list_t * lp,void * new)61 ctf_list_prepend(ctf_list_t *lp, void *new)
62 {
63 	ctf_list_t *p = new;		/* p = new list element */
64 	ctf_list_t *q = lp->l_next;	/* q = head list element */
65 
66 	lp->l_next = p;
67 	p->l_prev = NULL;
68 	p->l_next = q;
69 
70 	if (q != NULL)
71 		q->l_prev = p;
72 	else
73 		lp->l_prev = p;
74 }
75 
76 void
ctf_list_insert_before(ctf_list_t * head,void * item,void * nitem)77 ctf_list_insert_before(ctf_list_t *head, void *item, void *nitem)
78 {
79 	ctf_list_t *lp = item;
80 	ctf_list_t *new = nitem;
81 	ctf_list_t *prev = lp->l_prev;
82 
83 	lp->l_prev = new;
84 	new->l_next = lp;
85 	new->l_prev = prev;
86 	if (prev != NULL) {
87 		prev->l_next = new;
88 	} else {
89 		ASSERT(head->l_next == lp);
90 		head->l_next = new;
91 	}
92 }
93 
94 /*
95  * Delete the specified existing element from the given ctf_list_t.  The
96  * existing pointer should be pointing at a struct with embedded ctf_list_t.
97  */
98 void
ctf_list_delete(ctf_list_t * lp,void * existing)99 ctf_list_delete(ctf_list_t *lp, void *existing)
100 {
101 	ctf_list_t *p = existing;
102 
103 	if (p->l_prev != NULL)
104 		p->l_prev->l_next = p->l_next;
105 	else
106 		lp->l_next = p->l_next;
107 
108 	if (p->l_next != NULL)
109 		p->l_next->l_prev = p->l_prev;
110 	else
111 		lp->l_prev = p->l_prev;
112 }
113 
114 /*
115  * Convert an encoded CTF string name into a pointer to a C string by looking
116  * up the appropriate string table buffer and then adding the offset.
117  */
118 const char *
ctf_strraw(ctf_file_t * fp,uint_t name)119 ctf_strraw(ctf_file_t *fp, uint_t name)
120 {
121 	ctf_strs_t *ctsp = &fp->ctf_str[CTF_NAME_STID(name)];
122 
123 	if (ctsp->cts_strs != NULL && CTF_NAME_OFFSET(name) < ctsp->cts_len)
124 		return (ctsp->cts_strs + CTF_NAME_OFFSET(name));
125 
126 	/* string table not loaded or corrupt offset */
127 	return (NULL);
128 }
129 
130 const char *
ctf_strptr(ctf_file_t * fp,uint_t name)131 ctf_strptr(ctf_file_t *fp, uint_t name)
132 {
133 	const char *s = ctf_strraw(fp, name);
134 	return (s != NULL ? s : "(?)");
135 }
136 
137 /*
138  * Same strdup(3C), but use ctf_alloc() to do the memory allocation.
139  */
140 char *
ctf_strdup(const char * s1)141 ctf_strdup(const char *s1)
142 {
143 	char *s2 = ctf_alloc(strlen(s1) + 1);
144 
145 	if (s2 != NULL)
146 		(void) strcpy(s2, s1);
147 
148 	return (s2);
149 }
150 
151 /*
152  * Free a string which was allocated via ctf_alloc()
153  */
154 void
ctf_strfree(char * s)155 ctf_strfree(char *s)
156 {
157 	if (s == NULL)
158 		return;
159 	ctf_free(s, strlen(s) + 1);
160 }
161 
162 /*
163  * Store the specified error code into errp if it is non-NULL, and then
164  * return NULL for the benefit of the caller.
165  */
166 ctf_file_t *
ctf_set_open_errno(int * errp,int error)167 ctf_set_open_errno(int *errp, int error)
168 {
169 	if (errp != NULL)
170 		*errp = error;
171 	return (NULL);
172 }
173 
174 /*
175  * Store the specified error code into the CTF container, and then return
176  * CTF_ERR for the benefit of the caller.
177  */
178 long
ctf_set_errno(ctf_file_t * fp,int err)179 ctf_set_errno(ctf_file_t *fp, int err)
180 {
181 	fp->ctf_errno = err;
182 	return (CTF_ERR);
183 }
184 
185 boolean_t
ctf_sym_valid(uintptr_t strbase,int type,uint16_t shndx,uint64_t val,uint32_t noff)186 ctf_sym_valid(uintptr_t strbase, int type, uint16_t shndx, uint64_t val,
187     uint32_t noff)
188 {
189 	const char *name;
190 
191 	if (type != STT_OBJECT && type != STT_FUNC)
192 		return (B_FALSE);
193 	if (shndx == SHN_UNDEF || noff == 0)
194 		return (B_FALSE);
195 	if (type == STT_OBJECT && shndx == SHN_ABS && val == 0)
196 		return (B_FALSE);
197 	name = (char *)(strbase + noff);
198 	if (strcmp(name, "_START_") == 0 || strcmp(name, "_END_") == 0)
199 		return (B_FALSE);
200 
201 	return (B_TRUE);
202 }
203