poky: subtree update:23deb29c1b..c67f57c09e

Adrian Bunk (1):
      librsvg: Upgrade 2.40.20 -> 2.40.21

Alejandro Hernandez (1):
      musl: Upgrade to latest release 1.2.1

Alex Kiernan (8):
      systemd: Upgrade v245.6 -> v246
      systemd: Move musl patches to SRC_URI_MUSL
      systemd: Fix path to modules-load.d et al
      nfs-utils: Drop StandardError=syslog from systemd unit
      openssh: Drop StandardError=syslog from systemd unit
      volatile-binds: Drop StandardOutput=syslog from systemd unit
      systemd: Upgrade v246 -> v246.1
      systemd: Upgrade v246.1 -> v246.2

Alexander Kanavin (16):
      sysvinit: update 2.96 -> 2.97
      kbd: update 2.2.0 -> 2.3.0
      gnu-config: update to latest revision
      go: update 1.14.4 -> 1.14.6
      meson: update 0.54.3 -> 0.55.0
      nasm: update 2.14.02 -> 2.15.03
      glib-2.0: correct build with latest meson
      rsync: update 3.2.1 -> 3.2.2
      vala: update 0.48.6 -> 0.48.7
      logrotate: update 3.16.0 -> 3.17.0
      mesa: update 20.1.2 -> 20.1.4
      libcap: update 2.36 -> 2.41
      net-tools: fix upstream version check
      meson.bbclass: add a cups-config entry
      oeqa: write @OETestTag content into json test reports for each case
      libhandy: upstream has moved to gnome

Alistair Francis (1):
      binutils: Remove RISC-V PIE patch

Andrei Gherzan (2):
      initscripts: Fix various shellcheck warnings in populate-volatile.sh
      initscripts: Fix populate-volatile.sh bug when file/dir exists

Anuj Mittal (4):
      harfbuzz: upgrade 2.6.8 -> 2.7.1
      sqlite3: upgrade 3.32.3 -> 3.33.0
      stress-ng: upgrade 0.11.17 -> 0.11.18
      x264: upgrade to latest revision

Armin Kuster (1):
      glibc: Secruity fix for CVE-2020-6096

Bruce Ashfield (25):
      linux-yocto/5.4: update to v5.4.53
      linux-yocto/5.4: fix perf build with binutils 2.35
      kernel/yocto: allow dangling KERNEL_FEATURES
      linux-yocto/5.4: update to v5.4.54
      systemtap: update to 4.3 latest
      kernel-devsrc: fix x86 (32bit) on target module build
      lttng-modules: update to 2.12.2 (fixes v5.8+ builds)
      yocto-bsps: update reference BSPs to 5.4.54
      kernel-yocto: enhance configuration queue analysis capabilities
      strace: update to 5.8 (fix build against v5.8 uapi headers)
      linux-yocto-rt/5.4: update to rt32
      linux-yocto/5.4: update to v5.4.56
      linux-yocto/5.4: update to v5.4.57
      kernel-yocto: set cwd before querying the meta data dir
      kernel-yocto: make # is not set matching more precise
      kernel-yocto: split meta data gathering into patch and config phases
      make-mod-scripts: add HOSTCXX definitions and gmp-native dependency
      kernel-devsrc: fix on target modules prepare for ARM
      kernel-devsrc: 5.8 + gcc10 require gcc-plugins + libmpc-dev
      linux-yocto/5.4: update to v5.4.58
      linux-yocto/5.4: perf cs-etm: Move definition of 'traceid_list' global variable from header file
      libc-headers: update to v5.8
      linux-yocto: introduce 5.8 reference kernel
      kernel-yocto/5.8: add gmp-native dependency
      linux-yocto/5.8: update to v5.8.1

Chandana kalluri (1):
      qemu.inc: Use virtual/libgl instead of mesa

Changhyeok Bae (2):
      iproute2: upgrade 5.7.0 -> 5.8.0
      ethtool: upgrade 5.7 -> 5.8

Changqing Li (5):
      layer.conf: fix adwaita-icon-theme signature change problem
      gtk-icon-cache.bbclass: add features_check
      gcc-runtime.inc: fix m32 compile fail with x86-64 compiler
      libffi: fix multilib header conflict
      gpgme: fix multilib header conflict

Chen Qi (3):
      grub: set CVE_PRODUCT to grub2
      runqemu: fix permission check of /dev/vhost-net
      fribidi: extend CVE_PRODUCT to include fribidi

