1#!/usr/perl5/bin/perl -w 2# 3# CDDL HEADER START 4# 5# The contents of this file are subject to the terms of the 6# Common Development and Distribution License (the "License"). 7# You may not use this file except in compliance 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# 24# Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved. 25# 26 27# 28# Check ELF information. 29# 30# This script descends a directory hierarchy inspecting ELF dynamic executables 31# and shared objects. The general theme is to verify that common Makefile rules 32# have been used to build these objects. Typical failures occur when Makefile 33# rules are re-invented rather than being inherited from "cmd/lib" Makefiles. 34# 35# As always, a number of components don't follow the rules, and these are 36# excluded to reduce this scripts output. 37# 38# By default any file that has conditions that should be reported is first 39# listed and then each condition follows. The -o (one-line) option produces a 40# more terse output which is better for sorting/diffing with "nightly". 41# 42# NOTE: missing dependencies, symbols or versions are reported by running the 43# file through ldd(1). As objects within a proto area are built to exist in a 44# base system, standard use of ldd(1) will bind any objects to dependencies 45# that exist in the base system. It is frequently the case that newer objects 46# exist in the proto area that are required to satisfy other objects 47# dependencies, and without using these newer objects an ldd(1) will produce 48# misleading error messages. To compensate for this, the -D/-d options, or the 49# existence of the CODEMSG_WS/ROOT environment variables, cause the creation of 50# alternative dependency mappings via crle(1) configuration files that establish 51# any proto shared objects as alternatives to their base system location. Thus 52# ldd(1) can be executed against these configuration files so that objects in a 53# proto area bind to their dependencies in the same proto area. 54 55 56# Define all global variables (required for strict) 57use vars qw($Prog $Env $Ena64 $Tmpdir); 58use vars qw($LddNoU $Conf32 $Conf64); 59use vars qw(%opt); 60use vars qw($ErrFH $ErrTtl $InfoFH $InfoTtl $OutCnt1 $OutCnt2); 61 62# An exception file is used to specify regular expressions to match 63# objects. These directives specify special attributes of the object. 64# The regular expressions are read from the file and compiled into the 65# regular expression variables. 66# 67# The name of each regular expression variable is of the form 68# 69# $EXRE_xxx 70# 71# where xxx is the name of the exception in lower case. For example, 72# the regular expression variable for EXEC_STACK is $EXRE_exec_stack. 73# 74# onbld_elfmod::LoadExceptionsToEXRE() depends on this naming convention 75# to initialize the regular expression variables, and to detect invalid 76# exception names. 77# 78# If a given exception is not used in the exception file, its regular 79# expression variable will be undefined. Users of these variables must 80# test the variable with defined() prior to use: 81# 82# defined($EXRE_exec_stack) && ($foo =~ $EXRE_exec_stack) 83# 84# or if the test is to make sure the item is not specified: 85# 86# !defined($EXRE_exec_stack) || ($foo !~ $EXRE_exec_stack) 87# 88# ---- 89# 90# The exceptions are: 91# 92# EXEC_DATA 93# Objects that are not required to have non-executable writable 94# data segments. 95# 96# EXEC_STACK 97# Objects that are not required to have a non-executable stack 98# 99# NOCRLEALT 100# Objects that should be skipped by AltObjectConfig() when building 101# the crle script that maps objects to the proto area. 102# 103# NODIRECT 104# Objects that are not required to use direct bindings 105# 106# NOSYMSORT 107# Objects we should not check for duplicate addresses in 108# the symbol sort sections. 109# 110# OLDDEP 111# Objects that are no longer needed because their functionalty 112# has migrated elsewhere. These are usually pure filters that 113# point at libc. 114# 115# SKIP 116# Files and directories that should be excluded from analysis. 117# 118# STAB 119# Objects that are allowed to contain stab debugging sections 120# 121# TEXTREL 122# Object for which relocations are allowed to the text segment 123# 124# UNDEF_REF 125# Objects that are allowed undefined references 126# 127# UNREF_OBJ 128# "unreferenced object=" ldd(1) diagnostics. 129# 130# UNUSED_DEPS 131# Objects that are allowed to have unused dependencies 132# 133# UNUSED_OBJ 134# Objects that are allowed to be unused dependencies 135# 136# UNUSED_RPATH 137# Objects with unused runpaths 138# 139 140use vars qw($EXRE_exec_data $EXRE_exec_stack $EXRE_nocrlealt); 141use vars qw($EXRE_nodirect $EXRE_nosymsort); 142use vars qw($EXRE_olddep $EXRE_skip $EXRE_stab $EXRE_textrel $EXRE_undef_ref); 143use vars qw($EXRE_unref_obj $EXRE_unused_deps $EXRE_unused_obj); 144use vars qw($EXRE_unused_rpath); 145 146use strict; 147use Getopt::Std; 148use File::Basename; 149 150 151# Reliably compare two OS revisions. Arguments are <ver1> <op> <ver2>. 152# <op> is the string form of a normal numeric comparison operator. 153sub cmp_os_ver { 154 my @ver1 = split(/\./, $_[0]); 155 my $op = $_[1]; 156 my @ver2 = split(/\./, $_[2]); 157 158 push @ver2, ("0") x $#ver1 - $#ver2; 159 push @ver1, ("0") x $#ver2 - $#ver1; 160 161 my $diff = 0; 162 while (@ver1 || @ver2) { 163 if (($diff = shift(@ver1) - shift(@ver2)) != 0) { 164 last; 165 } 166 } 167 return (eval "$diff $op 0" ? 1 : 0); 168} 169 170## ProcFile(FullPath, RelPath, File, Class, Type, Verdef) 171# 172# Determine whether this a ELF dynamic object and if so investigate its runtime 173# attributes. 174# 175sub ProcFile { 176 my($FullPath, $RelPath, $Class, $Type, $Verdef) = @_; 177 my(@Elf, @Ldd, $Dyn, $Sym, $Stack); 178 my($Sun, $Relsz, $Pltsz, $Tex, $Stab, $Strip, $Lddopt, $SymSort); 179 my($Val, $Header, $IsX86, $RWX, $UnDep); 180 my($HasDirectBinding); 181 182 # Only look at executables and sharable objects 183 return if ($Type ne 'EXEC') && ($Type ne 'DYN'); 184 185 # Ignore symbolic links 186 return if -l $FullPath; 187 188 # Is this an object or directory hierarchy we don't care about? 189 return if (defined($EXRE_skip) && ($RelPath =~ $EXRE_skip)); 190 191 # Bail if we can't stat the file. Otherwise, note if it is SUID/SGID. 192 return if !stat($FullPath); 193 my $Secure = (-u _ || -g _) ? 1 : 0; 194 195 # Reset output message counts for new input file 196 $$ErrTtl = $$InfoTtl = 0; 197 198 @Ldd = 0; 199 200 # Determine whether we have access to inspect the file. 201 if (!(-r $FullPath)) { 202 onbld_elfmod::OutMsg($ErrFH, $ErrTtl, $RelPath, 203 "unable to inspect file: permission denied"); 204 return; 205 } 206 207 # Determine whether we have a executable (static or dynamic) or a 208 # shared object. 209 @Elf = split(/\n/, `elfdump -epdcy $FullPath 2>&1`); 210 211 $Dyn = $Stack = $IsX86 = $RWX = 0; 212 $Header = 'None'; 213 foreach my $Line (@Elf) { 214 # If we have an invalid file type (which we can tell from the 215 # first line), or we're processing an archive, bail. 216 if ($Header eq 'None') { 217 if (($Line =~ /invalid file/) || 218 ($Line =~ /\Q$FullPath\E(.*):/)) { 219 return; 220 } 221 } 222 223 if ($Line =~ /^ELF Header/) { 224 $Header = 'Ehdr'; 225 next; 226 } 227 228 if ($Line =~ /^Program Header/) { 229 $Header = 'Phdr'; 230 $RWX = 0; 231 next; 232 } 233 234 if ($Line =~ /^Dynamic Section/) { 235 # A dynamic section indicates we're a dynamic object 236 # (this makes sure we don't check static executables). 237 $Dyn = 1; 238 next; 239 } 240 241 if (($Header eq 'Ehdr') && ($Line =~ /e_machine:/)) { 242 # If it's a X86 object, we need to enforce RW- data. 243 $IsX86 = 1 if $Line =~ /(EM_AMD64|EM_386)/; 244 next; 245 } 246 247 if (($Header eq 'Phdr') && 248 ($Line =~ /\[ PF_X\s+PF_W\s+PF_R \]/)) { 249 # RWX segment seen. 250 $RWX = 1; 251 next; 252 } 253 254 if (($Header eq 'Phdr') && 255 ($Line =~ /\[ PT_LOAD \]/ && $RWX && $IsX86)) { 256 # Seen an RWX PT_LOAD segment. 257 if (!defined($EXRE_exec_data) || 258 ($RelPath !~ $EXRE_exec_data)) { 259 onbld_elfmod::OutMsg($ErrFH, $ErrTtl, $RelPath, 260 "application requires non-executable " . 261 "data\t<no -Mmapfile_noexdata?>"); 262 } 263 next; 264 } 265 266 if (($Header eq 'Phdr') && ($Line =~ /\[ PT_SUNWSTACK \]/)) { 267 # This object defines a non-executable stack. 268 $Stack = 1; 269 next; 270 } 271 } 272 273 # Determine whether this ELF executable or shared object has a 274 # conforming mcs(1) comment section. If the correct $(POST_PROCESS) 275 # macros are used, only a 3 or 4 line .comment section should exist 276 # containing one or two "@(#)SunOS" identifying comments (one comment 277 # for a non-debug build, and two for a debug build). The results of 278 # the following split should be three or four lines, the last empty 279 # line being discarded by the split. 280 if ($opt{m}) { 281 my(@Mcs, $Con, $Dev); 282 283 @Mcs = split(/\n/, `mcs -p $FullPath 2>&1`); 284 285 $Con = $Dev = $Val = 0; 286 foreach my $Line (@Mcs) { 287 $Val++; 288 289 if (($Val == 3) && ($Line !~ /^@\(#\)SunOS/)) { 290 $Con = 1; 291 last; 292 } 293 if (($Val == 4) && ($Line =~ /^@\(#\)SunOS/)) { 294 $Dev = 1; 295 next; 296 } 297 if (($Dev == 0) && ($Val == 4)) { 298 $Con = 1; 299 last; 300 } 301 if (($Dev == 1) && ($Val == 5)) { 302 $Con = 1; 303 last; 304 } 305 } 306 if ($opt{m} && ($Con == 1)) { 307 onbld_elfmod::OutMsg($ErrFH, $ErrTtl, $RelPath, 308 "non-conforming mcs(1) comment\t<no \$(POST_PROCESS)?>"); 309 } 310 } 311 312 # Applications should contain a non-executable stack definition. 313 if (($Type eq 'EXEC') && ($Stack == 0) && 314 (!defined($EXRE_exec_stack) || ($RelPath !~ $EXRE_exec_stack))) { 315 onbld_elfmod::OutMsg($ErrFH, $ErrTtl, $RelPath, 316 "non-executable stack required\t<no -Mmapfile_noexstk?>"); 317 } 318 319 # Having caught any static executables in the mcs(1) check and non- 320 # executable stack definition check, continue with dynamic objects 321 # from now on. 322 if ($Dyn eq 0) { 323 return; 324 } 325 326 # Use ldd unless its a 64-bit object and we lack the hardware. 327 if (($Class == 32) || $Ena64) { 328 my $LDDFullPath = $FullPath; 329 330 if ($Secure) { 331 # The execution of a secure application over an nfs file 332 # system mounted nosuid will result in warning messages 333 # being sent to /var/adm/messages. As this type of 334 # environment can occur with root builds, move the file 335 # being investigated to a safe place first. In addition 336 # remove its secure permission so that it can be 337 # influenced by any alternative dependency mappings. 338 339 my $File = $RelPath; 340 $File =~ s!^.*/!!; # basename 341 342 my($TmpPath) = "$Tmpdir/$File"; 343 344 system('cp', $LDDFullPath, $TmpPath); 345 chmod 0777, $TmpPath; 346 $LDDFullPath = $TmpPath; 347 } 348 349 # Use ldd(1) to determine the objects relocatability and use. 350 # By default look for all unreferenced dependencies. However, 351 # some objects have legitimate dependencies that they do not 352 # reference. 353 if ($LddNoU) { 354 $Lddopt = "-ru"; 355 } else { 356 $Lddopt = "-rU"; 357 } 358 @Ldd = split(/\n/, `ldd $Lddopt $Env $LDDFullPath 2>&1`); 359 if ($Secure) { 360 unlink $LDDFullPath; 361 } 362 } 363 364 $Val = 0; 365 $Sym = 5; 366 $UnDep = 1; 367 368 foreach my $Line (@Ldd) { 369 370 if ($Val == 0) { 371 $Val = 1; 372 # Make sure ldd(1) worked. One possible failure is that 373 # this is an old ldd(1) prior to -e addition (4390308). 374 if ($Line =~ /usage:/) { 375 $Line =~ s/$/\t<old ldd(1)?>/; 376 onbld_elfmod::OutMsg($ErrFH, $ErrTtl, 377 $RelPath, $Line); 378 last; 379 } elsif ($Line =~ /execution failed/) { 380 onbld_elfmod::OutMsg($ErrFH, $ErrTtl, 381 $RelPath, $Line); 382 last; 383 } 384 385 # It's possible this binary can't be executed, ie. we've 386 # found a sparc binary while running on an intel system, 387 # or a sparcv9 binary on a sparcv7/8 system. 388 if ($Line =~ /wrong class/) { 389 onbld_elfmod::OutMsg($ErrFH, $ErrTtl, $RelPath, 390 "has wrong class or data encoding"); 391 next; 392 } 393 394 # Historically, ldd(1) likes executable objects to have 395 # their execute bit set. 396 if ($Line =~ /not executable/) { 397 onbld_elfmod::OutMsg($ErrFH, $ErrTtl, $RelPath, 398 "is not executable"); 399 next; 400 } 401 } 402 403 # Look for "file" or "versions" that aren't found. Note that 404 # these lines will occur before we find any symbol referencing 405 # errors. 406 if (($Sym == 5) && ($Line =~ /not found\)/)) { 407 if ($Line =~ /file not found\)/) { 408 $Line =~ s/$/\t<no -zdefs?>/; 409 } 410 onbld_elfmod::OutMsg($ErrFH, $ErrTtl, $RelPath, $Line); 411 next; 412 } 413 # Look for relocations whose symbols can't be found. Note, we 414 # only print out the first 5 relocations for any file as this 415 # output can be excessive. 416 if ($Sym && ($Line =~ /symbol not found/)) { 417 # Determine if this file is allowed undefined 418 # references. 419 if (($Sym == 5) && defined($EXRE_undef_ref) && 420 ($RelPath =~ $EXRE_undef_ref)) { 421 $Sym = 0; 422 next; 423 } 424 if ($Sym-- == 1) { 425 onbld_elfmod::OutMsg($ErrFH, $ErrTtl, $RelPath, 426 "continued ...") if !$opt{o}; 427 next; 428 } 429 # Just print the symbol name. 430 $Line =~ s/$/\t<no -zdefs?>/; 431 onbld_elfmod::OutMsg($ErrFH, $ErrTtl, $RelPath, $Line); 432 next; 433 } 434 # Look for any unused search paths. 435 if ($Line =~ /unused search path=/) { 436 next if defined($EXRE_unused_rpath) && 437 ($Line =~ $EXRE_unused_rpath); 438 439 if ($Secure) { 440 $Line =~ s!$Tmpdir/!!; 441 } 442 $Line =~ s/^[ \t]*(.*)/\t$1\t<remove search path?>/; 443 onbld_elfmod::OutMsg($ErrFH, $ErrTtl, $RelPath, $Line); 444 next; 445 } 446 # Look for unreferenced dependencies. Note, if any unreferenced 447 # objects are ignored, then set $UnDep so as to suppress any 448 # associated unused-object messages. 449 if ($Line =~ /unreferenced object=/) { 450 if (defined($EXRE_unref_obj) && 451 ($Line =~ $EXRE_unref_obj)) { 452 $UnDep = 0; 453 next; 454 } 455 if ($Secure) { 456 $Line =~ s!$Tmpdir/!!; 457 } 458 $Line =~ s/^[ \t]*(.*)/$1\t<remove lib or -zignore?>/; 459 onbld_elfmod::OutMsg($ErrFH, $ErrTtl, $RelPath, $Line); 460 next; 461 } 462 # Look for any unused dependencies. 463 if ($UnDep && ($Line =~ /unused/)) { 464 # Skip if object is allowed to have unused dependencies 465 next if defined($EXRE_unused_deps) && 466 ($RelPath =~ $EXRE_unused_deps); 467 468 # Skip if dependency is always allowed to be unused 469 next if defined($EXRE_unused_obj) && 470 ($Line =~ $EXRE_unused_obj); 471 472 $Line =~ s!$Tmpdir/!! if $Secure; 473 $Line =~ s/^[ \t]*(.*)/$1\t<remove lib or -zignore?>/; 474 onbld_elfmod::OutMsg($ErrFH, $ErrTtl, $RelPath, $Line); 475 next; 476 } 477 } 478 479 # Reuse the elfdump(1) data to investigate additional dynamic linking 480 # information. 481 482 $Sun = $Relsz = $Pltsz = $Dyn = $Stab = $SymSort = 0; 483 $Tex = $Strip = 1; 484 $HasDirectBinding = 0; 485 486 $Header = 'None'; 487ELF: foreach my $Line (@Elf) { 488 # We're only interested in the section headers and the dynamic 489 # section. 490 if ($Line =~ /^Section Header/) { 491 $Header = 'Shdr'; 492 493 if (($Sun == 0) && ($Line =~ /\.SUNW_reloc/)) { 494 # This object has a combined relocation section. 495 $Sun = 1; 496 497 } elsif (($Stab == 0) && ($Line =~ /\.stab/)) { 498 # This object contain .stabs sections 499 $Stab = 1; 500 } elsif (($SymSort == 0) && 501 ($Line =~ /\.SUNW_dyn(sym)|(tls)sort/)) { 502 # This object contains a symbol sort section 503 $SymSort = 1; 504 } 505 506 if (($Strip == 1) && ($Line =~ /\.symtab/)) { 507 # This object contains a complete symbol table. 508 $Strip = 0; 509 } 510 next; 511 512 } elsif ($Line =~ /^Dynamic Section/) { 513 $Header = 'Dyn'; 514 next; 515 } elsif ($Line =~ /^Syminfo Section/) { 516 $Header = 'Syminfo'; 517 next; 518 } elsif (($Header ne 'Dyn') && ($Header ne 'Syminfo')) { 519 next; 520 } 521 522 # Look into the Syminfo section. 523 # Does this object have at least one Directly Bound symbol? 524 if (($Header eq 'Syminfo')) { 525 my(@Symword); 526 527 if ($HasDirectBinding == 1) { 528 next; 529 } 530 531 @Symword = split(' ', $Line); 532 533 if (!defined($Symword[1])) { 534 next; 535 } 536 if ($Symword[1] =~ /B/) { 537 $HasDirectBinding = 1; 538 } 539 next; 540 } 541 542 # Does this object contain text relocations. 543 if ($Tex && ($Line =~ /TEXTREL/)) { 544 # Determine if this file is allowed text relocations. 545 if (defined($EXRE_textrel) && 546 ($RelPath =~ $EXRE_textrel)) { 547 $Tex = 0; 548 next ELF; 549 } 550 onbld_elfmod::OutMsg($ErrFH, $ErrTtl, $RelPath, 551 "TEXTREL .dynamic tag\t\t\t<no -Kpic?>"); 552 $Tex = 0; 553 next; 554 } 555 556 # Does this file have any relocation sections (there are a few 557 # psr libraries with no relocations at all, thus a .SUNW_reloc 558 # section won't exist either). 559 if (($Relsz == 0) && ($Line =~ / RELA?SZ/)) { 560 $Relsz = hex((split(' ', $Line))[2]); 561 next; 562 } 563 564 # Does this file have any plt relocations. If the plt size is 565 # equivalent to the total relocation size then we don't have 566 # any relocations suitable for combining into a .SUNW_reloc 567 # section. 568 if (($Pltsz == 0) && ($Line =~ / PLTRELSZ/)) { 569 $Pltsz = hex((split(' ', $Line))[2]); 570 next; 571 } 572 573 # Does this object have any dependencies. 574 if ($Line =~ /NEEDED/) { 575 my($Need) = (split(' ', $Line))[3]; 576 577 if (defined($EXRE_olddep) && ($Need =~ $EXRE_olddep)) { 578 # Catch any old (unnecessary) dependencies. 579 onbld_elfmod::OutMsg($ErrFH, $ErrTtl, $RelPath, 580 "NEEDED=$Need\t<dependency no longer necessary>"); 581 } elsif ($opt{i}) { 582 # Under the -i (information) option print out 583 # any useful dynamic entries. 584 onbld_elfmod::OutMsg($InfoFH, $InfoTtl, $RelPath, 585 "NEEDED=$Need"); 586 } 587 next; 588 } 589 590 # Is this object built with -B direct flag on? 591 if ($Line =~ / DIRECT /) { 592 $HasDirectBinding = 1; 593 } 594 595 # Does this object specify a runpath. 596 if ($opt{i} && ($Line =~ /RPATH/)) { 597 my($Rpath) = (split(' ', $Line))[3]; 598 onbld_elfmod::OutMsg($InfoFH, $InfoTtl, 599 $RelPath, "RPATH=$Rpath"); 600 next; 601 } 602 } 603 604 # A shared object, that contains non-plt relocations, should have a 605 # combined relocation section indicating it was built with -z combreloc. 606 if (($Type eq 'DYN') && $Relsz && ($Relsz != $Pltsz) && ($Sun == 0)) { 607 onbld_elfmod::OutMsg($ErrFH, $ErrTtl, $RelPath, 608 ".SUNW_reloc section missing\t\t<no -zcombreloc?>"); 609 } 610 611 # No objects released to a customer should have any .stabs sections 612 # remaining, they should be stripped. 613 if ($opt{s} && $Stab) { 614 goto DONESTAB if defined($EXRE_stab) && ($RelPath =~ $EXRE_stab); 615 616 onbld_elfmod::OutMsg($ErrFH, $ErrTtl, $RelPath, 617 "debugging sections should be deleted\t<no strip -x?>"); 618 } 619 620 # Identify an object that is not built with either -B direct or 621 # -z direct. 622 goto DONESTAB 623 if (defined($EXRE_nodirect) && ($RelPath =~ $EXRE_nodirect)); 624 625 if ($Relsz && ($HasDirectBinding == 0)) { 626 onbld_elfmod::OutMsg($ErrFH, $ErrTtl, $RelPath, 627 "object has no direct bindings\t<no -B direct or -z direct?>"); 628 } 629 630DONESTAB: 631 632 # All objects should have a full symbol table to provide complete 633 # debugging stack traces. 634 onbld_elfmod::OutMsg($ErrFH, $ErrTtl, $RelPath, 635 "symbol table should not be stripped\t<remove -s?>") if $Strip; 636 637 # If there are symbol sort sections in this object, report on 638 # any that have duplicate addresses. 639 ProcSymSort($FullPath, $RelPath) if $SymSort; 640 641 # If -v was specified, and the object has a version definition 642 # section, generate output showing each public symbol and the 643 # version it belongs to. 644 ProcVerdef($FullPath, $RelPath) 645 if ($Verdef eq 'VERDEF') && $opt{v}; 646} 647 648 649## ProcSymSortOutMsg(RelPath, secname, addr, names...) 650# 651# Call onbld_elfmod::OutMsg for a duplicate address error in a symbol sort 652# section 653# 654sub ProcSymSortOutMsg { 655 my($RelPath, $secname, $addr, @names) = @_; 656 657 onbld_elfmod::OutMsg($ErrFH, $ErrTtl, $RelPath, 658 "$secname: duplicate $addr: ". join(', ', @names)); 659} 660 661 662## ProcSymSort(FullPath, RelPath) 663# 664# Examine the symbol sort sections for the given object and report 665# on any duplicate addresses found. Ideally, mapfile directives 666# should be used when building objects that have multiple symbols 667# with the same address so that only one of them appears in the sort 668# section. This saves space, reduces user confusion, and ensures that 669# libproc and debuggers always display public names instead of symbols 670# that are merely implementation details. 671# 672sub ProcSymSort { 673 674 my($FullPath, $RelPath) = @_; 675 676 # If this object is exempt from checking, return quietly 677 return if defined($EXRE_nosymsort) && ($FullPath =~ $EXRE_nosymsort); 678 679 680 open(SORT, "elfdump -S $FullPath|") || 681 die "$Prog: Unable to execute elfdump (symbol sort sections)\n"; 682 683 my $line; 684 my $last_addr; 685 my @dups = (); 686 my $secname; 687 while ($line = <SORT>) { 688 chomp $line; 689 690 next if ($line eq ''); 691 692 # If this is a header line, pick up the section name 693 if ($line =~ /^Symbol Sort Section:\s+([^\s]+)\s+/) { 694 $secname = $1; 695 696 # Every new section is followed by a column header line 697 $line = <SORT>; # Toss header line 698 699 # Flush anything left from previous section 700 ProcSymSortOutMsg($RelPath, $secname, $last_addr, @dups) 701 if (scalar(@dups) > 1); 702 703 # Reset variables for new sort section 704 $last_addr = ''; 705 @dups = (); 706 707 next; 708 } 709 710 # Process symbol line 711 my @fields = split /\s+/, $line; 712 my $new_addr = $fields[2]; 713 my $new_type = $fields[8]; 714 my $new_name = $fields[9]; 715 716 if ($new_type eq 'UNDEF') { 717 onbld_elfmod::OutMsg($ErrFH, $ErrTtl, $RelPath, 718 "$secname: unexpected UNDEF symbol " . 719 "(link-editor error): $new_name"); 720 next; 721 } 722 723 if ($new_addr eq $last_addr) { 724 push @dups, $new_name; 725 } else { 726 ProcSymSortOutMsg($RelPath, $secname, 727 $last_addr, @dups) if (scalar(@dups) > 1); 728 @dups = ( $new_name ); 729 $last_addr = $new_addr; 730 } 731 } 732 733 ProcSymSortOutMsg($RelPath, $secname, $last_addr, @dups) 734 if (scalar(@dups) > 1); 735 736 close SORT; 737} 738 739 740## ProcVerdef(FullPath, RelPath) 741# 742# Examine the version definition section for the given object and report 743# each public symbol along with the version it belongs to. 744# 745sub ProcVerdef { 746 747 my($FullPath, $RelPath) = @_; 748 my $line; 749 my $cur_ver = ''; 750 my $tab = $opt{o} ? '' : "\t"; 751 752 # pvs -dov provides information about the versioning hierarchy 753 # in the file. Lines are of the format: 754 # path - version[XXX]; 755 # where [XXX] indicates optional information, such as flags 756 # or inherited versions. 757 # 758 # Private versions are allowed to change freely, so ignore them. 759 open(PVS, "pvs -dov $FullPath|") || 760 die "$Prog: Unable to execute pvs (version definition section)\n"; 761 762 while ($line = <PVS>) { 763 chomp $line; 764 765 if ($line =~ /^[^\s]+\s+-\s+([^;]+)/) { 766 my $ver = $1; 767 768 next if $ver =~ /private/i; 769 onbld_elfmod::OutMsg($InfoFH, $InfoTtl, $RelPath, 770 "${tab}VERDEF=$ver"); 771 } 772 } 773 close PVS; 774 775 # pvs -dos lists the symbols assigned to each version definition. 776 # Lines are of the format: 777 # path - version: symbol; 778 # path - version: symbol (size); 779 # where the (size) is added to data items, but not for functions. 780 # We strip off the size, if present. 781 782 open(PVS, "pvs -dos $FullPath|") || 783 die "$Prog: Unable to execute pvs (version definition section)\n"; 784 while ($line = <PVS>) { 785 chomp $line; 786 if ($line =~ /^[^\s]+\s+-\s+([^:]+):\s*([^\s;]+)/) { 787 my $ver = $1; 788 my $sym = $2; 789 790 next if $ver =~ /private/i; 791 792 if ($opt{o}) { 793 onbld_elfmod::OutMsg($InfoFH, $InfoTtl, $RelPath, 794 "VERSION=$ver, SYMBOL=$sym"); 795 } else { 796 if ($cur_ver ne $ver) { 797 onbld_elfmod::OutMsg($InfoFH, $InfoTtl, 798 $RelPath, "VERSION=$ver"); 799 $cur_ver = $ver; 800 } 801 onbld_elfmod::OutMsg($InfoFH, $InfoTtl, 802 $RelPath, "SYMBOL=$sym"); 803 } 804 } 805 } 806 807 close PVS; 808} 809 810 811## OpenFindElf(file, FileHandleRef, LineNumRef) 812# 813# Open file in 'find_elf -r' format, and return the value of 814# the opening PREFIX line. 815# 816# entry: 817# file - file, or find_elf child process, to open 818# FileHandleRef - Reference to file handle to open 819# LineNumRef - Reference to integer to increment as lines are input 820# 821# exit: 822# This routine issues a fatal error and does not return on error. 823# Otherwise, the value of PREFIX is returned. 824# 825sub OpenFindElf { 826 my ($file, $fh, $LineNum) = @_; 827 my $line; 828 my $prefix; 829 830 open($fh, $file) || die "$Prog: Unable to open: $file"; 831 $$LineNum = 0; 832 833 # This script requires relative paths as created by 'find_elf -r'. 834 # When this is done, the first non-comment line will always 835 # be PREFIX. Obtain that line, or issue a fatal error. 836 while ($line = onbld_elfmod::GetLine($fh, $LineNum)) { 837 if ($line =~ /^PREFIX\s+(.*)$/i) { 838 $prefix = $1; 839 last; 840 } 841 842 die "$Prog: No PREFIX line seen on line $$LineNum: $file"; 843 } 844 845 $prefix; 846} 847 848 849## ProcFindElf(file) 850# 851# Open the specified file, which must be produced by "find_elf -r", 852# and process the files it describes. 853# 854sub ProcFindElf { 855 my $file = $_[0]; 856 my $line; 857 my $LineNum; 858 859 my $prefix = OpenFindElf($file, \*FIND_ELF, \$LineNum); 860 861 while ($line = onbld_elfmod::GetLine(\*FIND_ELF, \$LineNum)) { 862 next if !($line =~ /^OBJECT\s/i); 863 864 my ($item, $class, $type, $verdef, $obj) = 865 split(/\s+/, $line, 5); 866 867 ProcFile("$prefix/$obj", $obj, $class, $type, $verdef); 868 } 869 870 close FIND_ELF; 871} 872 873 874## AltObjectConfig(file) 875# 876# Recurse through a directory hierarchy looking for appropriate dependencies 877# to map from their standard system locations to the proto area via a crle 878# config file. 879# 880# entry: 881# file - File of ELF objects, in 'find_elf -r' format, to examine. 882# 883# exit: 884# Scripts are generated for the 32 and 64-bit cases to run crle 885# and create runtime configuration files that will establish 886# alternative dependency mappings for the objects identified. 887# 888# $Env - Set to environment variable definitions that will cause 889# the config files generated by this routine to be used 890# by ldd. 891# $Conf32, $Conf64 - Undefined, or set to the config files generated 892# by this routine. If defined, the caller is responsible for 893# unlinking the files before exiting. 894# 895sub AltObjectConfig { 896 my $file = $_[0]; 897 my ($Crle32, $Crle64); 898 my $line; 899 my $LineNum; 900 my $obj_path; 901 my $obj_active = 0; 902 my $obj_class; 903 904 my $prefix = OpenFindElf($file, \*FIND_ELF); 905 906LINE: 907 while ($line = onbld_elfmod::GetLine(\*FIND_ELF, \$LineNum)) { 908 ITEM: { 909 910 if ($line =~ /^OBJECT\s/i) { 911 my ($item, $class, $type, $verdef, $obj) = 912 split(/\s+/, $line, 5); 913 914 if ($type eq 'DYN') { 915 $obj_active = 1; 916 $obj_path = $obj; 917 $obj_class = $class; 918 } else { 919 # Only want sharable objects 920 $obj_active = 0; 921 } 922 last ITEM; 923 } 924 925 # We need to follow links to sharable objects so 926 # that any dependencies are expressed in all their 927 # available forms. We depend on ALIAS lines directly 928 # following the object they alias, so if we have 929 # a current object, this alias belongs to it. 930 if ($obj_active && ($line =~ /^ALIAS\s/i)) { 931 my ($item, $real_obj, $obj) = 932 split(/\s+/, $line, 3); 933 $obj_path = $obj; 934 last ITEM; 935 } 936 937 # Skip unrecognized item 938 next LINE; 939 } 940 941 next if !$obj_active; 942 943 my $full = "$prefix/$obj_path"; 944 945 next if defined($EXRE_nocrlealt) && 946 ($obj_path =~ $EXRE_nocrlealt); 947 948 my $Dir = $full; 949 $Dir =~ s/^(.*)\/.*$/$1/; 950 951 # Create a crle(1) script for the dependency we've found. 952 # We build separate scripts for the 32 and 64-bit cases. 953 # We create and initialize each script when we encounter 954 # the first object that needs it. 955 if ($obj_class == 32) { 956 if (!$Crle32) { 957 $Crle32 = "$Tmpdir/$Prog.crle32.$$"; 958 open(CRLE32, "> $Crle32") || 959 die "$Prog: open failed: $Crle32: $!"; 960 print CRLE32 "#!/bin/sh\ncrle \\\n"; 961 } 962 print CRLE32 "\t-o $Dir -a /$obj_path \\\n"; 963 } elsif ($Ena64) { 964 if (!$Crle64) { 965 $Crle64 = "$Tmpdir/$Prog.crle64.$$"; 966 open(CRLE64, "> $Crle64") || 967 die "$Prog: open failed: $Crle64: $!"; 968 print CRLE64 "#!/bin/sh\ncrle -64\\\n"; 969 } 970 print CRLE64 "\t-o $Dir -a /$obj_path \\\n"; 971 } 972 } 973 974 close FIND_ELF; 975 976 977 # Now that the config scripts are complete, use them to generate 978 # runtime linker config files. 979 if ($Crle64) { 980 $Conf64 = "$Tmpdir/$Prog.conf64.$$"; 981 print CRLE64 "\t-c $Conf64\n"; 982 983 chmod 0755, $Crle64; 984 close CRLE64; 985 986 undef $Conf64 if system($Crle64); 987 988 # Done with the script 989 unlink $Crle64; 990 } 991 if ($Crle32) { 992 $Conf32 = "$Tmpdir/$Prog.conf32.$$"; 993 print CRLE32 "\t-c $Conf32\n"; 994 995 chmod 0755, $Crle32; 996 close CRLE32; 997 998 undef $Conf32 if system($Crle32); 999 1000 # Done with the script 1001 unlink $Crle32; 1002 } 1003 1004 # Set $Env so that we will use the config files generated above 1005 # when we run ldd. 1006 if ($Crle64 && $Conf64 && $Crle32 && $Conf32) { 1007 $Env = "-e LD_FLAGS=config_64=$Conf64,config_32=$Conf32"; 1008 } elsif ($Crle64 && $Conf64) { 1009 $Env = "-e LD_FLAGS=config_64=$Conf64"; 1010 } elsif ($Crle32 && $Conf32) { 1011 $Env = "-e LD_FLAGS=config_32=$Conf32"; 1012 } 1013} 1014 1015# ----------------------------------------------------------------------------- 1016 1017# This script relies on ldd returning output reflecting only the binary 1018# contents. But if LD_PRELOAD* environment variables are present, libraries 1019# named by them will also appear in the output, disrupting our analysis. 1020# So, before we get too far, scrub the environment. 1021 1022delete($ENV{LD_PRELOAD}); 1023delete($ENV{LD_PRELOAD_32}); 1024delete($ENV{LD_PRELOAD_64}); 1025 1026# Establish a program name for any error diagnostics. 1027chomp($Prog = `basename $0`); 1028 1029# The onbld_elfmod package is maintained in the same directory as this 1030# script, and is installed in ../lib/perl. Use the local one if present, 1031# and the installed one otherwise. 1032my $moddir = dirname($0); 1033$moddir = "$moddir/../lib/perl" if ! -f "$moddir/onbld_elfmod.pm"; 1034require "$moddir/onbld_elfmod.pm"; 1035 1036# Determine what machinery is available. 1037my $Mach = `uname -p`; 1038my$Isalist = `isalist`; 1039if ($Mach =~ /sparc/) { 1040 if ($Isalist =~ /sparcv9/) { 1041 $Ena64 = "ok"; 1042 } 1043} elsif ($Mach =~ /i386/) { 1044 if ($Isalist =~ /amd64/) { 1045 $Ena64 = "ok"; 1046 } 1047} 1048 1049# $Env is used with all calls to ldd. It is set by AltObjectConfig to 1050# cause an alternate object mapping runtime config file to be used. 1051$Env = ''; 1052 1053# Check that we have arguments. 1054if ((getopts('D:d:E:e:f:I:imosvw:', \%opt) == 0) || 1055 (!$opt{f} && ($#ARGV == -1))) { 1056 print "usage: $Prog [-imosv] [-D depfile | -d depdir] [-E errfile]\n"; 1057 print "\t\t[-e exfile] [-f listfile] [-I infofile] [-w outdir]\n"; 1058 print "\t\t[file | dir]...\n"; 1059 print "\n"; 1060 print "\t[-D depfile]\testablish dependencies from 'find_elf -r' file list\n"; 1061 print "\t[-d depdir]\testablish dependencies from under directory\n"; 1062 print "\t[-E errfile]\tdirect error output to file\n"; 1063 print "\t[-e exfile]\texceptions file\n"; 1064 print "\t[-f listfile]\tuse file list produced by find_elf -r\n"; 1065 print "\t[-I infofile]\tdirect informational output (-i, -v) to file\n"; 1066 print "\t[-i]\t\tproduce dynamic table entry information\n"; 1067 print "\t[-m]\t\tprocess mcs(1) comments\n"; 1068 print "\t[-o]\t\tproduce one-liner output (prefixed with pathname)\n"; 1069 print "\t[-s]\t\tprocess .stab and .symtab entries\n"; 1070 print "\t[-v]\t\tprocess version definition entries\n"; 1071 print "\t[-w outdir]\tinterpret all files relative to given directory\n"; 1072 exit 1; 1073} 1074 1075die "$Prog: -D and -d options are mutually exclusive\n" if ($opt{D} && $opt{d}); 1076 1077$Tmpdir = "/tmp" if (!($Tmpdir = $ENV{TMPDIR}) || (! -d $Tmpdir)); 1078 1079# If -w, change working directory to given location 1080!$opt{w} || chdir($opt{w}) || die "$Prog: can't cd to $opt{w}"; 1081 1082# Locate and process the exceptions file 1083onbld_elfmod::LoadExceptionsToEXRE('check_rtime'); 1084 1085# Is there a proto area available, either via the -d option, or because 1086# we are part of an activated workspace? 1087my $Proto; 1088if ($opt{d}) { 1089 # User specified dependency directory - make sure it exists. 1090 -d $opt{d} || die "$Prog: $opt{d} is not a directory\n"; 1091 $Proto = $opt{d}; 1092} elsif ($ENV{CODEMGR_WS}) { 1093 my $Root; 1094 1095 # Without a user specified dependency directory see if we're 1096 # part of a codemanager workspace and if a proto area exists. 1097 $Proto = $Root if ($Root = $ENV{ROOT}) && (-d $Root); 1098} 1099 1100# If we are basing this analysis off the sharable objects found in 1101# a proto area, then gather dependencies and construct an alternative 1102# dependency mapping via a crle(1) configuration file. 1103# 1104# To support alternative dependency mapping we'll need ldd(1)'s 1105# -e option. This is relatively new (s81_30), so make sure 1106# ldd(1) is capable before gathering any dependency information. 1107if ($opt{D} || $Proto) { 1108 if (system('ldd -e /usr/lib/lddstub 2> /dev/null')) { 1109 print "ldd: does not support -e, unable to "; 1110 print "create alternative dependency mappingings.\n"; 1111 print "ldd: option added under 4390308 (s81_30).\n\n"; 1112 } else { 1113 # If -D was specified, it supplies a list of files in 1114 # 'find_elf -r' format, and can use it directly. Otherwise, 1115 # we will run find_elf as a child process to find the 1116 # sharable objects found under $Proto. 1117 AltObjectConfig($opt{D} ? $opt{D} : "find_elf -frs $Proto|"); 1118 } 1119} 1120 1121# To support unreferenced dependency detection we'll need ldd(1)'s -U 1122# option. This is relatively new (4638070), and if not available we 1123# can still fall back to -u. Even with this option, don't use -U with 1124# releases prior to 5.10 as the cleanup for -U use only got integrated 1125# into 5.10 under 4642023. Note, that nightly doesn't typically set a 1126# RELEASE from the standard <env> files. Users who wish to disable use 1127# of ldd(1)'s -U should set (or uncomment) RELEASE in their <env> file 1128# if using nightly, or otherwise establish it in their environment. 1129if (system('ldd -U /usr/lib/lddstub 2> /dev/null')) { 1130 $LddNoU = 1; 1131} else { 1132 my($Release); 1133 1134 if (($Release = $ENV{RELEASE}) && (cmp_os_ver($Release, "<", "5.10"))) { 1135 $LddNoU = 1; 1136 } else { 1137 $LddNoU = 0; 1138 } 1139} 1140 1141# Set up variables used to handle output files: 1142# 1143# Error messages go to stdout unless -E is specified. $ErrFH is a 1144# file handle reference that points at the file handle where error messages 1145# are sent, and $ErrTtl is a reference that points at an integer used 1146# to count how many lines have been sent there. 1147# 1148# Informational messages go to stdout unless -I is specified. $InfoFH is a 1149# file handle reference that points at the file handle where info messages 1150# are sent, and $InfoTtl is a reference that points at an integer used 1151# to count how many lines have been sent there. 1152# 1153if ($opt{E}) { 1154 open(ERROR, ">$opt{E}") || die "$Prog: open failed: $opt{E}"; 1155 $ErrFH = \*ERROR; 1156} else { 1157 $ErrFH = \*STDOUT; 1158} 1159 1160if ($opt{I}) { 1161 open(INFO, ">$opt{I}") || die "$Prog: open failed: $opt{I}"; 1162 $InfoFH = \*INFO; 1163} else { 1164 $InfoFH = \*STDOUT; 1165} 1166my ($err_dev, $err_ino) = stat($ErrFH); 1167my ($info_dev, $info_ino) = stat($InfoFH); 1168$ErrTtl = \$OutCnt1; 1169$InfoTtl = (($err_dev == $info_dev) && ($err_ino == $info_ino)) ? 1170 \$OutCnt1 : \$OutCnt2; 1171 1172 1173# If we were given a list of objects in 'find_elf -r' format, then 1174# process it. 1175ProcFindElf($opt{f}) if $opt{f}; 1176 1177# Process each argument 1178foreach my $Arg (@ARGV) { 1179 # Run find_elf to find the files given by $Arg and process them 1180 ProcFindElf("find_elf -fr $Arg|"); 1181} 1182 1183# Cleanup output files 1184unlink $Conf64 if $Conf64; 1185unlink $Conf32 if $Conf32; 1186close ERROR if $opt{E}; 1187close INFO if $opt{I}; 1188 1189exit 0; 1190