1 /* This file is part of Netwib. Read and honor its license.
2 */
3
4 /*
5 The data in the list contains :
6 - 0 pointer to next item
7 - 1 threadid
8 - 2 netwib_debug_leaktype
9 - 3 infoptr
10 - 4 infoint
11 - 5 backtrace size
12 - 6+backtrace array
13 */
14
15 /*-------------------------------------------------------------*/
16 static netwib_err netwib_debug_leak_disp(netwib_ptr item[]);
17
18 /*-------------------------------------------------------------*/
19 /*-------------------------------------------------------------*/
20 /*-------------------------------------------------------------*/
21 /*-------------------------------------------------------------*/
netwib_debug_leak_init(void)22 netwib_err netwib_debug_leak_init(void)
23 {
24 netwib_er(netwib_debug_glovars_wrlock());
25 netwib_debug_glovars.leak_list = NULL;
26 netwib_er(netwib_debug_glovars_wrunlock());
27 return(NETWIB_ERR_OK);
28 }
29
30 /*-------------------------------------------------------------*/
netwib_debug_leak_close2(void)31 static netwib_err netwib_debug_leak_close2(void)
32 {
33 netwib_ptr *item, *itemtofree;
34 netwib_debug_glovars_t *pglo = &netwib_debug_glovars;
35
36 item = (netwib_ptr*)pglo->leak_list;
37 while (item != NULL) {
38 /* netwib_er(netwib_debug_leak_disp(item)); */
39 itemtofree = item;
40 /* next item */
41 item = (netwib_ptr*)item[0];
42 /* now free it, we do not need it */
43 free(itemtofree);
44 }
45 pglo->leak_list = NULL;
46 return(NETWIB_ERR_OK);
47 }
netwib_debug_leak_close(void)48 netwib_err netwib_debug_leak_close(void)
49 {
50 netwib_err ret;
51 netwib_er(netwib_debug_glovars_wrlock());
52 ret = netwib_debug_leak_close2();
53 netwib_er(netwib_debug_glovars_wrunlock());
54 return(ret);
55 }
56
57 /*-------------------------------------------------------------*/
netwib_debug_leak_add2(netwib_debug_leaktype type,netwib_constptr infoptr,netwib_uint32 infoint)58 static netwib_err netwib_debug_leak_add2(netwib_debug_leaktype type,
59 netwib_constptr infoptr,
60 netwib_uint32 infoint)
61 {
62 netwib_ptr bt[NETWIB_DEBUG_BACKTRACE_MAXSIZE];
63 netwib_uint32 btsize, i, j, threadid;
64 netwib_ptr *item;
65 netwib_debug_glovars_t *pglo = &netwib_debug_glovars;
66
67 /* first, get the back trace */
68 netwib_er(netwib_debug_backtrace_array(NETWIB_DEBUG_BACKTRACE_MAXSIZE,
69 bt, &btsize));
70 /*
71 for ( i=0 ; i<btsize-1 ; i++ ) {
72 netwib_er(netwib_debug_disp_fmt("%p,", bt[i]));
73 }
74 netwib_er(netwib_debug_disp_fmt("%p\n", bt[btsize-1]));
75 */
76
77 /* allocate list item */
78 item = (netwib_ptr*)malloc((6 + btsize)*sizeof(netwib_ptr));
79 if (item == NULL)
80 return(NETWIB_ERR_FUMALLOC);
81
82 /* store values in it */
83 netwib_er(netwib_debug_thread_id(&threadid));
84 item[0] = pglo->leak_list;
85 item[1] = (netwib_ptr)((netwib_uintptr)threadid);
86 item[2] = (netwib_ptr)((netwib_uintptr)type);
87 item[3] = netwib_priv_castpptr(infoptr);
88 item[4] = (netwib_ptr)((netwib_uintptr)infoint);
89 item[5] = (netwib_ptr)((netwib_uintptr)btsize);
90 for (i = 0, j = 6; i < btsize; i++, j++) {
91 item[j] = bt[i];
92 }
93
94 /* display the item */
95 /*netwib_er(netwib_debug_disp_string("ADD"));
96 netwib_er(netwib_debug_leak_disp(item));*/
97
98 /* insert the item at the beginning of the list */
99 pglo->leak_list = item;
100
101 return(NETWIB_ERR_OK);
102 }
netwib_debug_leak_add(netwib_debug_leaktype type,netwib_constptr infoptr,netwib_uint32 infoint)103 netwib_err netwib_debug_leak_add(netwib_debug_leaktype type,
104 netwib_constptr infoptr,
105 netwib_uint32 infoint)
106 {
107 netwib_err ret;
108 netwib_er(netwib_debug_glovars_wrlock());
109 ret = netwib_debug_leak_add2(type, infoptr, infoint);
110 netwib_er(netwib_debug_glovars_wrunlock());
111 return(ret);
112 }
113
114 /*-------------------------------------------------------------*/
netwib_debug_leak_del2(netwib_debug_leaktype type,netwib_bool useptr,netwib_constptr infoptr,netwib_bool useint,netwib_uint32 infoint)115 static netwib_err netwib_debug_leak_del2(netwib_debug_leaktype type,
116 netwib_bool useptr,
117 netwib_constptr infoptr,
118 netwib_bool useint,
119 netwib_uint32 infoint)
120 {
121 netwib_ptr *item, *pprec;
122 netwib_debug_glovars_t *pglo = &netwib_debug_glovars;
123
124 item = (netwib_ptr*)pglo->leak_list;
125 pprec = NULL;
126 while (item != NULL) {
127 if (item[2] == (netwib_ptr)type) {
128 /* optimization for :
129 if (!useptr || (useptr && item[3] == infoptr) ) {
130 if (!useint || (useint && item[4] == infoint) ) {
131 */
132 if (!useptr || item[3] == infoptr) {
133 if (!useint || item[4] == (netwib_ptr)((netwib_uintptr)infoint)) {
134 /* found it */
135 if (pprec == NULL)
136 pglo->leak_list = item[0];
137 else
138 *pprec = item[0];
139 /*netwib_er(netwib_debug_disp_string("DEL"));
140 netwib_er(netwib_debug_leak_disp(item));*/
141 free(item);
142 return(NETWIB_ERR_OK);
143 }
144 }
145 }
146 /* next item */
147 pprec = item;
148 item = (netwib_ptr*)item[0];
149 }
150
151 return(NETWIB_ERR_NOTFOUND);
152 }
netwib_debug_leak_del(netwib_debug_leaktype type,netwib_bool useptr,netwib_constptr infoptr,netwib_bool useint,netwib_uint32 infoint)153 netwib_err netwib_debug_leak_del(netwib_debug_leaktype type,
154 netwib_bool useptr,
155 netwib_constptr infoptr,
156 netwib_bool useint,
157 netwib_uint32 infoint)
158 {
159 netwib_err ret;
160 netwib_er(netwib_debug_glovars_wrlock());
161 ret = netwib_debug_leak_del2(type, useptr, infoptr, useint, infoint);
162 netwib_er(netwib_debug_glovars_wrunlock());
163 return(ret);
164 }
165
166 /*-------------------------------------------------------------*/
netwib_debug_leak_valid2(netwib_debug_leaktype type,netwib_bool useptr,netwib_constptr infoptr,netwib_bool useint,netwib_uint32 infoint)167 static netwib_err netwib_debug_leak_valid2(netwib_debug_leaktype type,
168 netwib_bool useptr,
169 netwib_constptr infoptr,
170 netwib_bool useint,
171 netwib_uint32 infoint)
172 {
173 netwib_ptr *item, *pprec;
174 netwib_debug_glovars_t *pglo = &netwib_debug_glovars;
175
176 item = (netwib_ptr*)pglo->leak_list;
177 pprec = NULL;
178 while (item != NULL) {
179 if (item[2] == (netwib_ptr)type) {
180 /* optimization for :
181 if (!useptr || (useptr && item[3] == infoptr) ) {
182 if (!useint || (useint && item[4] == infoint) ) {
183 */
184 if (!useptr || item[3] == infoptr) {
185 if (!useint || item[4] == (netwib_ptr)((netwib_uintptr)infoint)) {
186 /* found it */
187 return(NETWIB_ERR_OK);
188 }
189 }
190 }
191 /* next item */
192 pprec = item;
193 item = (netwib_ptr*)item[0];
194 }
195
196 return(NETWIB_ERR_LOOBJUSENOTINITIALIZED);
197 }
netwib_debug_leak_valid(netwib_debug_leaktype type,netwib_bool useptr,netwib_constptr infoptr,netwib_bool useint,netwib_uint32 infoint)198 netwib_err netwib_debug_leak_valid(netwib_debug_leaktype type,
199 netwib_bool useptr,
200 netwib_constptr infoptr,
201 netwib_bool useint,
202 netwib_uint32 infoint)
203 {
204 netwib_err ret;
205 netwib_er(netwib_debug_glovars_rdlock());
206 ret = netwib_debug_leak_valid2(type, useptr, infoptr, useint, infoint);
207 netwib_er(netwib_debug_glovars_rdunlock());
208 return(ret);
209 }
210
211 /*-------------------------------------------------------------*/
netwib_debug_leak_report2(void)212 static netwib_err netwib_debug_leak_report2(void)
213 {
214 netwib_ptr *item;
215 netwib_debug_glovars_t *pglo = &netwib_debug_glovars;
216 netwib_debug_leaktype type;
217
218 /* display everything except MEM */
219 for (type = (netwib_debug_leaktype)(NETWIB_DEBUG_LEAKTYPE_MEM + 2);
220 type < NETWIB_DEBUG_LEAKTYPE_ENDENUM;
221 type = (netwib_debug_leaktype)(type + 1)) {
222 item = (netwib_ptr*)pglo->leak_list;
223 while (item != NULL) {
224 if (item[2] == (netwib_ptr)type) {
225 netwib_er(netwib_debug_leak_disp(item));
226 }
227 item = (netwib_ptr*)item[0];
228 }
229 }
230
231 /* display MEM */
232 item = (netwib_ptr*)pglo->leak_list;
233 while (item != NULL) {
234 if (item[2] == (netwib_ptr)NETWIB_DEBUG_LEAKTYPE_MEM) {
235 netwib_er(netwib_debug_leak_disp(item));
236 }
237 item = (netwib_ptr*)item[0];
238 }
239
240 return(NETWIB_ERR_OK);
241 }
netwib_debug_leak_report(void)242 netwib_err netwib_debug_leak_report(void)
243 {
244 netwib_err ret;
245 netwib_er(netwib_debug_glovars_rdlock());
246 ret = netwib_debug_leak_report2();
247 netwib_er(netwib_debug_glovars_rdunlock());
248 return(ret);
249 }
250
251
252 /*-------------------------------------------------------------*/
253 /*-------------------------------------------------------------*/
254 /*-------------------------------------------------------------*/
255 /*-------------------------------------------------------------*/
netwib_debug_leak_add_generic(netwib_constptr ptr,netwib_debug_leaktype leaktype)256 netwib_err netwib_debug_leak_add_generic(netwib_constptr ptr,
257 netwib_debug_leaktype leaktype)
258 {
259 return(netwib_debug_leak_add(leaktype, ptr, 0));
260 }
261
262 /*-------------------------------------------------------------*/
netwib_debug_leak_del_generic(netwib_constptr ptr,netwib_debug_leaktype leaktype)263 netwib_err netwib_debug_leak_del_generic(netwib_constptr ptr,
264 netwib_debug_leaktype leaktype)
265 {
266 return(netwib_debug_leak_del(leaktype, NETWIB_TRUE, ptr, NETWIB_FALSE, 0));
267 }
268
269 /*-------------------------------------------------------------*/
netwib_debug_leak_valid_generic(netwib_constptr ptr,netwib_debug_leaktype leaktype)270 netwib_err netwib_debug_leak_valid_generic(netwib_constptr ptr,
271 netwib_debug_leaktype leaktype)
272 {
273 return(netwib_debug_leak_valid(leaktype, NETWIB_TRUE, ptr, NETWIB_FALSE, 0));
274 }
275
276
277 /*-------------------------------------------------------------*/
278 /*-------------------------------------------------------------*/
netwib_debug_leak_add_mem(netwib_uint32 allocsize,netwib_constptr ptr)279 netwib_err netwib_debug_leak_add_mem(netwib_uint32 allocsize,
280 netwib_constptr ptr)
281 {
282 netwib_er(netwib_debug_leak_add(NETWIB_DEBUG_LEAKTYPE_MEM, ptr, allocsize));
283
284 return(NETWIB_ERR_OK);
285 }
286
287 /*-------------------------------------------------------------*/
netwib_debug_leak_del_mem(netwib_constptr ptr)288 netwib_err netwib_debug_leak_del_mem(netwib_constptr ptr)
289 {
290 netwib_err ret;
291
292 ret = netwib_debug_leak_del(NETWIB_DEBUG_LEAKTYPE_MEM,
293 NETWIB_TRUE, ptr, NETWIB_FALSE, 0);
294 if (ret == NETWIB_ERR_NOTFOUND) {
295 return(NETWIB_ERR_LOOBJCLOSENOTINITIALIZED);
296 }
297
298 return(ret);
299 }
300
301 /*-------------------------------------------------------------*/
netwib_debug_leak_valid_mem(netwib_constptr ptr)302 netwib_err netwib_debug_leak_valid_mem(netwib_constptr ptr)
303 {
304 return(netwib_debug_leak_valid(NETWIB_DEBUG_LEAKTYPE_MEM,
305 NETWIB_TRUE, ptr, NETWIB_FALSE, 0));
306 }
307
308 /*-------------------------------------------------------------*/
netwib_debug_leak_disp_mem(netwib_constptr infoptr,netwib_uint32 infoint)309 static netwib_err netwib_debug_leak_disp_mem(netwib_constptr infoptr,
310 netwib_uint32 infoint)
311 {
312 netwib_constdata infoptrdata = (netwib_constdata)infoptr;
313 netwib_uint32 i, displaysize;
314 netwib_byte c;
315
316 netwib_er(netwib_debug_disp_fmt("MEM : %p of size %{uint32}\n",
317 infoptr, infoint));
318
319 displaysize = infoint;
320 if (displaysize > 16)
321 displaysize = 16;
322 for (i = 0; i < displaysize; i++) {
323 netwib_er(netwib_debug_disp_fmt(" %{byte:02X}", infoptrdata[i]));
324 }
325 netwib_er(netwib_debug_disp_string(" "));
326 for (i = 0; i < displaysize; i++) {
327 c = infoptrdata[i];
328 if (netwib_c2_isprint(c)) {
329 netwib_er(netwib_debug_disp_fmt("%c", c));
330 } else {
331 netwib_er(netwib_debug_disp_string("."));
332 }
333 }
334 netwib_er(netwib_debug_disp_string("\n"));
335
336 return(NETWIB_ERR_OK);
337 }
338
339
340 /*-------------------------------------------------------------*/
341 /*-------------------------------------------------------------*/
netwib_debug_leak_add_fd(netwib_uint32 fd)342 netwib_err netwib_debug_leak_add_fd(netwib_uint32 fd)
343 {
344 return(netwib_debug_leak_add(NETWIB_DEBUG_LEAKTYPE_FD, NULL, fd));
345 }
346
347 /*-------------------------------------------------------------*/
netwib_debug_leak_del_fd(netwib_uint32 fd)348 netwib_err netwib_debug_leak_del_fd(netwib_uint32 fd)
349 {
350 return(netwib_debug_leak_del(NETWIB_DEBUG_LEAKTYPE_FD,
351 NETWIB_FALSE, NULL, NETWIB_TRUE, fd));
352 }
353
354 /*-------------------------------------------------------------*/
netwib_debug_leak_valid_fd(netwib_uint32 fd)355 netwib_err netwib_debug_leak_valid_fd(netwib_uint32 fd)
356 {
357 return(netwib_debug_leak_valid(NETWIB_DEBUG_LEAKTYPE_FD,
358 NETWIB_FALSE, NULL, NETWIB_TRUE, fd));
359 }
360
361 /*-------------------------------------------------------------*/
netwib_debug_leak_disp_fd(netwib_uint32 infoint)362 static netwib_err netwib_debug_leak_disp_fd(netwib_uint32 infoint)
363 {
364 netwib_er(netwib_debug_disp_fmt("FD : %{uint32}\n", infoint));
365
366 return(NETWIB_ERR_OK);
367
368 }
369
370
371 /*-------------------------------------------------------------*/
372 /*-------------------------------------------------------------*/
373 /* Generate between 100 and 0x07FFFFFF :
374 - 99 is NETWIB_DEBUG_LEAK_ID_BUF_IGNORE
375 - stop at 0x07FFFFFF (27 bits) because stored in flags
376 - leak id might round, so it's why we use both
377 ptr/leakid for a buffer : probability is less important
378 (it might still happen...).
379 */
netwib_debug_leak_id_buf(netwib_uint32 * pleakid)380 netwib_err netwib_debug_leak_id_buf(netwib_uint32 *pleakid)
381 {
382
383 /* not MT safe, but that should not bother us */
384 static netwib_uint32 leakid = 0xFFFFFFFFu >> NETWIB_BUF_FLAGS_USEDBITS;
385
386 if (pleakid != NULL) {
387 if (leakid < 100) leakid = 0xFFFFFFFFu >> NETWIB_BUF_FLAGS_USEDBITS;
388 *pleakid = leakid;
389 leakid--;
390 }
391
392 return(NETWIB_ERR_OK);
393 }
394
395 /*-------------------------------------------------------------*/
netwib_debug_leak_add_buf(netwib_constptr ptr,netwib_uint32 leakid)396 netwib_err netwib_debug_leak_add_buf(netwib_constptr ptr,
397 netwib_uint32 leakid)
398 {
399 if (leakid != NETWIB_DEBUG_LEAK_ID_BUF_IGNORE) {
400 netwib_er(netwib_debug_leak_add(NETWIB_DEBUG_LEAKTYPE_BUF, ptr, leakid));
401 }
402 return(NETWIB_ERR_OK);
403 }
404
405 /*-------------------------------------------------------------*/
netwib_debug_leak_del_buf(netwib_constptr ptr,netwib_uint32 leakid)406 netwib_err netwib_debug_leak_del_buf(netwib_constptr ptr,
407 netwib_uint32 leakid)
408 {
409 if (leakid != NETWIB_DEBUG_LEAK_ID_BUF_IGNORE) {
410 netwib_er(netwib_debug_leak_del(NETWIB_DEBUG_LEAKTYPE_BUF,
411 NETWIB_TRUE, ptr, NETWIB_TRUE, leakid));
412 }
413 return(NETWIB_ERR_OK);
414 }
415
416 /*-------------------------------------------------------------*/
netwib_debug_leak_valid_buf(netwib_constptr ptr,netwib_uint32 leakid)417 netwib_err netwib_debug_leak_valid_buf(netwib_constptr ptr,
418 netwib_uint32 leakid)
419 {
420 if (leakid != NETWIB_DEBUG_LEAK_ID_BUF_IGNORE) {
421 netwib_er(netwib_debug_leak_valid(NETWIB_DEBUG_LEAKTYPE_BUF,
422 NETWIB_TRUE, ptr, NETWIB_TRUE, leakid));
423 }
424 return(NETWIB_ERR_OK);
425 }
426
427 /*-------------------------------------------------------------*/
netwib_debug_leak_disp_buf(netwib_constptr infoptr,netwib_uint32 infoint)428 static netwib_err netwib_debug_leak_disp_buf(netwib_constptr infoptr,
429 netwib_uint32 infoint)
430 {
431 netwib_er(netwib_debug_disp_fmt("BUF : ptr=%p leakid=%{uint32:08X}\n",
432 infoptr, infoint));
433
434 return(NETWIB_ERR_OK);
435 }
436
437
438 /*-------------------------------------------------------------*/
439 /*-------------------------------------------------------------*/
440 /*-------------------------------------------------------------*/
441 /*-------------------------------------------------------------*/
netwib_debug_leak_disp(netwib_ptr item[])442 static netwib_err netwib_debug_leak_disp(netwib_ptr item[])
443 {
444 netwib_uint32 btsize, i, threadid;
445 netwib_debug_leaktype type;
446 netwib_ptr infoptr;
447 netwib_uint32 infoint;
448
449 btsize = (netwib_uint32)((netwib_uintptr)item[5]);
450 if (btsize > NETWIB_DEBUG_BACKTRACE_MAXSIZE) {
451 netwib_er(netwib_debug_disp_string("netwib_debug_leak_disp : btsize>NETWIB_DEBUG_BACKTRACE_MAXSIZE"));
452 return(NETWIB_ERR_LOINTERNALERROR);
453 }
454
455 threadid = (netwib_uint32)((netwib_uintptr)item[1]);
456 netwib_er(netwib_debug_disp_fmt("[threadid:%{uint32}] : ", threadid));
457
458 if (btsize != 0) {
459 for (i = 6; i < btsize + 5; i++) {
460 netwib_er(netwib_debug_disp_fmt("%p,", item[i]));
461 }
462 netwib_er(netwib_debug_disp_fmt("%p\n", item[btsize + 4]));
463 } else {
464 netwib_er(netwib_debug_disp_string("Backtrace is empty (unsupported ?)\n"));
465 }
466
467 type = (netwib_debug_leaktype)((netwib_uintptr)item[2]);
468 infoptr = item[3];
469 infoint = (netwib_uint32)((netwib_uintptr)item[4]);
470 switch(type) {
471 case NETWIB_DEBUG_LEAKTYPE_MEM :
472 netwib_er(netwib_debug_leak_disp_mem(infoptr, infoint));
473 break;
474 case NETWIB_DEBUG_LEAKTYPE_FD :
475 netwib_er(netwib_debug_leak_disp_fd(infoint));
476 break;
477 case NETWIB_DEBUG_LEAKTYPE_BUF :
478 netwib_er(netwib_debug_leak_disp_buf(infoptr, infoint));
479 break;
480 case NETWIB_DEBUG_LEAKTYPE_RING :
481 netwib_er(netwib_debug_disp_fmt("RING : %p\n", infoptr));
482 break;
483 case NETWIB_DEBUG_LEAKTYPE_RINGI :
484 netwib_er(netwib_debug_disp_fmt("RING_INDEX : %p\n", infoptr));
485 break;
486 case NETWIB_DEBUG_LEAKTYPE_HASH :
487 netwib_er(netwib_debug_disp_fmt("HASH : %p\n", infoptr));
488 break;
489 case NETWIB_DEBUG_LEAKTYPE_HASHI :
490 netwib_er(netwib_debug_disp_fmt("HASH_INDEX : %p\n", infoptr));
491 break;
492 case NETWIB_DEBUG_LEAKTYPE_ARRAY :
493 netwib_er(netwib_debug_disp_fmt("ARRAY : %p\n", infoptr));
494 break;
495 case NETWIB_DEBUG_LEAKTYPE_DIR :
496 netwib_er(netwib_debug_disp_fmt("DIR : %p\n", infoptr));
497 break;
498 case NETWIB_DEBUG_LEAKTYPE_IO :
499 netwib_er(netwib_debug_disp_fmt("IO : %p\n", infoptr));
500 break;
501 case NETWIB_DEBUG_LEAKTYPE_THREAD :
502 netwib_er(netwib_debug_disp_fmt("THREAD : %p\n", infoptr));
503 break;
504 case NETWIB_DEBUG_LEAKTYPE_THREAD_MUTEX :
505 netwib_er(netwib_debug_disp_fmt("THREAD_MUTEX : %p\n", infoptr));
506 break;
507 case NETWIB_DEBUG_LEAKTYPE_THREAD_RWLOCK :
508 netwib_er(netwib_debug_disp_fmt("THREAD_RWLOCK : %p\n", infoptr));
509 break;
510 case NETWIB_DEBUG_LEAKTYPE_THREAD_COND :
511 netwib_er(netwib_debug_disp_fmt("THREAD_COND : %p\n", infoptr));
512 break;
513 case NETWIB_DEBUG_LEAKTYPE_THREAD_TSD :
514 netwib_er(netwib_debug_disp_fmt("THREAD_TSD : %p\n", infoptr));
515 break;
516 case NETWIB_DEBUG_LEAKTYPE_WAIT :
517 netwib_er(netwib_debug_disp_fmt("WAIT : %p\n", infoptr));
518 break;
519 case NETWIB_DEBUG_LEAKTYPE_ETHS :
520 netwib_er(netwib_debug_disp_fmt("ETHS : %p\n", infoptr));
521 break;
522 case NETWIB_DEBUG_LEAKTYPE_IPS :
523 netwib_er(netwib_debug_disp_fmt("IPS : %p\n", infoptr));
524 break;
525 case NETWIB_DEBUG_LEAKTYPE_PORTS :
526 netwib_er(netwib_debug_disp_fmt("PORTS : %p\n", infoptr));
527 break;
528 case NETWIB_DEBUG_LEAKTYPE_ETHS_INDEX :
529 netwib_er(netwib_debug_disp_fmt("ETHS_INDEX : %p\n", infoptr));
530 break;
531 case NETWIB_DEBUG_LEAKTYPE_IPS_INDEX :
532 netwib_er(netwib_debug_disp_fmt("IPS_INDEX : %p\n", infoptr));
533 break;
534 case NETWIB_DEBUG_LEAKTYPE_PORTS_INDEX :
535 netwib_er(netwib_debug_disp_fmt("PORTS_INDEX : %p\n", infoptr));
536 break;
537 case NETWIB_DEBUG_LEAKTYPE_CONF_DEVICES_INDEX :
538 netwib_er(netwib_debug_disp_fmt("CONF_DEVICES_INDEX : %p\n", infoptr));
539 break;
540 case NETWIB_DEBUG_LEAKTYPE_CONF_IP_INDEX :
541 netwib_er(netwib_debug_disp_fmt("CONF_IP_INDEX : %p\n", infoptr));
542 break;
543 case NETWIB_DEBUG_LEAKTYPE_CONF_ARPCACHE_INDEX :
544 netwib_er(netwib_debug_disp_fmt("CONF_ARPCACHE_INDEX : %p\n", infoptr));
545 break;
546 case NETWIB_DEBUG_LEAKTYPE_CONF_ROUTES_INDEX :
547 netwib_er(netwib_debug_disp_fmt("CONF_ROUTES_INDEX : %p\n", infoptr));
548 break;
549 case NETWIB_DEBUG_LEAKTYPE_ENDENUM :
550 default :
551 netwib_er(netwib_priv_errmsg_func_string("netwib_debug_leak_disp",
552 "unknown value for type"));
553 return(NETWIB_ERR_LOINTERNALERROR);
554 }
555
556 return(NETWIB_ERR_OK);
557 }
558