Chris Laplante (11):
      lib/oe/log_colorizer.py: add LogColorizerProxyProgressHandler
      bitbake: build: print traceback if progress handler can't be created
      bitbake: build: create_progress_handler: fix calling 'get' on NoneType
      bitbake: progress: modernize syntax, format
      bitbake: progress: fix hypothetical NameError if 'progress' isn't set
      bitbake: progress: filter ANSI escape codes before looking for progress text
      bitbake: tests/color: add test suite for ANSI color code filtering
      bitbake: data: emit filename/lineno information for shell functions
      bitbake: build: print a backtrace when a Bash shell function fails
      bitbake: build: print a backtrace with the original metadata locations of Bash shell funcs
      bitbake: build: make shell traps less chatty when 'bitbake -v' is used

Dan Callaghan (1):
      stress-ng: create a symlink for /usr/bin/stress

Daniel Ammann (1):
      wic: fix typo

Daniel Gomez (1):
      allarch: Add missing allarch ttf-bitstream-vera

Diego Sueiro (1):
      cml1: Add the option to choose the .config root dir

Dmitry Baryshkov (3):
      mesa: enable freedreno Vulkan driver if freedreno is enabled
      arch-armv8-2a.inc: add tune include for armv8.2a
      tune-cortexa55.inc: switch to using armv8.2a include file

Fredrik Gustafsson (13):
      package_manager: Move to package_manager/__init__.py
      rpm: Move manifest to its own subdir
      ipk: Move ipk manifest to its own subdir
      deb: Move deb manifest to its own subdir
      rpm: Move rootfs to its own dir
      ipk: Move rootfs to its own dir
      deb: Move rootfs to its own dir
      rpm: Move sdk to its own dir
      ipk: Move sdk to its own dir
      deb: Move sdk to its own dir
      rpm: Move package manager to its own dir
      ipk: Move package manager to its own dir
      deb: Move package manager to its own dir

Guillaume Champagne (1):
      weston: add missing packageconfigs

Jeremy Puhlman (1):
      gobject-introspection: disable scanner caching in install

Joe Slater (3):
      libdnf: allow reproducible binary builds
      gconf: use python3
      gcr: make sure gcr-oids.h is generated

Jonathan Richardson (1):
      cortex-m0plus.inc: Add tuning for cortex M0 plus

Joshua Watt (3):
      bitbake: bitbake: command: Handle multiconfig in findSigInfo
      lib/oe/reproducible.py: Fix git HEAD check
      perl: Add check for non-arch Storable.pm file

Khasim Mohammed (2):
      wic/bootimg-efi: Add support for IMAGE_BOOT_FILES
      wic/bootimg-efi: Update docs for IMAGE_BOOT_FILES support in bootimg-efi

Khem Raj (23):
      qemumips: Use 34Kf CPU emulation
      libunwind: Backport a fix for -fno-common option to compile
      dhcp: Use -fcommon compiler option
      inetutils: Fix build with -fno-common
      libomxil: Use -fcommon compiler option
      kexec-tools: Fix build with -fno-common
      distcc: Fix build with -fno-common
      libacpi: Fix build with -fno-common
      minicom: Fix build when using -fno-common
      binutils: Upgrade to 2.35 release
      xf86-video-intel: Fix build with -fno-common
      glibc: Upgrade to 2.32 release
      go: Upgrade to 1.14.7
      webkitgtk: Upgrade to 2.28.4
      kexec-tools: Fix additional duplicate symbols on aarch64/x86_64 builds
      gcc: Upgrade to 10.2.0
      buildcpio.py: Apply patch to fix build with -fno-common
      buildgalculator: Patch to fix build with -fno-common
      localedef: Update to include floatn.h fix
      xserver-xorg: Fix build with -fno-common/mips
      binutils: Let crosssdk gold linker generate 4096 btyes long .interp section
      gcc-cross-canadian: Correct the regexp to delete versioned gcc binary
      curl: Upgrade to 7.72.0

Konrad Weihmann (2):
      rootfs-post: remove traling blanks from tasks
      cve-update: handle baseMetricV2 as optional

Lee Chee Yang (4):
      buildhistory: use pid for temporary txt file name
      checklayer: check layer in BBLAYERS before test
      ghostscript: fix CVE-2020-15900
      qemu : fix CVE-2020-15863

Mark Hatle (1):
      package.bbclass: Sort shlib2 output for hash equivalency

Martin Jansa (2):
      net-tools: upgrade to latest revision in upstream repo instead of old debian snapshot
      perf: backport a fix for confusing non-fatal error

Matt Madison (1):
      cogl-1.0: correct X11 dependencies

Matthew (3):
      ltp: remove --with-power-management-testsuite from EXTRA_OECONF
      ltp: remove OOM tests from runtest/mm
      ltp: make copyFrom scp command non-fatal

Mikko Rapeli (2):
      alsa-topology-conf: use ${datadir} in do_install()
      alsa-ucm-conf: use ${datadir} in do_install()

Ming Liu (3):
      conf/machine: set UBOOT_MACHINE for qemumips and qemumips64
      multilib.conf: add u-boot to NON_MULTILIB_RECIPES
      libubootenv: uprev to v0.3

Mingli Yu (2):
      ccache: Upgrade to 3.7.11
      Revert "python3: define a profile directory path"

Naoto Yamaguchi (1):
      patch.py: Change to more strictly fuzz detection

Nathan Rossi (4):
      libexif: Enable native and nativesdk
      cmake.bbclass: Rework compiler program variables for allarch
      python3: Improve handling of python3 manifest generation
      python3-manifest.json: Updates

Oleksandr Kravchuk (9):
      python3-setuptools: update to 49.2.0
      bash-completion: update to 2.11
      python3: update to 3.8.5
      re2c: update to 2.0
      diffoscope: update to 153
      json-c: update to 0.15
      git: update 2.28.0
      libwpe: update to 1.7.1
      python3-setuptools: update to 49.3.1

Richard Purdie (20):
      perl: Avoid race continually rebuilding miniperl
      gcc: Fix mangled patch
      bitbake: server/process: Fix UI first connection tracking
      bitbake: server/process: Account for xmlrpc connections
      Revert "lib/oe/log_colorizer.py: add LogColorizerProxyProgressHandler"
      lib/package_manager: Fix missing imports
      populate_sdk_ext: Ensure buildtools doesn't corrupt OECORE_NATIVE_SYSROOT
      buildtools: Handle generic environment setup injection
      uninative: Handle PREMIRRORS generically
      maintainers: Update entries for Mark Hatle
      gcr: Fix patch Upstream-Status from v2 patch
      bitbake: server/process: Remove pointless process forking
      bitbake: server/process: Simplfy idle callback handler function
      bitbake: server/process: Pass timeout/xmlrpc parameters directly to the server
      bitbake: server/process: Add extra logfile flushing
      packagefeed-stability: Remove as obsolete
      build-compare: Drop recipe
      qemu: Upgrade 5.0.0 -> 5.1.0
      selftest/tinfoil: Increase wait event timeout
      lttng-tools: upgrade 2.12.1 -> 2.12.2

Ross Burton (3):
      popt: upgrade to 1.18
      conf/machine: set UBOOT_MACHINE for qemuarm and qemuarm64
      gcc: backport a fix for out-of-line atomics on aarch64

TeohJayShen (2):
      oeqa/manual/bsp-hw.json : remove shutdown_system test
      oeqa/manual/bsp-hw.json : remove X_server_can_start_up_with_runlevel_5_boot test

Trevor Gamblin (1):
      llvm: upgrade 9.0.1 -> 10.0.1

Tyler Hicks (1):
      kernel-devicetree: Fix intermittent build failures caused by DTB builds

Usama Arif (3):
      kernel-fitimage: build configuration for image tree when dtb is not present
      oeqa/selftest/imagefeatures: Add testcase for fitImage
      ref-manual: Add documentation for kernel-fitimage

Vasyl Vavrychuk (1):
      runqemu: Check gtk or sdl option is passed together with gl or gl-es options.

Yi Zhao (1):
      pbzip2: extend for nativesdk

Zhang Qiang (1):
      kernel.bbclass: Configuration for environment with HOSTCXX

hongxu (1):
      nativesdk-rpm: adjust RPM_CONFIGDIR paths dynamically

zangrc (8):
      libevdev:upgrade 1.9.0 -> 1.9.1
      mpg123:upgrade 1.26.2 -> 1.26.3
      flex: Refresh patch
      stress-ng:upgrade 0.11.15 -> 0.11.17
      sudo:upgrade 1.9.1 -> 1.9.2
      libcap: Upgrade 2.41 -> 2.42
      libinput: Upgrade 1.15.6 -> 1.16.0
      python3-setuptools: Upgrade 49.2.0 -> 49.2.1

Signed-off-by: Andrew Geissler <geissonator@yahoo.com>
Change-Id: Ic7fa1e8484c1c7722a70c75608aa4ab21fa7d755

1 files changed, 404 insertions, 0 deletions

diff --git a/poky/meta/lib/oe/package_manager/rpm/__init__.py b/poky/meta/lib/oe/package_manager/rpm/__init__.py
new file mode 100644
index 000000000..c91f61ae5
--- /dev/null
+++ b/poky/meta/lib/oe/package_manager/rpm/__init__.py
@@ -0,0 +1,404 @@
+#
+# SPDX-License-Identifier: GPL-2.0-only
+#
+
+import shutil
+import subprocess
+from oe.package_manager import *
+
+class RpmIndexer(Indexer):
+    def write_index(self):
+        self.do_write_index(self.deploy_dir)
+
+    def do_write_index(self, deploy_dir):
+        if self.d.getVar('PACKAGE_FEED_SIGN') == '1':
+            signer = get_signer(self.d, self.d.getVar('PACKAGE_FEED_GPG_BACKEND'))
+        else:
+            signer = None
+
+        createrepo_c = bb.utils.which(os.environ['PATH'], "createrepo_c")
+        result = create_index("%s --update -q %s" % (createrepo_c, deploy_dir))
+        if result:
+            bb.fatal(result)
+
+        # Sign repomd
+        if signer:
+            sig_type = self.d.getVar('PACKAGE_FEED_GPG_SIGNATURE_TYPE')
+            is_ascii_sig = (sig_type.upper() != "BIN")
+            signer.detach_sign(os.path.join(deploy_dir, 'repodata', 'repomd.xml'),
+                               self.d.getVar('PACKAGE_FEED_GPG_NAME'),
+                               self.d.getVar('PACKAGE_FEED_GPG_PASSPHRASE_FILE'),
+                               armor=is_ascii_sig)
+
+class RpmSubdirIndexer(RpmIndexer):
+    def write_index(self):
+        bb.note("Generating package index for %s" %(self.deploy_dir))
+        self.do_write_index(self.deploy_dir)
+        for entry in os.walk(self.deploy_dir):
+            if os.path.samefile(self.deploy_dir, entry[0]):
+                for dir in entry[1]:
+                    if dir != 'repodata':
+                        dir_path = oe.path.join(self.deploy_dir, dir)
+                        bb.note("Generating package index for %s" %(dir_path))
+                        self.do_write_index(dir_path)
+
+
+class RpmPkgsList(PkgsList):
+    def list_pkgs(self):
+        return RpmPM(self.d, self.rootfs_dir, self.d.getVar('TARGET_VENDOR'), needfeed=False).list_installed()
+
+class RpmPM(PackageManager):
+    def __init__(self,
+                 d,
+                 target_rootfs,
+                 target_vendor,
+                 task_name='target',
+                 arch_var=None,
+                 os_var=None,
+                 rpm_repo_workdir="oe-rootfs-repo",
+                 filterbydependencies=True,
+                 needfeed=True):
+        super(RpmPM, self).__init__(d, target_rootfs)
+        self.target_vendor = target_vendor
+        self.task_name = task_name
+        if arch_var == None:
+            self.archs = self.d.getVar('ALL_MULTILIB_PACKAGE_ARCHS').replace("-","_")
+        else:
+            self.archs = self.d.getVar(arch_var).replace("-","_")
+        if task_name == "host":
+            self.primary_arch = self.d.getVar('SDK_ARCH')
+        else:
+            self.primary_arch = self.d.getVar('MACHINE_ARCH')
+
+        if needfeed:
+            self.rpm_repo_dir = oe.path.join(self.d.getVar('WORKDIR'), rpm_repo_workdir)
+            create_packages_dir(self.d, oe.path.join(self.rpm_repo_dir, "rpm"), d.getVar("DEPLOY_DIR_RPM"), "package_write_rpm", filterbydependencies)
+
+        self.saved_packaging_data = self.d.expand('${T}/saved_packaging_data/%s' % self.task_name)
+        if not os.path.exists(self.d.expand('${T}/saved_packaging_data')):
+            bb.utils.mkdirhier(self.d.expand('${T}/saved_packaging_data'))
+        self.packaging_data_dirs = ['etc/rpm', 'etc/rpmrc', 'etc/dnf', 'var/lib/rpm', 'var/lib/dnf', 'var/cache/dnf']
+        self.solution_manifest = self.d.expand('${T}/saved/%s_solution' %
+                                               self.task_name)
+        if not os.path.exists(self.d.expand('${T}/saved')):
+            bb.utils.mkdirhier(self.d.expand('${T}/saved'))
+
+    def _configure_dnf(self):
+        # libsolv handles 'noarch' internally, we don't need to specify it explicitly
+        archs = [i for i in reversed(self.archs.split()) if i not in ["any", "all", "noarch"]]
+        # This prevents accidental matching against libsolv's built-in policies
+        if len(archs) <= 1:
+            archs = archs + ["bogusarch"]
+        # This architecture needs to be upfront so that packages using it are properly prioritized
+        archs = ["sdk_provides_dummy_target"] + archs
+        confdir = "%s/%s" %(self.target_rootfs, "etc/dnf/vars/")
+        bb.utils.mkdirhier(confdir)
+        open(confdir + "arch", 'w').write(":".join(archs))
+        distro_codename = self.d.getVar('DISTRO_CODENAME')
+        open(confdir + "releasever", 'w').write(distro_codename if distro_codename is not None else '')
+
+        open(oe.path.join(self.target_rootfs, "etc/dnf/dnf.conf"), 'w').write("")
+
+
+    def _configure_rpm(self):
+        # We need to configure rpm to use our primary package architecture as the installation architecture,
+        # and to make it compatible with other package architectures that we use.
+        # Otherwise it will refuse to proceed with packages installation.
+        platformconfdir = "%s/%s" %(self.target_rootfs, "etc/rpm/")
+        rpmrcconfdir = "%s/%s" %(self.target_rootfs, "etc/")
+        bb.utils.mkdirhier(platformconfdir)
+        open(platformconfdir + "platform", 'w').write("%s-pc-linux" % self.primary_arch)
+        with open(rpmrcconfdir + "rpmrc", 'w') as f:
+            f.write("arch_compat: %s: %s\n" % (self.primary_arch, self.archs if len(self.archs) > 0 else self.primary_arch))
+            f.write("buildarch_compat: %s: noarch\n" % self.primary_arch)
+
+        open(platformconfdir + "macros", 'w').write("%_transaction_color 7\n")
+        if self.d.getVar('RPM_PREFER_ELF_ARCH'):
+            open(platformconfdir + "macros", 'a').write("%%_prefer_color %s" % (self.d.getVar('RPM_PREFER_ELF_ARCH')))
+
+        if self.d.getVar('RPM_SIGN_PACKAGES') == '1':
+            signer = get_signer(self.d, self.d.getVar('RPM_GPG_BACKEND'))
+            pubkey_path = oe.path.join(self.d.getVar('B'), 'rpm-key')
+            signer.export_pubkey(pubkey_path, self.d.getVar('RPM_GPG_NAME'))
+            rpm_bin = bb.utils.which(os.getenv('PATH'), "rpmkeys")
+            cmd = [rpm_bin, '--root=%s' % self.target_rootfs, '--import', pubkey_path]
+            try:
+                subprocess.check_output(cmd, stderr=subprocess.STDOUT)
+            except subprocess.CalledProcessError as e:
+                bb.fatal("Importing GPG key failed. Command '%s' "
+                        "returned %d:\n%s" % (' '.join(cmd), e.returncode, e.output.decode("utf-8")))
+
+    def create_configs(self):
+        self._configure_dnf()
+        self._configure_rpm()
+
+    def write_index(self):
+        lockfilename = self.d.getVar('DEPLOY_DIR_RPM') + "/rpm.lock"
+        lf = bb.utils.lockfile(lockfilename, False)
+        RpmIndexer(self.d, self.rpm_repo_dir).write_index()
+        bb.utils.unlockfile(lf)
+
+    def insert_feeds_uris(self, feed_uris, feed_base_paths, feed_archs):
+        from urllib.parse import urlparse
+
+        if feed_uris == "":
+            return
+
+        gpg_opts = ''
+        if self.d.getVar('PACKAGE_FEED_SIGN') == '1':
+            gpg_opts += 'repo_gpgcheck=1\n'
+            gpg_opts += 'gpgkey=file://%s/pki/packagefeed-gpg/PACKAGEFEED-GPG-KEY-%s-%s\n' % (self.d.getVar('sysconfdir'), self.d.getVar('DISTRO'), self.d.getVar('DISTRO_CODENAME'))
+
+        if self.d.getVar('RPM_SIGN_PACKAGES') != '1':
+            gpg_opts += 'gpgcheck=0\n'
+
+        bb.utils.mkdirhier(oe.path.join(self.target_rootfs, "etc", "yum.repos.d"))
+        remote_uris = self.construct_uris(feed_uris.split(), feed_base_paths.split())
+        for uri in remote_uris:
+            repo_base = "oe-remote-repo" + "-".join(urlparse(uri).path.split("/"))
+            if feed_archs is not None:
+                for arch in feed_archs.split():
+                    repo_uri = uri + "/" + arch
+                    repo_id   = "oe-remote-repo"  + "-".join(urlparse(repo_uri).path.split("/"))
+                    repo_name = "OE Remote Repo:" + " ".join(urlparse(repo_uri).path.split("/"))
+                    open(oe.path.join(self.target_rootfs, "etc", "yum.repos.d", repo_base + ".repo"), 'a').write(
+                             "[%s]\nname=%s\nbaseurl=%s\n%s\n" % (repo_id, repo_name, repo_uri, gpg_opts))
+            else:
+                repo_name = "OE Remote Repo:" + " ".join(urlparse(uri).path.split("/"))
+                repo_uri = uri
+                open(oe.path.join(self.target_rootfs, "etc", "yum.repos.d", repo_base + ".repo"), 'w').write(
+                             "[%s]\nname=%s\nbaseurl=%s\n%s" % (repo_base, repo_name, repo_uri, gpg_opts))
+
+    def _prepare_pkg_transaction(self):
+        os.environ['D'] = self.target_rootfs
+        os.environ['OFFLINE_ROOT'] = self.target_rootfs
+        os.environ['IPKG_OFFLINE_ROOT'] = self.target_rootfs
+        os.environ['OPKG_OFFLINE_ROOT'] = self.target_rootfs
+        os.environ['INTERCEPT_DIR'] = self.intercepts_dir
+        os.environ['NATIVE_ROOT'] = self.d.getVar('STAGING_DIR_NATIVE')
+
+
+    def install(self, pkgs, attempt_only = False):
+        if len(pkgs) == 0:
+            return
+        self._prepare_pkg_transaction()
+
+        bad_recommendations = self.d.getVar('BAD_RECOMMENDATIONS')
+        package_exclude = self.d.getVar('PACKAGE_EXCLUDE')
+        exclude_pkgs = (bad_recommendations.split() if bad_recommendations else []) + (package_exclude.split() if package_exclude else [])
+
+        output = self._invoke_dnf((["--skip-broken"] if attempt_only else []) +
+                         (["-x", ",".join(exclude_pkgs)] if len(exclude_pkgs) > 0 else []) +
+                         (["--setopt=install_weak_deps=False"] if self.d.getVar('NO_RECOMMENDATIONS') == "1" else []) +
+                         (["--nogpgcheck"] if self.d.getVar('RPM_SIGN_PACKAGES') != '1' else ["--setopt=gpgcheck=True"]) +
+                         ["install"] +
+                         pkgs)
+
+        failed_scriptlets_pkgnames = collections.OrderedDict()
+        for line in output.splitlines():
+            if line.startswith("Error in POSTIN scriptlet in rpm package"):
+                failed_scriptlets_pkgnames[line.split()[-1]] = True
+
+        if len(failed_scriptlets_pkgnames) > 0:
+            failed_postinsts_abort(list(failed_scriptlets_pkgnames.keys()), self.d.expand("${T}/log.do_${BB_CURRENTTASK}"))
+
+    def remove(self, pkgs, with_dependencies = True):
+        if not pkgs:
+            return
+
+        self._prepare_pkg_transaction()
+
+        if with_dependencies:
+            self._invoke_dnf(["remove"] + pkgs)
+        else:
+            cmd = bb.utils.which(os.getenv('PATH'), "rpm")
+            args = ["-e", "-v", "--nodeps", "--root=%s" %self.target_rootfs]
+
+            try:
+                bb.note("Running %s" % ' '.join([cmd] + args + pkgs))
+                output = subprocess.check_output([cmd] + args + pkgs, stderr=subprocess.STDOUT).decode("utf-8")
+                bb.note(output)
+            except subprocess.CalledProcessError as e:
+                bb.fatal("Could not invoke rpm. Command "
+                     "'%s' returned %d:\n%s" % (' '.join([cmd] + args + pkgs), e.returncode, e.output.decode("utf-8")))
+
+    def upgrade(self):
+        self._prepare_pkg_transaction()
+        self._invoke_dnf(["upgrade"])
+
+    def autoremove(self):
+        self._prepare_pkg_transaction()
+        self._invoke_dnf(["autoremove"])
+
+    def remove_packaging_data(self):
+        self._invoke_dnf(["clean", "all"])
+        for dir in self.packaging_data_dirs:
+            bb.utils.remove(oe.path.join(self.target_rootfs, dir), True)
+
+    def backup_packaging_data(self):
+        # Save the packaging dirs for increment rpm image generation
+        if os.path.exists(self.saved_packaging_data):
+            bb.utils.remove(self.saved_packaging_data, True)
+        for i in self.packaging_data_dirs:
+            source_dir = oe.path.join(self.target_rootfs, i)
+            target_dir = oe.path.join(self.saved_packaging_data, i)
+            if os.path.isdir(source_dir):
+                shutil.copytree(source_dir, target_dir, symlinks=True)
+            elif os.path.isfile(source_dir):
+                shutil.copy2(source_dir, target_dir)
+
+    def recovery_packaging_data(self):
+        # Move the rpmlib back
+        if os.path.exists(self.saved_packaging_data):
+            for i in self.packaging_data_dirs:
+                target_dir = oe.path.join(self.target_rootfs, i)
+                if os.path.exists(target_dir):
+                    bb.utils.remove(target_dir, True)
+                source_dir = oe.path.join(self.saved_packaging_data, i)
+                if os.path.isdir(source_dir):
+                    shutil.copytree(source_dir, target_dir, symlinks=True)
+                elif os.path.isfile(source_dir):
+                    shutil.copy2(source_dir, target_dir)
+
+    def list_installed(self):
+        output = self._invoke_dnf(["repoquery", "--installed", "--queryformat", "Package: %{name} %{arch} %{version} %{name}-%{version}-%{release}.%{arch}.rpm\nDependencies:\n%{requires}\nRecommendations:\n%{recommends}\nDependenciesEndHere:\n"],
+                                  print_output = False)
+        packages = {}
+        current_package = None
+        current_deps = None
+        current_state = "initial"
+        for line in output.splitlines():
+            if line.startswith("Package:"):
+                package_info = line.split(" ")[1:]
+                current_package = package_info[0]
+                package_arch = package_info[1]
+                package_version = package_info[2]
+                package_rpm = package_info[3]
+                packages[current_package] = {"arch":package_arch, "ver":package_version, "filename":package_rpm}
+                current_deps = []
+            elif line.startswith("Dependencies:"):
+                current_state = "dependencies"
+            elif line.startswith("Recommendations"):
+                current_state = "recommendations"
+            elif line.startswith("DependenciesEndHere:"):
+                current_state = "initial"
+                packages[current_package]["deps"] = current_deps
+            elif len(line) > 0:
+                if current_state == "dependencies":
+                    current_deps.append(line)
+                elif current_state == "recommendations":
+                    current_deps.append("%s [REC]" % line)
+
+        return packages
+
+    def update(self):
+        self._invoke_dnf(["makecache", "--refresh"])
+
+    def _invoke_dnf(self, dnf_args, fatal = True, print_output = True ):
+        os.environ['RPM_ETCCONFIGDIR'] = self.target_rootfs
+
+        dnf_cmd = bb.utils.which(os.getenv('PATH'), "dnf")
+        standard_dnf_args = ["-v", "--rpmverbosity=info", "-y",
+                             "-c", oe.path.join(self.target_rootfs, "etc/dnf/dnf.conf"),
+                             "--setopt=reposdir=%s" %(oe.path.join(self.target_rootfs, "etc/yum.repos.d")),
+                             "--installroot=%s" % (self.target_rootfs),
+                             "--setopt=logdir=%s" % (self.d.getVar('T'))
+                            ]
+        if hasattr(self, "rpm_repo_dir"):
+            standard_dnf_args.append("--repofrompath=oe-repo,%s" % (self.rpm_repo_dir))
+        cmd = [dnf_cmd] + standard_dnf_args + dnf_args
+        bb.note('Running %s' % ' '.join(cmd))
+        try:
+            output = subprocess.check_output(cmd,stderr=subprocess.STDOUT).decode("utf-8")
+            if print_output:
+                bb.debug(1, output)
+            return output
+        except subprocess.CalledProcessError as e:
+            if print_output:
+                (bb.note, bb.fatal)[fatal]("Could not invoke dnf. Command "
+                     "'%s' returned %d:\n%s" % (' '.join(cmd), e.returncode, e.output.decode("utf-8")))
+            else:
+                (bb.note, bb.fatal)[fatal]("Could not invoke dnf. Command "
+                     "'%s' returned %d:" % (' '.join(cmd), e.returncode))
+            return e.output.decode("utf-8")
+
+    def dump_install_solution(self, pkgs):
+        open(self.solution_manifest, 'w').write(" ".join(pkgs))
+        return pkgs
+
+    def load_old_install_solution(self):
+        if not os.path.exists(self.solution_manifest):
+            return []
+        with open(self.solution_manifest, 'r') as fd:
+            return fd.read().split()
+
+    def _script_num_prefix(self, path):
+        files = os.listdir(path)
+        numbers = set()
+        numbers.add(99)
+        for f in files:
+            numbers.add(int(f.split("-")[0]))
+        return max(numbers) + 1
+
+    def save_rpmpostinst(self, pkg):
+        bb.note("Saving postinstall script of %s" % (pkg))
+        cmd = bb.utils.which(os.getenv('PATH'), "rpm")
+        args = ["-q", "--root=%s" % self.target_rootfs, "--queryformat", "%{postin}", pkg]
+
+        try:
+            output = subprocess.check_output([cmd] + args,stderr=subprocess.STDOUT).decode("utf-8")
+        except subprocess.CalledProcessError as e:
+            bb.fatal("Could not invoke rpm. Command "
+                     "'%s' returned %d:\n%s" % (' '.join([cmd] + args), e.returncode, e.output.decode("utf-8")))
+
+        # may need to prepend #!/bin/sh to output
+
+        target_path = oe.path.join(self.target_rootfs, self.d.expand('${sysconfdir}/rpm-postinsts/'))
+        bb.utils.mkdirhier(target_path)
+        num = self._script_num_prefix(target_path)
+        saved_script_name = oe.path.join(target_path, "%d-%s" % (num, pkg))
+        open(saved_script_name, 'w').write(output)
+        os.chmod(saved_script_name, 0o755)
+
+    def _handle_intercept_failure(self, registered_pkgs):
+        rpm_postinsts_dir = self.target_rootfs + self.d.expand('${sysconfdir}/rpm-postinsts/')
+        bb.utils.mkdirhier(rpm_postinsts_dir)
+
+        # Save the package postinstalls in /etc/rpm-postinsts
+        for pkg in registered_pkgs.split():
+            self.save_rpmpostinst(pkg)
+
+    def extract(self, pkg):
+        output = self._invoke_dnf(["repoquery", "--queryformat", "%{location}", pkg])
+        pkg_name = output.splitlines()[-1]
+        if not pkg_name.endswith(".rpm"):
+            bb.fatal("dnf could not find package %s in repository: %s" %(pkg, output))
+        pkg_path = oe.path.join(self.rpm_repo_dir, pkg_name)
+
+        cpio_cmd = bb.utils.which(os.getenv("PATH"), "cpio")
+        rpm2cpio_cmd = bb.utils.which(os.getenv("PATH"), "rpm2cpio")
+
+        if not os.path.isfile(pkg_path):
+            bb.fatal("Unable to extract package for '%s'."
+                     "File %s doesn't exists" % (pkg, pkg_path))
+
+        tmp_dir = tempfile.mkdtemp()
+        current_dir = os.getcwd()
+        os.chdir(tmp_dir)
+
+        try:
+            cmd = "%s %s | %s -idmv" % (rpm2cpio_cmd, pkg_path, cpio_cmd)
+            output = subprocess.check_output(cmd, stderr=subprocess.STDOUT, shell=True)
+        except subprocess.CalledProcessError as e:
+            bb.utils.remove(tmp_dir, recurse=True)
+            bb.fatal("Unable to extract %s package. Command '%s' "
+                     "returned %d:\n%s" % (pkg_path, cmd, e.returncode, e.output.decode("utf-8")))
+        except OSError as e:
+            bb.utils.remove(tmp_dir, recurse=True)
+            bb.fatal("Unable to extract %s package. Command '%s' "
+                     "returned %d:\n%s at %s" % (pkg_path, cmd, e.errno, e.strerror, e.filename))
+
+        bb.note("Extracted %s to %s" % (pkg_path, tmp_dir))
+        os.chdir(current_dir)
+
+        return tmp_dir