blob: 6e83f01f1488cf7c222166c30339a09931af90b1 [file] [log] [blame]
import stat
import mmap
import subprocess
def runstrip(arg):
# Function to strip a single file, called from split_and_strip_files below
# A working 'file' (one which works on the target architecture)
#
# The elftype is a bit pattern (explained in is_elf below) to tell
# us what type of file we're processing...
# 4 - executable
# 8 - shared library
# 16 - kernel module
(file, elftype, strip) = arg
newmode = None
if not os.access(file, os.W_OK) or os.access(file, os.R_OK):
origmode = os.stat(file)[stat.ST_MODE]
newmode = origmode | stat.S_IWRITE | stat.S_IREAD
os.chmod(file, newmode)
stripcmd = [strip]
skip_strip = False
# kernel module
if elftype & 16:
if is_kernel_module_signed(file):
bb.debug(1, "Skip strip on signed module %s" % file)
skip_strip = True
else:
stripcmd.extend(["--strip-debug", "--remove-section=.comment",
"--remove-section=.note", "--preserve-dates"])
# .so and shared library
elif ".so" in file and elftype & 8:
stripcmd.extend(["--remove-section=.comment", "--remove-section=.note", "--strip-unneeded"])
# shared or executable:
elif elftype & 8 or elftype & 4:
stripcmd.extend(["--remove-section=.comment", "--remove-section=.note"])
stripcmd.append(file)
bb.debug(1, "runstrip: %s" % stripcmd)
if not skip_strip:
output = subprocess.check_output(stripcmd, stderr=subprocess.STDOUT)
if newmode:
os.chmod(file, origmode)
# Detect .ko module by searching for "vermagic=" string
def is_kernel_module(path):
with open(path) as f:
return mmap.mmap(f.fileno(), 0, prot=mmap.PROT_READ).find(b"vermagic=") >= 0
# Detect if .ko module is signed
def is_kernel_module_signed(path):
with open(path, "rb") as f:
f.seek(-28, 2)
module_tail = f.read()
return "Module signature appended" in "".join(chr(c) for c in bytearray(module_tail))
# Return type (bits):
# 0 - not elf
# 1 - ELF
# 2 - stripped
# 4 - executable
# 8 - shared library
# 16 - kernel module
def is_elf(path):
exec_type = 0
result = subprocess.check_output(["file", "-b", path], stderr=subprocess.STDOUT).decode("utf-8")
if "ELF" in result:
exec_type |= 1
if "not stripped" not in result:
exec_type |= 2
if "executable" in result:
exec_type |= 4
if "shared" in result:
exec_type |= 8
if "relocatable" in result:
if path.endswith(".ko") and path.find("/lib/modules/") != -1 and is_kernel_module(path):
exec_type |= 16
return (path, exec_type)
def is_static_lib(path):
if path.endswith('.a') and not os.path.islink(path):
with open(path, 'rb') as fh:
# The magic must include the first slash to avoid
# matching golang static libraries
magic = b'!<arch>\x0a/'
start = fh.read(len(magic))
return start == magic
return False
def strip_execs(pn, dstdir, strip_cmd, libdir, base_libdir, d, qa_already_stripped=False):
"""
Strip executable code (like executables, shared libraries) _in_place_
- Based on sysroot_strip in staging.bbclass
:param dstdir: directory in which to strip files
:param strip_cmd: Strip command (usually ${STRIP})
:param libdir: ${libdir} - strip .so files in this directory
:param base_libdir: ${base_libdir} - strip .so files in this directory
:param qa_already_stripped: Set to True if already-stripped' in ${INSANE_SKIP}
This is for proper logging and messages only.
"""
import stat, errno, oe.path, oe.utils
elffiles = {}
inodes = {}
libdir = os.path.abspath(dstdir + os.sep + libdir)
base_libdir = os.path.abspath(dstdir + os.sep + base_libdir)
exec_mask = stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH
#
# First lets figure out all of the files we may have to process
#
checkelf = []
inodecache = {}
for root, dirs, files in os.walk(dstdir):
for f in files:
file = os.path.join(root, f)
try:
ltarget = oe.path.realpath(file, dstdir, False)
s = os.lstat(ltarget)
except OSError as e:
(err, strerror) = e.args
if err != errno.ENOENT:
raise
# Skip broken symlinks
continue
if not s:
continue
# Check its an excutable
if s[stat.ST_MODE] & exec_mask \
or ((file.startswith(libdir) or file.startswith(base_libdir)) and ".so" in f) \
or file.endswith('.ko'):
# If it's a symlink, and points to an ELF file, we capture the readlink target
if os.path.islink(file):
continue
# It's a file (or hardlink), not a link
# ...but is it ELF, and is it already stripped?
checkelf.append(file)
inodecache[file] = s.st_ino
results = oe.utils.multiprocess_launch(is_elf, checkelf, d)
for (file, elf_file) in results:
#elf_file = is_elf(file)
if elf_file & 1:
if elf_file & 2:
if qa_already_stripped:
bb.note("Skipping file %s from %s for already-stripped QA test" % (file[len(dstdir):], pn))
else:
bb.warn("File '%s' from %s was already stripped, this will prevent future debugging!" % (file[len(dstdir):], pn))
continue
if inodecache[file] in inodes:
os.unlink(file)
os.link(inodes[inodecache[file]], file)
else:
# break hardlinks so that we do not strip the original.
inodes[inodecache[file]] = file
bb.utils.break_hardlinks(file)
elffiles[file] = elf_file
#
# Now strip them (in parallel)
#
sfiles = []
for file in elffiles:
elf_file = int(elffiles[file])
sfiles.append((file, elf_file, strip_cmd))
oe.utils.multiprocess_launch(runstrip, sfiles, d)
def file_translate(file):
ft = file.replace("@", "@at@")
ft = ft.replace(" ", "@space@")
ft = ft.replace("\t", "@tab@")
ft = ft.replace("[", "@openbrace@")
ft = ft.replace("]", "@closebrace@")
ft = ft.replace("_", "@underscore@")
return ft
def filedeprunner(arg):
import re, subprocess, shlex
(pkg, pkgfiles, rpmdeps, pkgdest) = arg
provides = {}
requires = {}
file_re = re.compile(r'\s+\d+\s(.*)')
dep_re = re.compile(r'\s+(\S)\s+(.*)')
r = re.compile(r'[<>=]+\s+\S*')
def process_deps(pipe, pkg, pkgdest, provides, requires):
file = None
for line in pipe.split("\n"):
m = file_re.match(line)
if m:
file = m.group(1)
file = file.replace(pkgdest + "/" + pkg, "")
file = file_translate(file)
continue
m = dep_re.match(line)
if not m or not file:
continue
type, dep = m.groups()
if type == 'R':
i = requires
elif type == 'P':
i = provides
else:
continue
if dep.startswith("python("):
continue
# Ignore all perl(VMS::...) and perl(Mac::...) dependencies. These
# are typically used conditionally from the Perl code, but are
# generated as unconditional dependencies.
if dep.startswith('perl(VMS::') or dep.startswith('perl(Mac::'):
continue
# Ignore perl dependencies on .pl files.
if dep.startswith('perl(') and dep.endswith('.pl)'):
continue
# Remove perl versions and perl module versions since they typically
# do not make sense when used as package versions.
if dep.startswith('perl') and r.search(dep):
dep = dep.split()[0]
# Put parentheses around any version specifications.
dep = r.sub(r'(\g<0>)',dep)
if file not in i:
i[file] = []
i[file].append(dep)
return provides, requires
output = subprocess.check_output(shlex.split(rpmdeps) + pkgfiles, stderr=subprocess.STDOUT).decode("utf-8")
provides, requires = process_deps(output, pkg, pkgdest, provides, requires)
return (pkg, provides, requires)
def read_shlib_providers(d):
import re
shlib_provider = {}
shlibs_dirs = d.getVar('SHLIBSDIRS').split()
list_re = re.compile(r'^(.*)\.list$')
# Go from least to most specific since the last one found wins
for dir in reversed(shlibs_dirs):
bb.debug(2, "Reading shlib providers in %s" % (dir))
if not os.path.exists(dir):
continue
for file in os.listdir(dir):
m = list_re.match(file)
if m:
dep_pkg = m.group(1)
try:
fd = open(os.path.join(dir, file))
except IOError:
# During a build unrelated shlib files may be deleted, so
# handle files disappearing between the listdirs and open.
continue
lines = fd.readlines()
fd.close()
for l in lines:
s = l.strip().split(":")
if s[0] not in shlib_provider:
shlib_provider[s[0]] = {}
shlib_provider[s[0]][s[1]] = (dep_pkg, s[2])
return shlib_provider
def npm_split_package_dirs(pkgdir):
"""
Work out the packages fetched and unpacked by BitBake's npm fetcher
Returns a dict of packagename -> (relpath, package.json) ordered
such that it is suitable for use in PACKAGES and FILES
"""
from collections import OrderedDict
import json
packages = {}
for root, dirs, files in os.walk(pkgdir):
if os.path.basename(root) == 'node_modules':
for dn in dirs:
relpth = os.path.relpath(os.path.join(root, dn), pkgdir)
pkgitems = ['${PN}']
for pathitem in relpth.split('/'):
if pathitem == 'node_modules':
continue
pkgitems.append(pathitem)
pkgname = '-'.join(pkgitems).replace('_', '-')
pkgname = pkgname.replace('@', '')
pkgfile = os.path.join(root, dn, 'package.json')
data = None
if os.path.exists(pkgfile):
with open(pkgfile, 'r') as f:
data = json.loads(f.read())
packages[pkgname] = (relpth, data)
# We want the main package for a module sorted *after* its subpackages
# (so that it doesn't otherwise steal the files for the subpackage), so
# this is a cheap way to do that whilst still having an otherwise
# alphabetical sort
return OrderedDict((key, packages[key]) for key in sorted(packages, key=lambda pkg: pkg + '~'))