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 #pragma ident "%Z%%M% %I% %E% SMI"
28
29 #include <ctf_impl.h>
30
31 /*
32 * Simple doubly-linked list append routine. This implementation assumes that
33 * each list element contains an embedded ctf_list_t as the first member.
34 * An additional ctf_list_t is used to store the head (l_next) and tail
35 * (l_prev) pointers. The current head and tail list elements have their
36 * previous and next pointers set to NULL, respectively.
37 */
38 void
ctf_list_append(ctf_list_t * lp,void * new)39 ctf_list_append(ctf_list_t *lp, void *new)
40 {
41 ctf_list_t *p = lp->l_prev; /* p = tail list element */
42 ctf_list_t *q = new; /* q = new list element */
43
44 lp->l_prev = q;
45 q->l_prev = p;
46 q->l_next = NULL;
47
48 if (p != NULL)
49 p->l_next = q;
50 else
51 lp->l_next = q;
52 }
53
54 /*
55 * Prepend the specified existing element to the given ctf_list_t. The
56 * existing pointer should be pointing at a struct with embedded ctf_list_t.
57 */
58 void
ctf_list_prepend(ctf_list_t * lp,void * new)59 ctf_list_prepend(ctf_list_t *lp, void *new)
60 {
61 ctf_list_t *p = new; /* p = new list element */
62 ctf_list_t *q = lp->l_next; /* q = head list element */
63
64 lp->l_next = p;
65 p->l_prev = NULL;
66 p->l_next = q;
67
68 if (q != NULL)
69 q->l_prev = p;
70 else
71 lp->l_prev = p;
72 }
73
74 /*
75 * Delete the specified existing element from the given ctf_list_t. The
76 * existing pointer should be pointing at a struct with embedded ctf_list_t.
77 */
78 void
ctf_list_delete(ctf_list_t * lp,void * existing)79 ctf_list_delete(ctf_list_t *lp, void *existing)
80 {
81 ctf_list_t *p = existing;
82
83 if (p->l_prev != NULL)
84 p->l_prev->l_next = p->l_next;
85 else
86 lp->l_next = p->l_next;
87
88 if (p->l_next != NULL)
89 p->l_next->l_prev = p->l_prev;
90 else
91 lp->l_prev = p->l_prev;
92 }
93
94 /*
95 * Convert an encoded CTF string name into a pointer to a C string by looking
96 * up the appropriate string table buffer and then adding the offset.
97 */
98 const char *
ctf_strraw(const ctf_file_t * fp,uint_t name)99 ctf_strraw(const ctf_file_t *fp, uint_t name)
100 {
101 const ctf_strs_t *ctsp = &fp->ctf_str[CTF_NAME_STID(name)];
102
103 if (ctsp->cts_strs != NULL && CTF_NAME_OFFSET(name) < ctsp->cts_len)
104 return (ctsp->cts_strs + CTF_NAME_OFFSET(name));
105
106 /* string table not loaded or corrupt offset */
107 return (NULL);
108 }
109
110 const char *
ctf_strptr(const ctf_file_t * fp,uint_t name)111 ctf_strptr(const ctf_file_t *fp, uint_t name)
112 {
113 const char *s = ctf_strraw(fp, name);
114 return (s != NULL ? s : "(?)");
115 }
116
117 /*
118 * Same strdup(3C), but use ctf_alloc() to do the memory allocation.
119 */
120 char *
ctf_strdup(const char * s1)121 ctf_strdup(const char *s1)
122 {
123 char *s2 = ctf_alloc(strlen(s1) + 1);
124
125 if (s2 != NULL)
126 (void) strcpy(s2, s1);
127
128 return (s2);
129 }
130
131 /*
132 * Store the specified error code into errp if it is non-NULL, and then
133 * return NULL for the benefit of the caller.
134 */
135 ctf_file_t *
ctf_set_open_errno(int * errp,int error)136 ctf_set_open_errno(int *errp, int error)
137 {
138 if (errp != NULL)
139 *errp = error;
140 return (NULL);
141 }
142
143 /*
144 * Store the specified error code into the CTF container, and then return
145 * CTF_ERR for the benefit of the caller.
146 */
147 long
ctf_set_errno(ctf_file_t * fp,int err)148 ctf_set_errno(ctf_file_t *fp, int err)
149 {
150 fp->ctf_errno = err;
151 return (CTF_ERR);
152 }
153