mirror of
git://git.yoctoproject.org/poky.git
synced 2025-07-19 21:09:03 +02:00
f85a4a1462
To exclude content from the rootfs, wic makes a copy (using hardlinks if possible) of the rootfs directory and associated pseudo db, then removes files & directories as needed. However if these files and directories are removed using the python functions os.remove and shutil.rmtree, the copied pseudo db will not be updated correctly. For files copied from the original rootfs, if hardlinks were used successfully when copying the rootfs this should mean that the relevant inodes can't be reused and so the risk of pseudo aborts should be avoided. However, this logic doesn't apply for directories (as they can't be hardlinked) or for files added via the '--include-path' argument (as they weren't present in the original rootfs) and so there remains some risk of inodes being reused and the pseudo db becoming corrupted. To fix this, use the 'rm' command under pseudo when removing files & directories from the copied rootfs to ensure that the copied pseudo db is updated. (From OE-Core rev: d5db7e268947f0392c2126137571a44acd29ccd6) Signed-off-by: Paul Barker <pbarker@konsulko.com> Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
220 lines
9.1 KiB
Python
220 lines
9.1 KiB
Python
#
|
|
# Copyright (c) 2014, Intel Corporation.
|
|
#
|
|
# SPDX-License-Identifier: GPL-2.0-only
|
|
#
|
|
# DESCRIPTION
|
|
# This implements the 'rootfs' source plugin class for 'wic'
|
|
#
|
|
# AUTHORS
|
|
# Tom Zanussi <tom.zanussi (at] linux.intel.com>
|
|
# Joao Henrique Ferreira de Freitas <joaohf (at] gmail.com>
|
|
#
|
|
|
|
import logging
|
|
import os
|
|
import shutil
|
|
import sys
|
|
|
|
from oe.path import copyhardlinktree
|
|
from pathlib import Path
|
|
|
|
from wic import WicError
|
|
from wic.pluginbase import SourcePlugin
|
|
from wic.misc import get_bitbake_var, exec_native_cmd
|
|
|
|
logger = logging.getLogger('wic')
|
|
|
|
class RootfsPlugin(SourcePlugin):
|
|
"""
|
|
Populate partition content from a rootfs directory.
|
|
"""
|
|
|
|
name = 'rootfs'
|
|
|
|
@staticmethod
|
|
def __validate_path(cmd, rootfs_dir, path):
|
|
if os.path.isabs(path):
|
|
logger.error("%s: Must be relative: %s" % (cmd, orig_path))
|
|
sys.exit(1)
|
|
|
|
# Disallow climbing outside of parent directory using '..',
|
|
# because doing so could be quite disastrous (we will delete the
|
|
# directory, or modify a directory outside OpenEmbedded).
|
|
full_path = os.path.realpath(os.path.join(rootfs_dir, path))
|
|
if not full_path.startswith(os.path.realpath(rootfs_dir)):
|
|
logger.error("%s: Must point inside the rootfs:" % (cmd, path))
|
|
sys.exit(1)
|
|
|
|
return full_path
|
|
|
|
@staticmethod
|
|
def __get_rootfs_dir(rootfs_dir):
|
|
if os.path.isdir(rootfs_dir):
|
|
return os.path.realpath(rootfs_dir)
|
|
|
|
image_rootfs_dir = get_bitbake_var("IMAGE_ROOTFS", rootfs_dir)
|
|
if not os.path.isdir(image_rootfs_dir):
|
|
raise WicError("No valid artifact IMAGE_ROOTFS from image "
|
|
"named %s has been found at %s, exiting." %
|
|
(rootfs_dir, image_rootfs_dir))
|
|
|
|
return os.path.realpath(image_rootfs_dir)
|
|
|
|
@staticmethod
|
|
def __get_pseudo(native_sysroot, rootfs, pseudo_dir):
|
|
pseudo = "export PSEUDO_PREFIX=%s/usr;" % native_sysroot
|
|
pseudo += "export PSEUDO_LOCALSTATEDIR=%s;" % pseudo_dir
|
|
pseudo += "export PSEUDO_PASSWD=%s;" % rootfs
|
|
pseudo += "export PSEUDO_NOSYMLINKEXP=1;"
|
|
pseudo += "%s " % get_bitbake_var("FAKEROOTCMD")
|
|
return pseudo
|
|
|
|
@classmethod
|
|
def do_prepare_partition(cls, part, source_params, cr, cr_workdir,
|
|
oe_builddir, bootimg_dir, kernel_dir,
|
|
krootfs_dir, native_sysroot):
|
|
"""
|
|
Called to do the actual content population for a partition i.e. it
|
|
'prepares' the partition to be incorporated into the image.
|
|
In this case, prepare content for legacy bios boot partition.
|
|
"""
|
|
if part.rootfs_dir is None:
|
|
if not 'ROOTFS_DIR' in krootfs_dir:
|
|
raise WicError("Couldn't find --rootfs-dir, exiting")
|
|
|
|
rootfs_dir = krootfs_dir['ROOTFS_DIR']
|
|
else:
|
|
if part.rootfs_dir in krootfs_dir:
|
|
rootfs_dir = krootfs_dir[part.rootfs_dir]
|
|
elif part.rootfs_dir:
|
|
rootfs_dir = part.rootfs_dir
|
|
else:
|
|
raise WicError("Couldn't find --rootfs-dir=%s connection or "
|
|
"it is not a valid path, exiting" % part.rootfs_dir)
|
|
|
|
part.rootfs_dir = cls.__get_rootfs_dir(rootfs_dir)
|
|
pseudo_dir = os.path.join(part.rootfs_dir, "../pseudo")
|
|
if not os.path.lexists(pseudo_dir):
|
|
logger.warn("%s folder does not exist. "
|
|
"Usernames and permissions will be invalid " % pseudo_dir)
|
|
pseudo_dir = None
|
|
|
|
new_rootfs = None
|
|
new_pseudo = None
|
|
# Handle excluded paths.
|
|
if part.exclude_path or part.include_path or part.change_directory:
|
|
# We need a new rootfs directory we can delete files from. Copy to
|
|
# workdir.
|
|
new_rootfs = os.path.realpath(os.path.join(cr_workdir, "rootfs%d" % part.lineno))
|
|
|
|
if os.path.lexists(new_rootfs):
|
|
shutil.rmtree(os.path.join(new_rootfs))
|
|
|
|
if part.change_directory:
|
|
cd = part.change_directory
|
|
if cd[-1] == '/':
|
|
cd = cd[:-1]
|
|
orig_dir = cls.__validate_path("--change-directory", part.rootfs_dir, cd)
|
|
else:
|
|
orig_dir = part.rootfs_dir
|
|
copyhardlinktree(orig_dir, new_rootfs)
|
|
|
|
# Convert the pseudo directory to its new location
|
|
if (pseudo_dir):
|
|
new_pseudo = os.path.realpath(
|
|
os.path.join(cr_workdir, "pseudo%d" % part.lineno))
|
|
if os.path.lexists(new_pseudo):
|
|
shutil.rmtree(new_pseudo)
|
|
os.mkdir(new_pseudo)
|
|
shutil.copy(os.path.join(pseudo_dir, "files.db"),
|
|
os.path.join(new_pseudo, "files.db"))
|
|
|
|
pseudo_cmd = "%s -B -m %s -M %s" % (cls.__get_pseudo(native_sysroot,
|
|
new_rootfs,
|
|
new_pseudo),
|
|
orig_dir, new_rootfs)
|
|
exec_native_cmd(pseudo_cmd, native_sysroot)
|
|
|
|
for in_path in part.include_path or []:
|
|
#parse arguments
|
|
include_path = in_path[0]
|
|
if len(in_path) > 2:
|
|
logger.error("'Invalid number of arguments for include-path")
|
|
sys.exit(1)
|
|
if len(in_path) == 2:
|
|
path = in_path[1]
|
|
else:
|
|
path = None
|
|
|
|
# Pack files to be included into a tar file.
|
|
# We need to create a tar file, because that way we can keep the
|
|
# permissions from the files even when they belong to different
|
|
# pseudo enviroments.
|
|
# If we simply copy files using copyhardlinktree/copytree... the
|
|
# copied files will belong to the user running wic.
|
|
tar_file = os.path.realpath(
|
|
os.path.join(cr_workdir, "include-path%d.tar" % part.lineno))
|
|
if os.path.isfile(include_path):
|
|
parent = os.path.dirname(os.path.realpath(include_path))
|
|
tar_cmd = "tar c --owner=root --group=root -f %s -C %s %s" % (
|
|
tar_file, parent, os.path.relpath(include_path, parent))
|
|
exec_native_cmd(tar_cmd, native_sysroot)
|
|
else:
|
|
if include_path in krootfs_dir:
|
|
include_path = krootfs_dir[include_path]
|
|
include_path = cls.__get_rootfs_dir(include_path)
|
|
include_pseudo = os.path.join(include_path, "../pseudo")
|
|
if os.path.lexists(include_pseudo):
|
|
pseudo = cls.__get_pseudo(native_sysroot, include_path,
|
|
include_pseudo)
|
|
tar_cmd = "tar cf %s -C %s ." % (tar_file, include_path)
|
|
else:
|
|
pseudo = None
|
|
tar_cmd = "tar c --owner=root --group=root -f %s -C %s ." % (
|
|
tar_file, include_path)
|
|
exec_native_cmd(tar_cmd, native_sysroot, pseudo)
|
|
|
|
#create destination
|
|
if path:
|
|
destination = cls.__validate_path("--include-path", new_rootfs, path)
|
|
Path(destination).mkdir(parents=True, exist_ok=True)
|
|
else:
|
|
destination = new_rootfs
|
|
|
|
#extract destination
|
|
untar_cmd = "tar xf %s -C %s" % (tar_file, destination)
|
|
if new_pseudo:
|
|
pseudo = cls.__get_pseudo(native_sysroot, new_rootfs, new_pseudo)
|
|
else:
|
|
pseudo = None
|
|
exec_native_cmd(untar_cmd, native_sysroot, pseudo)
|
|
os.remove(tar_file)
|
|
|
|
for orig_path in part.exclude_path or []:
|
|
path = orig_path
|
|
|
|
full_path = cls.__validate_path("--exclude-path", new_rootfs, path)
|
|
|
|
if not os.path.lexists(full_path):
|
|
continue
|
|
|
|
if new_pseudo:
|
|
pseudo = cls.__get_pseudo(native_sysroot, new_rootfs, new_pseudo)
|
|
else:
|
|
pseudo = None
|
|
if path.endswith(os.sep):
|
|
# Delete content only.
|
|
for entry in os.listdir(full_path):
|
|
full_entry = os.path.join(full_path, entry)
|
|
rm_cmd = "rm -rf %s" % (full_entry)
|
|
exec_native_cmd(rm_cmd, native_sysroot, pseudo)
|
|
else:
|
|
# Delete whole directory.
|
|
rm_cmd = "rm -rf %s" % (full_path)
|
|
exec_native_cmd(rm_cmd, native_sysroot, pseudo)
|
|
|
|
part.prepare_rootfs(cr_workdir, oe_builddir,
|
|
new_rootfs or part.rootfs_dir, native_sysroot,
|
|
pseudo_dir = new_pseudo or pseudo_dir)
|