From 82b454d2ff43b39e1a3b38fded0c2e5caffcd336 Mon Sep 17 00:00:00 2001

From: Matthew Almond <malmond@fb.com>

Date: Fri, 8 Nov 2019 09:29:43 -0800

Subject: [PATCH 1/4] RPM with Copy on Write

This is part of https://fedoraproject.org/wiki/Changes/RPMCoW

The majority of changes are in two new programs:

= rpm2extents

Modeled as a 'stream processor'. It reads a regular .rpm file on stdin,

and produces a modified .rpm file on stdout. The lead, signature and

headers are preserved 1:1 to allow all the normal metadata inspection,

signature verification to work as expected. Only the 'payload' is

modified.

The primary motivation for this tool is to re-organize the payload as a

sequence of raw file extents (hence the name). The files are organized

by their digest identity instead of path/filename. If any digest is

repeated, then the file is skipped/de-duped. Only regular files are

represented. All other entries like directories, symlinks, devices are

fully described in the headers and are omitted.

The files are padded so they start on `sysconf(_SC_PAGESIZE)` boundries

to permit 'reflink' syscalls to work in the `reflink` plugin.

At the end of the file is a footer with 3 sections:

1. List of calculated digests of the input stream. This is used in

   `librepo` because the file *written* is a derivative, and not the

   same as the repo metadata describes. `rpm2extents` takes one or more

   positional arguments that described which digest algorithms are

   desired. This is often just `SHA256`. This program is only measuring

   and recording the digest - it does not express an opinion on whether

   the file is correct. Due to the API on most compression libraries

   directly reading the source file, the whole file digest is measured

   using a subprocess and pipes. I don't love it, but it works.

2. Sorted List of file content digests + offset pairs. This is used in

   the plugin with a trivial binary search to locate the start of file

   content. The size is not needed because it's part of normal headers.

3. (offset of 1., offset of 2., 8 byte MAGIC value) triple

= reflink plugin

Looks for the 8 byte magic value at the end of the rpm file. If present

it alters the `RPMTAG_PAYLOADFORMAT` in memory to `clon`, and reads in

the digest-> offset table.

`rpmPackageFilesInstall()` in `fsm.c` is

modified to alter the enumeration strategy from

`rpmfiNewArchiveReader()` to `rpmfilesIter()` if not `cpio`. This is

needed because there is no cpio to enumerate. In the same function, if

`rpmpluginsCallFsmFilePre()` returns `RPMRC_PLUGIN_CONTENTS` then

`fsmMkfile()` is skipped as it is assumed the plugin did the work.

The majority of the work is in `reflink_fsm_file_pre()` - the per file

hook for RPM plugins. If the file enumerated in

`rpmPackageFilesInstall()` is a regular file, this function will look up

the offset in the digest->offset table and will try to reflink it, then

fall back to a regular copy. If reflinking does work: we will have

reflinked a whole number of pages, so we truncate the file to the

expected size. Therefore installing most files does involve two writes:

the reflink of the full size, then a fork/copy on write for the last

page worth.

If the file passed to `reflink_fsm_file_pre()` is anything other than a

regular file, it return `RPMRC_OK` so the normal mechanics of

`rpmPackageFilesInstall()` are used. That handles directories, symlinks

and other non file types.

= New API for internal use

1. `rpmReadPackageRaw()` is used within `rpm2extents` to read all the

   headers without trying to validate signatures. This eliminates the

   runtime dependency on rpmdb.

2. `rpmteFd()` exposes the Fd behind the rpmte, so plugins can interact

   with the rpm itself.

3. `RPMRC_PLUGIN_CONTENTS` in `rpmRC_e` for use in

   `rpmpluginsCallFsmFilePre()` specifically.

4. `pgpStringVal()` is used to help parse the command line in

   `rpm2extents` - the positional arguments are strings, and this

   converts the values back to the values in the table.

Nothing has been removed, and none of the changes are intended to be

used externally, so I don't think a soname bump is warranted here.

---

 Makefile.am         |   6 +-

 lib/depends.c       |   2 +

 lib/fsm.c           |  50 ++++-

 lib/package.c       |  40 ++++

 lib/rpmlib.h        |   9 +

 lib/rpmplugins.c    |  21 +-

 lib/rpmte.c         |   5 +

 lib/rpmte.h         |   2 +

 lib/rpmtypes.h      |   3 +-

 macros.in           |   1 +

 plugins/Makefile.am |   4 +

 plugins/reflink.c   | 340 +++++++++++++++++++++++++++++

 rpm2extents.c       | 519 ++++++++++++++++++++++++++++++++++++++++++++

 rpmio/rpmpgp.c      |  10 +

 rpmio/rpmpgp.h      |   9 +

 15 files changed, 1006 insertions(+), 15 deletions(-)

 create mode 100644 plugins/reflink.c

 create mode 100644 rpm2extents.c

diff --git a/Makefile.am b/Makefile.am

index aca2f8996..17c1e0e8a 100644

--- a/Makefile.am

+++ b/Makefile.am

@@ -105,7 +105,7 @@ pkginclude_HEADERS += build/rpmfc.h

 pkginclude_HEADERS += build/rpmspec.h

-bin_PROGRAMS =		rpm rpm2cpio rpmbuild rpmdb rpmkeys rpmsign rpmspec

+bin_PROGRAMS =		rpm rpm2cpio rpmbuild rpmdb rpmkeys rpmsign rpmspec rpm2extents

 if WITH_ARCHIVE

 bin_PROGRAMS += 	rpm2archive 

 endif

@@ -159,6 +159,10 @@ rpm2cpio_SOURCES =	rpm2cpio.c debug.h system.h

 rpm2cpio_LDADD =	lib/librpm.la rpmio/librpmio.la

 rpm2cpio_LDADD +=	@WITH_POPT_LIB@

+rpm2extents_SOURCES =	rpm2extents.c debug.h system.h

+rpm2extents_LDADD =	lib/librpm.la rpmio/librpmio.la

+rpm2extents_LDADD +=	@WITH_POPT_LIB@

+

 rpm2archive_SOURCES =	rpm2archive.c debug.h system.h

 rpm2archive_LDADD =	lib/librpm.la rpmio/librpmio.la

 rpm2archive_LDADD +=	@WITH_POPT_LIB@ @WITH_ARCHIVE_LIB@

diff --git a/lib/depends.c b/lib/depends.c

index 28a4a784d..9e0489bcc 100644

--- a/lib/depends.c

+++ b/lib/depends.c

