Print this page
XXXX adding PID information to netstat output
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/common/list/list.c
+++ new/usr/src/common/list/list.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21 /*
22 22 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
23 23 */
24 24
25 25 /*
26 26 * Generic doubly-linked list implementation
27 27 */
28 28
29 29 #include <sys/list.h>
30 30 #include <sys/list_impl.h>
31 31 #include <sys/types.h>
32 32 #include <sys/sysmacros.h>
33 33 #ifdef _KERNEL
34 34 #include <sys/debug.h>
35 35 #else
36 36 #include <assert.h>
37 37 #define ASSERT(a) assert(a)
38 38 #endif
39 39
40 40 #ifdef lint
41 41 extern list_node_t *list_d2l(list_t *list, void *obj);
42 42 #else
43 43 #define list_d2l(a, obj) ((list_node_t *)(((char *)obj) + (a)->list_offset))
44 44 #endif
45 45 #define list_object(a, node) ((void *)(((char *)node) - (a)->list_offset))
46 46 #define list_empty(a) ((a)->list_head.list_next == &(a)->list_head)
47 47
48 48 #define list_insert_after_node(list, node, object) { \
49 49 list_node_t *lnew = list_d2l(list, object); \
50 50 lnew->list_prev = (node); \
51 51 lnew->list_next = (node)->list_next; \
52 52 (node)->list_next->list_prev = lnew; \
53 53 (node)->list_next = lnew; \
54 54 }
55 55
56 56 #define list_insert_before_node(list, node, object) { \
57 57 list_node_t *lnew = list_d2l(list, object); \
58 58 lnew->list_next = (node); \
59 59 lnew->list_prev = (node)->list_prev; \
60 60 (node)->list_prev->list_next = lnew; \
61 61 (node)->list_prev = lnew; \
62 62 }
63 63
64 64 #define list_remove_node(node) \
65 65 (node)->list_prev->list_next = (node)->list_next; \
66 66 (node)->list_next->list_prev = (node)->list_prev; \
67 67 (node)->list_next = (node)->list_prev = NULL
68 68
69 69 void
70 70 list_create(list_t *list, size_t size, size_t offset)
71 71 {
72 72 ASSERT(list);
73 73 ASSERT(size > 0);
74 74 ASSERT(size >= offset + sizeof (list_node_t));
75 75
76 76 list->list_size = size;
77 77 list->list_offset = offset;
78 78 list->list_head.list_next = list->list_head.list_prev =
79 79 &list->list_head;
80 80 }
81 81
82 82 void
83 83 list_destroy(list_t *list)
84 84 {
85 85 list_node_t *node = &list->list_head;
86 86
87 87 ASSERT(list);
88 88 ASSERT(list->list_head.list_next == node);
89 89 ASSERT(list->list_head.list_prev == node);
90 90
91 91 node->list_next = node->list_prev = NULL;
92 92 }
93 93
94 94 void
95 95 list_insert_after(list_t *list, void *object, void *nobject)
96 96 {
97 97 if (object == NULL) {
98 98 list_insert_head(list, nobject);
99 99 } else {
100 100 list_node_t *lold = list_d2l(list, object);
101 101 list_insert_after_node(list, lold, nobject);
102 102 }
103 103 }
104 104
105 105 void
106 106 list_insert_before(list_t *list, void *object, void *nobject)
107 107 {
108 108 if (object == NULL) {
109 109 list_insert_tail(list, nobject);
110 110 } else {
111 111 list_node_t *lold = list_d2l(list, object);
112 112 list_insert_before_node(list, lold, nobject);
113 113 }
114 114 }
115 115
116 116 void
117 117 list_insert_head(list_t *list, void *object)
118 118 {
119 119 list_node_t *lold = &list->list_head;
120 120 list_insert_after_node(list, lold, object);
121 121 }
122 122
123 123 void
124 124 list_insert_tail(list_t *list, void *object)
125 125 {
126 126 list_node_t *lold = &list->list_head;
127 127 list_insert_before_node(list, lold, object);
128 128 }
129 129
130 130 void
131 131 list_remove(list_t *list, void *object)
132 132 {
133 133 list_node_t *lold = list_d2l(list, object);
134 134 ASSERT(!list_empty(list));
135 135 ASSERT(lold->list_next != NULL);
136 136 list_remove_node(lold);
137 137 }
138 138
139 139 void *
140 140 list_remove_head(list_t *list)
141 141 {
142 142 list_node_t *head = list->list_head.list_next;
143 143 if (head == &list->list_head)
144 144 return (NULL);
145 145 list_remove_node(head);
146 146 return (list_object(list, head));
147 147 }
148 148
149 149 void *
150 150 list_remove_tail(list_t *list)
151 151 {
152 152 list_node_t *tail = list->list_head.list_prev;
153 153 if (tail == &list->list_head)
154 154 return (NULL);
155 155 list_remove_node(tail);
156 156 return (list_object(list, tail));
157 157 }
158 158
159 159 void *
160 160 list_head(list_t *list)
161 161 {
162 162 if (list_empty(list))
163 163 return (NULL);
164 164 return (list_object(list, list->list_head.list_next));
165 165 }
166 166
167 167 void *
168 168 list_tail(list_t *list)
169 169 {
170 170 if (list_empty(list))
171 171 return (NULL);
172 172 return (list_object(list, list->list_head.list_prev));
173 173 }
174 174
175 175 void *
176 176 list_next(list_t *list, void *object)
177 177 {
178 178 list_node_t *node = list_d2l(list, object);
179 179
180 180 if (node->list_next != &list->list_head)
181 181 return (list_object(list, node->list_next));
182 182
183 183 return (NULL);
184 184 }
185 185
186 186 void *
187 187 list_prev(list_t *list, void *object)
188 188 {
189 189 list_node_t *node = list_d2l(list, object);
190 190
191 191 if (node->list_prev != &list->list_head)
192 192 return (list_object(list, node->list_prev));
193 193
194 194 return (NULL);
195 195 }
196 196
197 197 /*
198 198 * Insert src list after dst list. Empty src list thereafter.
199 199 */
200 200 void
201 201 list_move_tail(list_t *dst, list_t *src)
202 202 {
203 203 list_node_t *dstnode = &dst->list_head;
204 204 list_node_t *srcnode = &src->list_head;
205 205
206 206 ASSERT(dst->list_size == src->list_size);
207 207 ASSERT(dst->list_offset == src->list_offset);
208 208
209 209 if (list_empty(src))
210 210 return;
211 211
212 212 dstnode->list_prev->list_next = srcnode->list_next;
213 213 srcnode->list_next->list_prev = dstnode->list_prev;
214 214 dstnode->list_prev = srcnode->list_prev;
215 215 srcnode->list_prev->list_next = dstnode;
216 216
217 217 /* empty src list */
218 218 srcnode->list_next = srcnode->list_prev = srcnode;
219 219 }
220 220
221 221 void
222 222 list_link_replace(list_node_t *lold, list_node_t *lnew)
223 223 {
224 224 ASSERT(list_link_active(lold));
225 225 ASSERT(!list_link_active(lnew));
226 226
227 227 lnew->list_next = lold->list_next;
228 228 lnew->list_prev = lold->list_prev;
229 229 lold->list_prev->list_next = lnew;
230 230 lold->list_next->list_prev = lnew;
231 231 lold->list_next = lold->list_prev = NULL;
232 232 }
233 233
234 234 void
235 235 list_link_init(list_node_t *link)
236 236 {
237 237 link->list_next = NULL;
238 238 link->list_prev = NULL;
239 239 }
240 240
241 241 int
|
↓ open down ↓ |
241 lines elided |
↑ open up ↑ |
242 242 list_link_active(list_node_t *link)
243 243 {
244 244 return (link->list_next != NULL);
245 245 }
246 246
247 247 int
248 248 list_is_empty(list_t *list)
249 249 {
250 250 return (list_empty(list));
251 251 }
252 +
253 +uint64_t
254 +list_size(list_t *list)
255 +{
256 + size_t sz = 0;
257 + list_node_t *node;
258 +
259 + node = &list->list_head;
260 + while (node->list_next != &list->list_head) {
261 + sz++;
262 + node = node->list_next;
263 + }
264 + return (sz);
265 +}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX