1 /* Test plugin for the GNU linker. 2 Copyright (C) 2010-2014 Free Software Foundation, Inc. 3 4 This file is part of the GNU Binutils. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 19 MA 02110-1301, USA. */ 20 21 #include "sysdep.h" 22 #include "bfd.h" 23 #include "plugin-api.h" 24 /* For ARRAY_SIZE macro only - we don't link the library itself. */ 25 #include "libiberty.h" 26 27 extern enum ld_plugin_status onload (struct ld_plugin_tv *tv); 28 static enum ld_plugin_status onclaim_file (const struct ld_plugin_input_file *file, 29 int *claimed); 30 static enum ld_plugin_status onall_symbols_read (void); 31 static enum ld_plugin_status oncleanup (void); 32 33 /* Helper for calling plugin api message function. */ 34 #define TV_MESSAGE if (tv_message) (*tv_message) 35 36 /* Struct for recording files to claim / files claimed. */ 37 typedef struct claim_file 38 { 39 struct claim_file *next; 40 struct ld_plugin_input_file file; 41 bfd_boolean claimed; 42 struct ld_plugin_symbol *symbols; 43 int n_syms_allocated; 44 int n_syms_used; 45 } claim_file_t; 46 47 /* Types of things that can be added at all symbols read time. */ 48 typedef enum addfile_enum 49 { 50 ADD_FILE, 51 ADD_LIB, 52 ADD_DIR 53 } addfile_enum_t; 54 55 /* Struct for recording files to add to final link. */ 56 typedef struct add_file 57 { 58 struct add_file *next; 59 const char *name; 60 addfile_enum_t type; 61 } add_file_t; 62 63 /* Helper macro for defining array of transfer vector tags and names. */ 64 #define ADDENTRY(tag) { tag, #tag } 65 66 /* Struct for looking up human-readable versions of tag names. */ 67 typedef struct tag_name 68 { 69 enum ld_plugin_tag tag; 70 const char *name; 71 } tag_name_t; 72 73 /* Array of all known tags and their names. */ 74 static const tag_name_t tag_names[] = 75 { 76 ADDENTRY(LDPT_NULL), 77 ADDENTRY(LDPT_API_VERSION), 78 ADDENTRY(LDPT_GOLD_VERSION), 79 ADDENTRY(LDPT_LINKER_OUTPUT), 80 ADDENTRY(LDPT_OPTION), 81 ADDENTRY(LDPT_REGISTER_CLAIM_FILE_HOOK), 82 ADDENTRY(LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK), 83 ADDENTRY(LDPT_REGISTER_CLEANUP_HOOK), 84 ADDENTRY(LDPT_ADD_SYMBOLS), 85 ADDENTRY(LDPT_GET_SYMBOLS), 86 ADDENTRY(LDPT_GET_SYMBOLS_V2), 87 ADDENTRY(LDPT_ADD_INPUT_FILE), 88 ADDENTRY(LDPT_MESSAGE), 89 ADDENTRY(LDPT_GET_INPUT_FILE), 90 ADDENTRY(LDPT_RELEASE_INPUT_FILE), 91 ADDENTRY(LDPT_ADD_INPUT_LIBRARY), 92 ADDENTRY(LDPT_OUTPUT_NAME), 93 ADDENTRY(LDPT_SET_EXTRA_LIBRARY_PATH), 94 ADDENTRY(LDPT_GNU_LD_VERSION) 95 }; 96 97 /* Function pointers to cache hooks passed at onload time. */ 98 static ld_plugin_register_claim_file tv_register_claim_file = 0; 99 static ld_plugin_register_all_symbols_read tv_register_all_symbols_read = 0; 100 static ld_plugin_register_cleanup tv_register_cleanup = 0; 101 static ld_plugin_add_symbols tv_add_symbols = 0; 102 static ld_plugin_get_symbols tv_get_symbols = 0; 103 static ld_plugin_get_symbols tv_get_symbols_v2 = 0; 104 static ld_plugin_add_input_file tv_add_input_file = 0; 105 static ld_plugin_message tv_message = 0; 106 static ld_plugin_get_input_file tv_get_input_file = 0; 107 static ld_plugin_release_input_file tv_release_input_file = 0; 108 static ld_plugin_add_input_library tv_add_input_library = 0; 109 static ld_plugin_set_extra_library_path tv_set_extra_library_path = 0; 110 111 /* Other cached info from the transfer vector. */ 112 static enum ld_plugin_output_file_type linker_output; 113 static const char *output_name; 114 115 /* Behaviour control flags set by plugin options. */ 116 static enum ld_plugin_status onload_ret = LDPS_OK; 117 static enum ld_plugin_status claim_file_ret = LDPS_OK; 118 static enum ld_plugin_status all_symbols_read_ret = LDPS_OK; 119 static enum ld_plugin_status cleanup_ret = LDPS_OK; 120 static bfd_boolean register_claimfile_hook = FALSE; 121 static bfd_boolean register_allsymbolsread_hook = FALSE; 122 static bfd_boolean register_cleanup_hook = FALSE; 123 static bfd_boolean dumpresolutions = FALSE; 124 125 /* The master list of all claimable/claimed files. */ 126 static claim_file_t *claimfiles_list = NULL; 127 128 /* We keep a tail pointer for easy linking on the end. */ 129 static claim_file_t **claimfiles_tail_chain_ptr = &claimfiles_list; 130 131 /* The last claimed file added to the list, for receiving syms. */ 132 static claim_file_t *last_claimfile = NULL; 133 134 /* The master list of all files to add to the final link. */ 135 static add_file_t *addfiles_list = NULL; 136 137 /* We keep a tail pointer for easy linking on the end. */ 138 static add_file_t **addfiles_tail_chain_ptr = &addfiles_list; 139 140 /* Add a new claimfile on the end of the chain. */ 141 static enum ld_plugin_status 142 record_claim_file (const char *file) 143 { 144 claim_file_t *newfile; 145 146 newfile = malloc (sizeof *newfile); 147 if (!newfile) 148 return LDPS_ERR; 149 memset (newfile, 0, sizeof *newfile); 150 /* Only setup for now is remembering the name to look for. */ 151 newfile->file.name = file; 152 /* Chain it on the end of the list. */ 153 *claimfiles_tail_chain_ptr = newfile; 154 claimfiles_tail_chain_ptr = &newfile->next; 155 /* Record it as active for receiving symbols to register. */ 156 last_claimfile = newfile; 157 return LDPS_OK; 158 } 159 160 /* Add a new addfile on the end of the chain. */ 161 static enum ld_plugin_status 162 record_add_file (const char *file, addfile_enum_t type) 163 { 164 add_file_t *newfile; 165 166 newfile = malloc (sizeof *newfile); 167 if (!newfile) 168 return LDPS_ERR; 169 newfile->next = NULL; 170 newfile->name = file; 171 newfile->type = type; 172 /* Chain it on the end of the list. */ 173 *addfiles_tail_chain_ptr = newfile; 174 addfiles_tail_chain_ptr = &newfile->next; 175 return LDPS_OK; 176 } 177 178 /* Parse a command-line argument string into a symbol definition. 179 Symbol-strings follow the colon-separated format: 180 NAME:VERSION:def:vis:size:COMDATKEY 181 where the fields in capitals are strings and those in lower 182 case are integers. We don't allow to specify a resolution as 183 doing so is not meaningful when calling the add symbols hook. */ 184 static enum ld_plugin_status 185 parse_symdefstr (const char *str, struct ld_plugin_symbol *sym) 186 { 187 int n; 188 long long size; 189 const char *colon1, *colon2, *colon5; 190 191 /* Locate the colons separating the first two strings. */ 192 colon1 = strchr (str, ':'); 193 if (!colon1) 194 return LDPS_ERR; 195 colon2 = strchr (colon1+1, ':'); 196 if (!colon2) 197 return LDPS_ERR; 198 /* Name must not be empty (version may be). */ 199 if (colon1 == str) 200 return LDPS_ERR; 201 202 /* The fifth colon and trailing comdat key string are optional, 203 but the intermediate ones must all be present. */ 204 colon5 = strchr (colon2+1, ':'); /* Actually only third so far. */ 205 if (!colon5) 206 return LDPS_ERR; 207 colon5 = strchr (colon5+1, ':'); /* Hopefully fourth now. */ 208 if (!colon5) 209 return LDPS_ERR; 210 colon5 = strchr (colon5+1, ':'); /* Optional fifth now. */ 211 212 /* Finally we'll use sscanf to parse the numeric fields, then 213 we'll split out the strings which we need to allocate separate 214 storage for anyway so that we can add nul termination. */ 215 n = sscanf (colon2 + 1, "%i:%i:%lli", &sym->def, &sym->visibility, &size); 216 if (n != 3) 217 return LDPS_ERR; 218 219 /* Parsed successfully, so allocate strings and fill out fields. */ 220 sym->size = size; 221 sym->resolution = LDPR_UNKNOWN; 222 sym->name = malloc (colon1 - str + 1); 223 if (!sym->name) 224 return LDPS_ERR; 225 memcpy (sym->name, str, colon1 - str); 226 sym->name[colon1 - str] = '\0'; 227 if (colon2 > (colon1 + 1)) 228 { 229 sym->version = malloc (colon2 - colon1); 230 if (!sym->version) 231 return LDPS_ERR; 232 memcpy (sym->version, colon1 + 1, colon2 - (colon1 + 1)); 233 sym->version[colon2 - (colon1 + 1)] = '\0'; 234 } 235 else 236 sym->version = NULL; 237 if (colon5 && colon5[1]) 238 { 239 sym->comdat_key = malloc (strlen (colon5 + 1) + 1); 240 if (!sym->comdat_key) 241 return LDPS_ERR; 242 strcpy (sym->comdat_key, colon5 + 1); 243 } 244 else 245 sym->comdat_key = 0; 246 return LDPS_OK; 247 } 248 249 /* Record a symbol to be added for the last-added claimfile. */ 250 static enum ld_plugin_status 251 record_claimed_file_symbol (const char *symdefstr) 252 { 253 struct ld_plugin_symbol sym; 254 255 /* Can't add symbols except as belonging to claimed files. */ 256 if (!last_claimfile) 257 return LDPS_ERR; 258 259 /* If string doesn't parse correctly, give an error. */ 260 if (parse_symdefstr (symdefstr, &sym) != LDPS_OK) 261 return LDPS_ERR; 262 263 /* Check for enough space, resize array if needed, and add it. */ 264 if (last_claimfile->n_syms_allocated == last_claimfile->n_syms_used) 265 { 266 int new_n_syms = last_claimfile->n_syms_allocated 267 ? 2 * last_claimfile->n_syms_allocated 268 : 10; 269 last_claimfile->symbols = realloc (last_claimfile->symbols, 270 new_n_syms * sizeof *last_claimfile->symbols); 271 if (!last_claimfile->symbols) 272 return LDPS_ERR; 273 last_claimfile->n_syms_allocated = new_n_syms; 274 } 275 last_claimfile->symbols[last_claimfile->n_syms_used++] = sym; 276 277 return LDPS_OK; 278 } 279 280 /* Records the status to return from one of the registered hooks. */ 281 static enum ld_plugin_status 282 set_ret_val (const char *whichval, enum ld_plugin_status retval) 283 { 284 if (!strcmp ("onload", whichval)) 285 onload_ret = retval; 286 else if (!strcmp ("claimfile", whichval)) 287 claim_file_ret = retval; 288 else if (!strcmp ("allsymbolsread", whichval)) 289 all_symbols_read_ret = retval; 290 else if (!strcmp ("cleanup", whichval)) 291 cleanup_ret = retval; 292 else 293 return LDPS_ERR; 294 return LDPS_OK; 295 } 296 297 /* Records hooks which should be registered. */ 298 static enum ld_plugin_status 299 set_register_hook (const char *whichhook, bfd_boolean yesno) 300 { 301 if (!strcmp ("claimfile", whichhook)) 302 register_claimfile_hook = yesno; 303 else if (!strcmp ("allsymbolsread", whichhook)) 304 register_allsymbolsread_hook = yesno; 305 else if (!strcmp ("cleanup", whichhook)) 306 register_cleanup_hook = yesno; 307 else 308 return LDPS_ERR; 309 return LDPS_OK; 310 } 311 312 /* Determine type of plugin option and pass to individual parsers. */ 313 static enum ld_plugin_status 314 parse_option (const char *opt) 315 { 316 if (!strncmp ("fail", opt, 4)) 317 return set_ret_val (opt + 4, LDPS_ERR); 318 else if (!strncmp ("pass", opt, 4)) 319 return set_ret_val (opt + 4, LDPS_OK); 320 else if (!strncmp ("register", opt, 8)) 321 return set_register_hook (opt + 8, TRUE); 322 else if (!strncmp ("noregister", opt, 10)) 323 return set_register_hook (opt + 10, FALSE); 324 else if (!strncmp ("claim:", opt, 6)) 325 return record_claim_file (opt + 6); 326 else if (!strncmp ("sym:", opt, 4)) 327 return record_claimed_file_symbol (opt + 4); 328 else if (!strncmp ("add:", opt, 4)) 329 return record_add_file (opt + 4, ADD_FILE); 330 else if (!strncmp ("lib:", opt, 4)) 331 return record_add_file (opt + 4, ADD_LIB); 332 else if (!strncmp ("dir:", opt, 4)) 333 return record_add_file (opt + 4, ADD_DIR); 334 else if (!strcmp ("dumpresolutions", opt)) 335 dumpresolutions = TRUE; 336 else 337 return LDPS_ERR; 338 return LDPS_OK; 339 } 340 341 /* Output contents of transfer vector array entry in human-readable form. */ 342 static void 343 dump_tv_tag (size_t n, struct ld_plugin_tv *tv) 344 { 345 size_t tag; 346 char unknownbuf[40]; 347 const char *name; 348 349 for (tag = 0; tag < ARRAY_SIZE (tag_names); tag++) 350 if (tag_names[tag].tag == tv->tv_tag) 351 break; 352 sprintf (unknownbuf, "unknown tag #%d", tv->tv_tag); 353 name = (tag < ARRAY_SIZE (tag_names)) ? tag_names[tag].name : unknownbuf; 354 switch (tv->tv_tag) 355 { 356 case LDPT_OPTION: 357 case LDPT_OUTPUT_NAME: 358 TV_MESSAGE (LDPL_INFO, "tv[%d]: %s '%s'", n, name, 359 tv->tv_u.tv_string); 360 break; 361 case LDPT_REGISTER_CLAIM_FILE_HOOK: 362 case LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK: 363 case LDPT_REGISTER_CLEANUP_HOOK: 364 case LDPT_ADD_SYMBOLS: 365 case LDPT_GET_SYMBOLS: 366 case LDPT_GET_SYMBOLS_V2: 367 case LDPT_ADD_INPUT_FILE: 368 case LDPT_MESSAGE: 369 case LDPT_GET_INPUT_FILE: 370 case LDPT_RELEASE_INPUT_FILE: 371 case LDPT_ADD_INPUT_LIBRARY: 372 case LDPT_SET_EXTRA_LIBRARY_PATH: 373 TV_MESSAGE (LDPL_INFO, "tv[%d]: %s func@0x%p", n, name, 374 (void *)(tv->tv_u.tv_message)); 375 break; 376 case LDPT_NULL: 377 case LDPT_API_VERSION: 378 case LDPT_GOLD_VERSION: 379 case LDPT_LINKER_OUTPUT: 380 case LDPT_GNU_LD_VERSION: 381 default: 382 TV_MESSAGE (LDPL_INFO, "tv[%d]: %s value %W (%d)", n, name, 383 (bfd_vma)tv->tv_u.tv_val, tv->tv_u.tv_val); 384 break; 385 } 386 } 387 388 /* Handle/record information received in a transfer vector entry. */ 389 static enum ld_plugin_status 390 parse_tv_tag (struct ld_plugin_tv *tv) 391 { 392 #define SETVAR(x) x = tv->tv_u.x 393 switch (tv->tv_tag) 394 { 395 case LDPT_OPTION: 396 return parse_option (tv->tv_u.tv_string); 397 case LDPT_NULL: 398 case LDPT_GOLD_VERSION: 399 case LDPT_GNU_LD_VERSION: 400 case LDPT_API_VERSION: 401 default: 402 break; 403 case LDPT_OUTPUT_NAME: 404 output_name = tv->tv_u.tv_string; 405 break; 406 case LDPT_LINKER_OUTPUT: 407 linker_output = tv->tv_u.tv_val; 408 break; 409 case LDPT_REGISTER_CLAIM_FILE_HOOK: 410 SETVAR(tv_register_claim_file); 411 break; 412 case LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK: 413 SETVAR(tv_register_all_symbols_read); 414 break; 415 case LDPT_REGISTER_CLEANUP_HOOK: 416 SETVAR(tv_register_cleanup); 417 break; 418 case LDPT_ADD_SYMBOLS: 419 SETVAR(tv_add_symbols); 420 break; 421 case LDPT_GET_SYMBOLS: 422 SETVAR(tv_get_symbols); 423 break; 424 case LDPT_GET_SYMBOLS_V2: 425 tv_get_symbols_v2 = tv->tv_u.tv_get_symbols; 426 break; 427 case LDPT_ADD_INPUT_FILE: 428 SETVAR(tv_add_input_file); 429 break; 430 case LDPT_MESSAGE: 431 SETVAR(tv_message); 432 break; 433 case LDPT_GET_INPUT_FILE: 434 SETVAR(tv_get_input_file); 435 break; 436 case LDPT_RELEASE_INPUT_FILE: 437 SETVAR(tv_release_input_file); 438 break; 439 case LDPT_ADD_INPUT_LIBRARY: 440 SETVAR(tv_add_input_library); 441 break; 442 case LDPT_SET_EXTRA_LIBRARY_PATH: 443 SETVAR(tv_set_extra_library_path); 444 break; 445 } 446 #undef SETVAR 447 return LDPS_OK; 448 } 449 450 /* Record any useful information in transfer vector entry and display 451 it in human-readable form using the plugin API message() callback. */ 452 enum ld_plugin_status 453 parse_and_dump_tv_tag (size_t n, struct ld_plugin_tv *tv) 454 { 455 enum ld_plugin_status rv = parse_tv_tag (tv); 456 dump_tv_tag (n, tv); 457 return rv; 458 } 459 460 /* Standard plugin API entry point. */ 461 enum ld_plugin_status 462 onload (struct ld_plugin_tv *tv) 463 { 464 size_t n = 0; 465 enum ld_plugin_status rv; 466 467 /* This plugin does nothing but dump the tv array. It would 468 be an error if this function was called without one. */ 469 if (!tv) 470 return LDPS_ERR; 471 472 /* First entry should always be LDPT_MESSAGE, letting us get 473 hold of it easily so we can send output straight away. */ 474 if (tv[0].tv_tag == LDPT_MESSAGE) 475 tv_message = tv[0].tv_u.tv_message; 476 477 fflush (NULL); 478 TV_MESSAGE (LDPL_INFO, "Hello from testplugin."); 479 480 do 481 if ((rv = parse_and_dump_tv_tag (n++, tv)) != LDPS_OK) 482 return rv; 483 while ((tv++)->tv_tag != LDPT_NULL); 484 485 /* Register hooks only if instructed by options. */ 486 if (register_claimfile_hook) 487 { 488 if (!tv_register_claim_file) 489 { 490 TV_MESSAGE (LDPL_FATAL, "No register_claim_file hook"); 491 fflush (NULL); 492 return LDPS_ERR; 493 } 494 (*tv_register_claim_file) (onclaim_file); 495 } 496 if (register_allsymbolsread_hook) 497 { 498 if (!tv_register_all_symbols_read) 499 { 500 TV_MESSAGE (LDPL_FATAL, "No register_all_symbols_read hook"); 501 fflush (NULL); 502 return LDPS_ERR; 503 } 504 (*tv_register_all_symbols_read) (onall_symbols_read); 505 } 506 if (register_cleanup_hook) 507 { 508 if (!tv_register_cleanup) 509 { 510 TV_MESSAGE (LDPL_FATAL, "No register_cleanup hook"); 511 fflush (NULL); 512 return LDPS_ERR; 513 } 514 (*tv_register_cleanup) (oncleanup); 515 } 516 fflush (NULL); 517 return onload_ret; 518 } 519 520 /* Standard plugin API registerable hook. */ 521 static enum ld_plugin_status 522 onclaim_file (const struct ld_plugin_input_file *file, int *claimed) 523 { 524 /* Let's see if we want to claim this file. */ 525 claim_file_t *claimfile = claimfiles_list; 526 while (claimfile) 527 { 528 if (!strcmp (file->name, claimfile->file.name)) 529 break; 530 claimfile = claimfile->next; 531 } 532 533 /* Inform the user/testsuite. */ 534 TV_MESSAGE (LDPL_INFO, "hook called: claim_file %s [@%ld/%ld] %s", 535 file->name, (long)file->offset, (long)file->filesize, 536 claimfile ? "CLAIMED" : "not claimed"); 537 fflush (NULL); 538 539 /* If we decided to claim it, record that fact, and add any symbols 540 that were defined for it by plugin options. */ 541 *claimed = (claimfile != 0); 542 if (claimfile) 543 { 544 claimfile->claimed = TRUE; 545 claimfile->file = *file; 546 if (claimfile->n_syms_used && !tv_add_symbols) 547 return LDPS_ERR; 548 else if (claimfile->n_syms_used) 549 return (*tv_add_symbols) (claimfile->file.handle, 550 claimfile->n_syms_used, claimfile->symbols); 551 } 552 553 return claim_file_ret; 554 } 555 556 /* Standard plugin API registerable hook. */ 557 static enum ld_plugin_status 558 onall_symbols_read (void) 559 { 560 static const char *resolutions[] = 561 { 562 "LDPR_UNKNOWN", 563 "LDPR_UNDEF", 564 "LDPR_PREVAILING_DEF", 565 "LDPR_PREVAILING_DEF_IRONLY", 566 "LDPR_PREEMPTED_REG", 567 "LDPR_PREEMPTED_IR", 568 "LDPR_RESOLVED_IR", 569 "LDPR_RESOLVED_EXEC", 570 "LDPR_RESOLVED_DYN", 571 "LDPR_PREVAILING_DEF_IRONLY_EXP", 572 }; 573 claim_file_t *claimfile = dumpresolutions ? claimfiles_list : NULL; 574 add_file_t *addfile = addfiles_list; 575 TV_MESSAGE (LDPL_INFO, "hook called: all symbols read."); 576 for ( ; claimfile; claimfile = claimfile->next) 577 { 578 enum ld_plugin_status rv; 579 int n; 580 if (claimfile->n_syms_used && !tv_get_symbols_v2) 581 return LDPS_ERR; 582 else if (!claimfile->n_syms_used) 583 continue; 584 rv = tv_get_symbols_v2 (claimfile->file.handle, claimfile->n_syms_used, 585 claimfile->symbols); 586 if (rv != LDPS_OK) 587 return rv; 588 for (n = 0; n < claimfile->n_syms_used; n++) 589 TV_MESSAGE (LDPL_INFO, "Sym: '%s%s%s' Resolution: %s", 590 claimfile->symbols[n].name, 591 claimfile->symbols[n].version ? "@" : "", 592 (claimfile->symbols[n].version 593 ? claimfile->symbols[n].version : ""), 594 resolutions[claimfile->symbols[n].resolution]); 595 } 596 for ( ; addfile ; addfile = addfile->next) 597 { 598 enum ld_plugin_status rv; 599 if (addfile->type == ADD_LIB && tv_add_input_library) 600 rv = (*tv_add_input_library) (addfile->name); 601 else if (addfile->type == ADD_FILE && tv_add_input_file) 602 rv = (*tv_add_input_file) (addfile->name); 603 else if (addfile->type == ADD_DIR && tv_set_extra_library_path) 604 rv = (*tv_set_extra_library_path) (addfile->name); 605 else 606 rv = LDPS_ERR; 607 if (rv != LDPS_OK) 608 return rv; 609 } 610 fflush (NULL); 611 return all_symbols_read_ret; 612 } 613 614 /* Standard plugin API registerable hook. */ 615 static enum ld_plugin_status 616 oncleanup (void) 617 { 618 TV_MESSAGE (LDPL_INFO, "hook called: cleanup."); 619 fflush (NULL); 620 return cleanup_ret; 621 } 622