@@ -80,6 +80,8 @@ static rpmRC headerCheckPayloadFormat(Header h) {

      */

     if (!payloadfmt) return rc;

+    if (rstreq(payloadfmt, "clon")) return rc;

+

     if (!rstreq(payloadfmt, "cpio")) {

         char *nevra = headerGetAsString(h, RPMTAG_NEVRA);

         if (payloadfmt && rstreq(payloadfmt, "drpm")) {

diff --git a/lib/fsm.c b/lib/fsm.c

index 35dcda081..03a716474 100644

--- a/lib/fsm.c

+++ b/lib/fsm.c

@@ -7,6 +7,7 @@

 #include <utime.h>

 #include <errno.h>

+#include <stdbool.h>

 #if WITH_CAP

 #include <sys/capability.h>

 #endif

@@ -18,6 +19,7 @@

 #include "rpmio/rpmio_internal.h"	/* fdInit/FiniDigest */

 #include "lib/fsm.h"

+#include "lib/rpmlib.h"

 #include "lib/rpmte_internal.h"	/* XXX rpmfs */

 #include "lib/rpmplugins.h"	/* rpm plugins hooks */

 #include "lib/rpmug.h"

@@ -835,7 +837,7 @@ int rpmPackageFilesInstall(rpmts ts, rpmte te, rpmfiles files,

               rpmpsm psm, char ** failedFile)

 {

     FD_t payload = rpmtePayload(te);

-    rpmfi fi = rpmfiNewArchiveReader(payload, files, RPMFI_ITER_READ_ARCHIVE);

+    rpmfi fi;

     rpmfs fs = rpmteGetFileStates(te);

     rpmPlugins plugins = rpmtsPlugins(ts);

     struct stat sb;

@@ -850,10 +852,21 @@ int rpmPackageFilesInstall(rpmts ts, rpmte te, rpmfiles files,

     char *tid = NULL;

     const char *suffix;

     char *fpath = NULL;

+    Header h = rpmteHeader(te);

+    const char *payloadfmt = headerGetString(h, RPMTAG_PAYLOADFORMAT);

+    bool cpio = true;

-    if (fi == NULL) {

-	rc = RPMERR_BAD_MAGIC;

-	goto exit;

+    if (payloadfmt && rstreq(payloadfmt, "clon")) {

+	cpio = false;

+    }

+    if (cpio) {

+	fi = rpmfiNewArchiveReader(payload, files, RPMFI_ITER_READ_ARCHIVE);

+	if (fi == NULL) {

+	    rc = RPMERR_BAD_MAGIC;

+	    goto exit;

+	}

+    } else {

+	fi = rpmfilesIter(files, RPMFI_ITER_FWD);

     }

     /* transaction id used for temporary path suffix while installing */

@@ -893,10 +906,20 @@ int rpmPackageFilesInstall(rpmts ts, rpmte te, rpmfiles files,

 	/* Run fsm file pre hook for all plugins */

 	rc = rpmpluginsCallFsmFilePre(plugins, fi, fpath,

 				      sb.st_mode, action);

-	if (rc) {

-	    skip = 1;

-	} else {

+	skip = skip || rpmfiFFlags(fi) & RPMFILE_GHOST;

+	bool plugin_contents = false;

+	switch (rc) {

+	case RPMRC_OK:

 	    setFileState(fs, rpmfiFX(fi));

+	    break;

+	case RPMRC_PLUGIN_CONTENTS:

+	    plugin_contents = true;

+	    // reduce reads on cpio to this value. Could be zero if

+	    // this is from a hard link.

+	    rc = RPMRC_OK;

+	    break;

+	default:

+	    skip = 1;

 	}

         if (!skip) {

@@ -926,8 +949,12 @@ int rpmPackageFilesInstall(rpmts ts, rpmte te, rpmfiles files,

             if (S_ISREG(sb.st_mode)) {

 		if (rc == RPMERR_ENOENT) {

-		    rc = fsmMkfile(fi, fpath, files, psm, nodigest,

-				   &setmeta, &firsthardlink, &firstlinkfile);

+		    if (plugin_contents) {

+			rc = RPMRC_OK;

+		    } else {

+			rc = fsmMkfile(fi, fpath, files, psm, nodigest,

+				&setmeta, &firsthardlink, &firstlinkfile);

+		    }

 		}

             } else if (S_ISDIR(sb.st_mode)) {

                 if (rc == RPMERR_ENOENT) {

@@ -1011,7 +1038,10 @@ int rpmPackageFilesInstall(rpmts ts, rpmte te, rpmfiles files,

 exit:

     /* No need to bother with close errors on read */

-    rpmfiArchiveClose(fi);

+    if (cpio) {

+	rpmfiArchiveClose(fi);

+    }

+	h = headerFree(h);

     rpmfiFree(fi);

     Fclose(payload);

     free(tid);

diff --git a/lib/package.c b/lib/package.c

index 93a06ebfe..b0c1c2857 100644

--- a/lib/package.c

+++ b/lib/package.c

@@ -407,5 +407,45 @@ rpmRC rpmReadPackageFile(rpmts ts, FD_t fd, const char * fn, Header * hdrp)

     return rc;

 }

+rpmRC rpmReadPackageRaw(FD_t fd, Header * sigp, Header * hdrp)

+{

+    char *msg = NULL;

+    hdrblob sigblob = hdrblobCreate();

+    hdrblob blob = hdrblobCreate();

+    Header h = NULL;

+    Header sigh = NULL;

+

+    rpmRC rc = rpmLeadRead(fd, &msg;;

+    if (rc != RPMRC_OK)

+	goto exit;

+

+    rc = hdrblobRead(fd, 1, 0, RPMTAG_HEADERSIGNATURES, sigblob, &msg;;

+    if (rc != RPMRC_OK)

+	goto exit;

+

+    rc = hdrblobRead(fd, 1, 1, RPMTAG_HEADERIMMUTABLE, blob, &msg;;

+    if (rc != RPMRC_OK)

+	goto exit;

+

+    rc = hdrblobImport(sigblob, 0, &sigh, &msg;;

+    if (rc)

+	goto exit;

+    rc = hdrblobImport(blob, 0, &h, &msg;;

+    if (rc)

+	goto exit;

+    *sigp = headerLink(sigh);

+    *hdrp = headerLink(h);

+

+exit:

+    if (rc != RPMRC_OK && msg)

+	rpmlog(RPMLOG_ERR, "%s: %s\n", Fdescr(fd), msg);

+    hdrblobFree(sigblob);

+    hdrblobFree(blob);

+    headerFree(sigh);

+    headerFree(h);

+    free(msg);

+

+    return rc;

+}

diff --git a/lib/rpmlib.h b/lib/rpmlib.h

index 72ee724e8..4f1a24d14 100644

--- a/lib/rpmlib.h

+++ b/lib/rpmlib.h

@@ -156,6 +156,15 @@ rpmRC rpmReadHeader(rpmts ts, FD_t fd, Header *hdrp, char ** msg);

 rpmRC rpmReadPackageFile(rpmts ts, FD_t fd,

 		const char * fn, Header * hdrp);

+/** \ingroup header

+ * Return package signature, header from file handle, no verification.

+ * @param fd		file handle

+ * @param[out] sigp		address of header (or NULL)

+ * @param[out] hdrp		address of header (or NULL)

+ * @return		RPMRC_OK on success

+ */

+rpmRC rpmReadPackageRaw(FD_t fd, Header * sigp, Header * hdrp);

+

 /** \ingroup rpmtrans

  * Install source package.

  * @param ts		transaction set

diff --git a/lib/rpmplugins.c b/lib/rpmplugins.c

index 62d75c4cf..c5084d398 100644

--- a/lib/rpmplugins.c

+++ b/lib/rpmplugins.c

@@ -356,13 +356,28 @@ rpmRC rpmpluginsCallFsmFilePre(rpmPlugins plugins, rpmfi fi, const char *path,

     plugin_fsm_file_pre_func hookFunc;

     int i;

     rpmRC rc = RPMRC_OK;

+    rpmRC hook_rc;

     for (i = 0; i < plugins->count; i++) {

 	rpmPlugin plugin = plugins->plugins[i];

 	RPMPLUGINS_SET_HOOK_FUNC(fsm_file_pre);

-	if (hookFunc && hookFunc(plugin, fi, path, file_mode, op) == RPMRC_FAIL) {

-	    rpmlog(RPMLOG_ERR, "Plugin %s: hook fsm_file_pre failed\n", plugin->name);

-	    rc = RPMRC_FAIL;

+	if (hookFunc) {

+	    hook_rc = hookFunc(plugin, fi, path, file_mode, op);

+	    if (hook_rc == RPMRC_FAIL) {

+		rpmlog(RPMLOG_ERR, "Plugin %s: hook fsm_file_pre failed\n", plugin->name);

+		rc = RPMRC_FAIL;

+	    } else if (hook_rc == RPMRC_PLUGIN_CONTENTS && rc != RPMRC_FAIL) {

+		if (rc == RPMRC_PLUGIN_CONTENTS) {

+		    /*

+		    Another plugin already said it'd handle contents. It's undefined how

+		    these would combine, so treat this as a failure condition.

+		    */

+		    rc = RPMRC_FAIL;

+		} else {

+		    /* Plugin will handle content */

+		    rc = RPMRC_PLUGIN_CONTENTS;

+		}

+	    }

 	}

     }

diff --git a/lib/rpmte.c b/lib/rpmte.c

index fe9782953..ba06c2985 100644

--- a/lib/rpmte.c

+++ b/lib/rpmte.c

@@ -422,6 +422,11 @@ FD_t rpmteSetFd(rpmte te, FD_t fd)

     return NULL;

 }

+FD_t rpmteFd(rpmte te)

+{

+    return (te != NULL ? te->fd : NULL);

+}

+

 fnpyKey rpmteKey(rpmte te)

 {

     return (te != NULL ? te->key : NULL);

diff --git a/lib/rpmte.h b/lib/rpmte.h

index 81acf7a19..6fc0a9f91 100644

--- a/lib/rpmte.h

+++ b/lib/rpmte.h

@@ -209,6 +209,8 @@ const char * rpmteNEVR(rpmte te);

  */

 const char * rpmteNEVRA(rpmte te);

+FD_t rpmteFd(rpmte te);

+

 /** \ingroup rpmte

  * Retrieve key from transaction element.

  * @param te		transaction element

diff --git a/lib/rpmtypes.h b/lib/rpmtypes.h

index e8e69b506..af2611e9e 100644

--- a/lib/rpmtypes.h

+++ b/lib/rpmtypes.h

@@ -106,7 +106,8 @@ typedef	enum rpmRC_e {

     RPMRC_NOTFOUND	= 1,	/*!< Generic not found code. */

     RPMRC_FAIL		= 2,	/*!< Generic failure code. */

     RPMRC_NOTTRUSTED	= 3,	/*!< Signature is OK, but key is not trusted. */

-    RPMRC_NOKEY		= 4	/*!< Public key is unavailable. */

+    RPMRC_NOKEY		= 4,	/*!< Public key is unavailable. */

+    RPMRC_PLUGIN_CONTENTS = 5     /*!< fsm_file_pre plugin is handling content */

 } rpmRC;

 #ifdef __cplusplus

diff --git a/macros.in b/macros.in

index 5778a1f58..15a28c2d2 100644

--- a/macros.in

+++ b/macros.in

@@ -1175,6 +1175,7 @@ package or when debugging this package.\

 # Transaction plugin macros

 %__plugindir		%{_libdir}/rpm-plugins

+%__transaction_reflink		%{__plugindir}/reflink.so

 %__transaction_systemd_inhibit	%{__plugindir}/systemd_inhibit.so

 %__transaction_selinux		%{__plugindir}/selinux.so

 %__transaction_syslog		%{__plugindir}/syslog.so

diff --git a/plugins/Makefile.am b/plugins/Makefile.am

index 963d53db4..a21401966 100644

--- a/plugins/Makefile.am

+++ b/plugins/Makefile.am

@@ -33,6 +33,10 @@ prioreset_la_SOURCES = prioreset.c

 prioreset_la_LIBADD = $(top_builddir)/lib/librpm.la $(top_builddir)/rpmio/librpmio.la

 plugins_LTLIBRARIES += prioreset.la

+reflink_la_SOURCES = reflink.c

+reflink_la_LIBADD = $(top_builddir)/lib/librpm.la $(top_builddir)/rpmio/librpmio.la

+plugins_LTLIBRARIES += reflink.la

+

 syslog_la_SOURCES = syslog.c

 syslog_la_LIBADD = $(top_builddir)/lib/librpm.la $(top_builddir)/rpmio/librpmio.la

 plugins_LTLIBRARIES += syslog.la

diff --git a/plugins/reflink.c b/plugins/reflink.c

new file mode 100644

index 000000000..d7f19acd9

--- /dev/null

+++ b/plugins/reflink.c

@@ -0,0 +1,340 @@

+#include "system.h"

+

+#include <errno.h>

+#include <sys/resource.h>

+#include <unistd.h>

+#include <sys/types.h>

+#include <sys/stat.h>

+#include <fcntl.h>

+#if defined(__linux__)

+#include <linux/fs.h>        /* For FICLONE */

+#endif

+

+#include <rpm/rpmlog.h>

+#include "lib/rpmlib.h"

+#include "lib/rpmplugin.h"

+#include "lib/rpmte_internal.h"

+#include <rpm/rpmfileutil.h>

+#include "rpmio/rpmio_internal.h"

+

+

+#include "debug.h"

+

+#include <sys/ioctl.h>

+

+/* use hash table to remember inode -> ix (for rpmfilesFN(ix)) lookups */

+#undef HASHTYPE

+#undef HTKEYTYPE

+#undef HTDATATYPE

+#define HASHTYPE inodeIndexHash

+#define HTKEYTYPE rpm_ino_t

+#define HTDATATYPE int

+#include "lib/rpmhash.H"

+#include "lib/rpmhash.C"

+

+/*

+We use this in find to indicate a key wasn't found. This is an unrecoverable

+error, but we can at least show a decent error. 0 is never a valid offset

+because it's the offset of the start of the file.

+*/

+#define NOT_FOUND 0

+

+#define BUFFER_SIZE (1024 * 128)

+

+/* magic value at end of file (64 bits) that indicates this is a transcoded rpm */

+#define MAGIC 3472329499408095051

+

+struct reflink_state_s {

+  /* Stuff that's used across rpms */

+  long fundamental_block_size;

+  char *buffer;

+

+  /* stuff that's used/updated per psm */

+  uint32_t keys, keysize;

+

+  // table for current rpm, keys * (keysize + sizeof(rpm_loff_t))

+  unsigned char *table;

+  FD_t fd;

+  rpmfiles files;

+  inodeIndexHash inodeIndexes;

+};

+

+typedef struct reflink_state_s * reflink_state;

+

+static int inodeCmp(rpm_ino_t a, rpm_ino_t b)

+{

+    return (a != b);

+}

+

+static unsigned int inodeId(rpm_ino_t a)

+{

+    /* rpm_ino_t is uint32_t so maps safely to unsigned int */

+    return (unsigned int)a;

+}

+

+static rpmRC reflink_init(rpmPlugin plugin, rpmts ts) {

+  reflink_state state = rcalloc(1, sizeof(struct reflink_state_s));

+

+  /*

+  IOCTL-FICLONERANGE(2): ...Disk filesystems generally require the offset and

+  length arguments to be aligned to the fundamental block size.

+

+  The value of "fundamental block size" is directly related to the system's

+  page size, so we should use that.

+  */

+  state->fundamental_block_size = sysconf(_SC_PAGESIZE);

+  state->buffer = rcalloc(1, BUFFER_SIZE);

+  rpmPluginSetData(plugin, state);

+

+  return RPMRC_OK;

+}

+

+static void reflink_cleanup(rpmPlugin plugin) {

+  reflink_state state = rpmPluginGetData(plugin);

+  free(state->buffer);

+  free(state);

+}

+

+static rpmRC reflink_psm_pre(rpmPlugin plugin, rpmte te) {

+    reflink_state state = rpmPluginGetData(plugin);

+    state->fd = rpmteFd(te);

+    if (state->fd == 0) {

+      rpmlog(RPMLOG_DEBUG, _("reflink: fd = 0, no install\n"));

+      return RPMRC_OK;

+    }

+    rpm_loff_t current = Ftell(state->fd);

+    uint64_t magic;

+    if (Fseek(state->fd, -(sizeof(magic)), SEEK_END) < 0) {

+      rpmlog(RPMLOG_ERR, _("reflink: failed to seek for magic\n"));

+      if (Fseek(state->fd, current, SEEK_SET) < 0) {

+        /* yes this gets a bit repetitive */

+        rpmlog(RPMLOG_ERR, _("reflink: unable to seek back to original location\n"));

+      }

+      return RPMRC_FAIL;

+    }

+    size_t len = sizeof(magic);

+    if (Fread(&magic, len, 1, state->fd) != len) {

+      rpmlog(RPMLOG_ERR, _("reflink: unable to read magic\n"));

+      if (Fseek(state->fd, current, SEEK_SET) < 0) {

+        rpmlog(RPMLOG_ERR, _("reflink: unable to seek back to original location\n"));

+      }

+      return RPMRC_FAIL;

+    }

+    if (magic != MAGIC) {

+      rpmlog(RPMLOG_DEBUG, _("reflink: not transcoded\n"));

+      if (Fseek(state->fd, current, SEEK_SET) < 0) {

+        rpmlog(RPMLOG_ERR, _("reflink: unable to seek back to original location\n"));

+        return RPMRC_FAIL;

+      }

+      return RPMRC_OK;

+    }

+    rpmlog(RPMLOG_DEBUG, _("reflink: *is* transcoded\n"));

+    Header h = rpmteHeader(te);

+

+    /* replace/add header that main fsm.c can read */

+    headerDel(h, RPMTAG_PAYLOADFORMAT);

+    headerPutString(h, RPMTAG_PAYLOADFORMAT, "clon");

+    headerFree(h);

+    state->files = rpmteFiles(te);

+    /* tail of file contains offset_table, offset_checksums

+       then magic

+    */

+    if (Fseek(state->fd, -(sizeof(rpm_loff_t) * 2 + sizeof(magic)), SEEK_END) < 0) {

+      rpmlog(RPMLOG_ERR, _("reflink: failed to seek for tail %p\n"), state->fd);

+      return RPMRC_FAIL;

+    }

+    rpm_loff_t table_start;

+    len = sizeof(table_start);

+    if (Fread(&table_start, len, 1, state->fd) != len) {

+      rpmlog(RPMLOG_ERR, _("reflink: unable to read table_start\n"));

+      return RPMRC_FAIL;

+    }

+    if (Fseek(state->fd, table_start, SEEK_SET) < 0) {

+      rpmlog(RPMLOG_ERR, _("reflink: unable to seek to table_start\n"));

+      return RPMRC_FAIL;

+    }

+    len = sizeof(state->keys);

+    if (Fread(&state->keys, len, 1, state->fd) != len) {

+      rpmlog(RPMLOG_ERR, _("reflink: unable to read number of keys\n"));

+      return RPMRC_FAIL;

+    }

+    len = sizeof(state->keysize);

+    if (Fread(&state->keysize, len, 1, state->fd) != len) {

+      rpmlog(RPMLOG_ERR, _("reflink: unable to read keysize\n"));

+      return RPMRC_FAIL;

+    }

+    rpmlog(RPMLOG_DEBUG, _("reflink: table_start=0x%lx, keys=%d, keysize=%d\n"), table_start, state->keys, state->keysize);

+    // now get digest table if there is a reason to have one.

+    if (state->keys == 0 || state->keysize == 0) {

+      // no files (or no digests(!))

+      state->table = NULL;

+    } else {

+      int table_size = state->keys * (state->keysize + sizeof(rpm_loff_t));

+      state->table = rcalloc(1, table_size);

+      if (Fread(state->table, table_size, 1, state->fd) != table_size) {

+        rpmlog(RPMLOG_ERR, _("reflink: unable to read table\n"));

+        return RPMRC_FAIL;

+      }

+      state->inodeIndexes = inodeIndexHashCreate(state->keys, inodeId, inodeCmp, NULL, NULL);

+    }

+

+    // seek back to original location

+    // might not be needed if we seek to offset immediately

+    if (Fseek(state->fd, current, SEEK_SET) < 0) {

+      rpmlog(RPMLOG_ERR, _("reflink: unable to seek back to original location\n"));

+      return RPMRC_FAIL;

+    }

+    return RPMRC_OK;

+}

+

+static rpmRC reflink_psm_post(rpmPlugin plugin, rpmte te, int res)

+{

+    reflink_state state = rpmPluginGetData(plugin);

+    state->files = rpmfilesFree(state->files);

+    if (state->table) {

+      free(state->table);

+      state->table = NULL;

+    }

+    if (state->inodeIndexes) {

+      inodeIndexHashFree(state->inodeIndexes);

+      state->inodeIndexes = NULL;

+    }

+    return RPMRC_OK;

+}

+

+

+// have a prototype, warnings system

+rpm_loff_t find(const unsigned char *digest, reflink_state state);

+

+rpm_loff_t find(const unsigned char *digest, reflink_state state) {

+# if defined(__GNUC__)

+  /* GCC nested function because bsearch's comparison function can't access

+     state-keysize otherwise

+  */

+  int cmpdigest(const void *k1, const void *k2) {

+    rpmlog(RPMLOG_DEBUG, _("reflink: cmpdigest k1=%p k2=%p\n"), k1, k2);

+    return memcmp(k1, k2, state->keysize);

+  }

+# endif

+  rpmlog(RPMLOG_DEBUG, _("reflink: bsearch(key=%p, base=%p, nmemb=%d, size=%lu)\n"), digest, state->table, state->keys, state->keysize + sizeof(rpm_loff_t));

+  char *entry = bsearch(digest, state->table, state->keys, state->keysize + sizeof(rpm_loff_t), cmpdigest);

+  if (entry == NULL) {

+    return NOT_FOUND;

+  }

+  rpm_loff_t offset = *(rpm_loff_t *)(entry + state->keysize);

+  return offset;

+}

+

+static rpmRC reflink_fsm_file_pre(rpmPlugin plugin, rpmfi fi, const char* path, mode_t file_mode, rpmFsmOp op)

+{

+    struct file_clone_range fcr;

+    rpm_loff_t size;

+    int dst, rc;

+    int *hlix;

+

+    reflink_state state = rpmPluginGetData(plugin);

+    if (state->table == NULL) {

+        // no table means rpm is not in reflink format, so leave. Now.

+        return RPMRC_OK;

+    }

+    if (op == FA_TOUCH) {

+        // we're not overwriting an existing file

+        return RPMRC_OK;

+    }

+    fcr.dest_offset = 0;

+    if (S_ISREG(file_mode) && !(rpmfiFFlags(fi) & RPMFILE_GHOST)) {

+      rpm_ino_t inode = rpmfiFInode(fi);

+      /* check for hard link entry in table. GetEntry overwrites hlix with the address of the first match */

+      if (inodeIndexHashGetEntry(state->inodeIndexes, inode, &hlix, NULL, NULL)) {

+        // entry is in table, use hard link

+        char *fn = rpmfilesFN(state->files, hlix[0]);

+        if (link(fn, path) != 0) {

+          rpmlog(RPMLOG_ERR, _("reflink: Unable to hard link %s -> %s due to %s\n"), fn, path, strerror(errno));

+          free(fn);

+          return RPMRC_FAIL;

+        }

+        free(fn);

+        return RPMRC_PLUGIN_CONTENTS;

+      }

+      /* if we didn't hard link, then we'll track this inode as being created soon */

+      if (rpmfiFNlink(fi) > 1) {

+        /* minor optimization: only store files with more than one link */

+        inodeIndexHashAddEntry(state->inodeIndexes, inode, rpmfiFX(fi));

+      }

+      /* derived from wfd_open in fsm.c */

+      mode_t old_umask = umask(0577);

+      dst = open(path, O_WRONLY | O_CREAT | O_EXCL, S_IRUSR);

+      umask(old_umask);

+      if (dst == -1) {

+          rpmlog(RPMLOG_ERR, _("reflink: Unable to open %s for writing due to %s, flags = %x\n"), path, strerror(errno), rpmfiFFlags(fi));

+          return RPMRC_FAIL;

+      }

+      size = rpmfiFSize(fi);

+      if (size > 0) {

+          /* round src_length down to fundamental_block_size multiple */

+          fcr.src_length = size / state->fundamental_block_size * state->fundamental_block_size;

+          if ((size % state->fundamental_block_size) > 0) {

+              /* round up to next fundamental_block_size. We expect the data in the rpm to be similarly padded */

+              fcr.src_length += state->fundamental_block_size;

+          }

+          fcr.src_fd = Fileno(state->fd);

+          if (fcr.src_fd == -1) {

+            close(dst);

+            rpmlog(RPMLOG_ERR, _("reflink: src fd lookup failed\n"));

+            return RPMRC_FAIL;

+          }

+          fcr.src_offset = find(rpmfiFDigest(fi, NULL, NULL), state);

+          if (fcr.src_offset == NOT_FOUND) {

+            close(dst);