xfs: create a blob array data structure

Create a simple 'blob array' data structure for storage of arbitrarily
sized metadata objects that will be used to reconstruct metadata.  For
the intended usage (temporarily storing extended attribute names and
values) we only have to support storing objects and retrieving them.
Use the xfile abstraction to store the attribute information in memory
that can be swapped out.

Signed-off-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Christoph Hellwig <hch@lst.de>

diff --git a/libxfs/Makefile b/libxfs/Makefile
index 9fb53d9cc32cd4961a4895be4c5e5d679a6d02fb..4e8f9a13581879cdf2c33b14ca22027e50cc33a8 100644 (file)
--- a/libxfs/Makefile
+++ b/libxfs/Makefile
@@ -28,6 +28,7 @@ HFILES = \
        linux-err.h \
        topology.h \
        buf_mem.h \
+       xfblob.h \
        xfile.h \
        xfs_ag_resv.h \
        xfs_alloc.h \
@@ -73,6 +74,7 @@ CFILES = buf_mem.c \
        topology.c \
        trans.c \
        util.c \
+       xfblob.c \
        xfile.c \
        xfs_ag.c \
        xfs_ag_resv.c \

diff --git a/libxfs/xfblob.c b/libxfs/xfblob.c
new file mode 100644 (file)
index 0000000..7d8caaa
--- /dev/null
+++ b/libxfs/xfblob.c
@@ -0,0 +1,147 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (c) 2022-2024 Oracle.  All Rights Reserved.
+ * Author: Darrick J. Wong <djwong@kernel.org>
+ */
+#include "libxfs_priv.h"
+#include "libxfs.h"
+#include "libxfs/xfile.h"
+#include "libxfs/xfblob.h"
+
+/*
+ * XFS Blob Storage
+ * ================
+ * Stores and retrieves blobs using an xfile.  Objects are appended to the file
+ * and the offset is returned as a magic cookie for retrieval.
+ */
+
+#define XB_KEY_MAGIC   0xABAADDAD
+struct xb_key {
+       uint32_t                xb_magic;  /* XB_KEY_MAGIC */
+       uint32_t                xb_size;   /* size of the blob, in bytes */
+       loff_t                  xb_offset; /* byte offset of this key */
+       /* blob comes after here */
+} __packed;
+
+/* Initialize a blob storage object. */
+int
+xfblob_create(
+       const char              *description,
+       struct xfblob           **blobp)
+{
+       struct xfblob           *blob;
+       struct xfile            *xfile;
+       int                     error;
+
+       error = xfile_create(description, 0, &xfile);
+       if (error)
+               return error;
+
+       blob = malloc(sizeof(struct xfblob));
+       if (!blob) {
+               error = -ENOMEM;
+               goto out_xfile;
+       }
+
+       blob->xfile = xfile;
+       blob->last_offset = PAGE_SIZE;
+
+       *blobp = blob;
+       return 0;
+
+out_xfile:
+       xfile_destroy(xfile);
+       return error;
+}
+
+/* Destroy a blob storage object. */
+void
+xfblob_destroy(
+       struct xfblob   *blob)
+{
+       xfile_destroy(blob->xfile);
+       kfree(blob);
+}
+
+/* Retrieve a blob. */
+int
+xfblob_load(
+       struct xfblob   *blob,
+       xfblob_cookie   cookie,
+       void            *ptr,
+       uint32_t        size)
+{
+       struct xb_key   key;
+       int             error;
+
+       error = xfile_load(blob->xfile, &key, sizeof(key), cookie);
+       if (error)
+               return error;
+
+       if (key.xb_magic != XB_KEY_MAGIC || key.xb_offset != cookie) {
+               ASSERT(0);
+               return -ENODATA;
+       }
+       if (size < key.xb_size) {
+               ASSERT(0);
+               return -EFBIG;
+       }
+
+       return xfile_load(blob->xfile, ptr, key.xb_size,
+                       cookie + sizeof(key));
+}
+
+/* Store a blob. */
+int
+xfblob_store(
+       struct xfblob   *blob,
+       xfblob_cookie   *cookie,
+       const void      *ptr,
+       uint32_t        size)
+{
+       struct xb_key   key = {
+               .xb_offset = blob->last_offset,
+               .xb_magic = XB_KEY_MAGIC,
+               .xb_size = size,
+       };
+       loff_t          pos = blob->last_offset;
+       int             error;
+
+       error = xfile_store(blob->xfile, &key, sizeof(key), pos);
+       if (error)
+               return error;
+
+       pos += sizeof(key);
+       error = xfile_store(blob->xfile, ptr, size, pos);
+       if (error)
+               goto out_err;
+
+       *cookie = blob->last_offset;
+       blob->last_offset += sizeof(key) + size;
+       return 0;
+out_err:
+       xfile_discard(blob->xfile, blob->last_offset, sizeof(key));
+       return error;
+}
+
+/* Free a blob. */
+int
+xfblob_free(
+       struct xfblob   *blob,
+       xfblob_cookie   cookie)
+{
+       struct xb_key   key;
+       int             error;
+
+       error = xfile_load(blob->xfile, &key, sizeof(key), cookie);
+       if (error)
+               return error;
+
+       if (key.xb_magic != XB_KEY_MAGIC || key.xb_offset != cookie) {
+               ASSERT(0);
+               return -ENODATA;
+       }
+
+       xfile_discard(blob->xfile, cookie, sizeof(key) + key.xb_size);
+       return 0;
+}

diff --git a/libxfs/xfblob.h b/libxfs/xfblob.h
new file mode 100644 (file)
index 0000000..28bf4ab
--- /dev/null
+++ b/libxfs/xfblob.h
@@ -0,0 +1,24 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (c) 2022-2024 Oracle.  All Rights Reserved.
+ * Author: Darrick J. Wong <djwong@kernel.org>
+ */
+#ifndef __XFS_SCRUB_XFBLOB_H__
+#define __XFS_SCRUB_XFBLOB_H__
+
+struct xfblob {
+       struct xfile    *xfile;
+       loff_t          last_offset;
+};
+
+typedef loff_t         xfblob_cookie;
+
+int xfblob_create(const char *descr, struct xfblob **blobp);
+void xfblob_destroy(struct xfblob *blob);
+int xfblob_load(struct xfblob *blob, xfblob_cookie cookie, void *ptr,
+               uint32_t size);
+int xfblob_store(struct xfblob *blob, xfblob_cookie *cookie, const void *ptr,
+               uint32_t size);
+int xfblob_free(struct xfblob *blob, xfblob_cookie cookie);
+
+#endif /* __XFS_SCRUB_XFBLOB_H__ */

diff --git a/libxfs/xfile.c b/libxfs/xfile.c
index 6e0fa809a29654d2f7c3a042607f17180d43b5a4..b4908b49b6d5e03339dea0cbbd8c537373b56d15 100644 (file)
--- a/libxfs/xfile.c
+++ b/libxfs/xfile.c
@@ -391,3 +391,14 @@ xfile_bytes(
 
        return (unsigned long long)statbuf.st_blocks << 9;
 }
+
+/* Discard pages backing a range of the xfile. */
+void
+xfile_discard(
+       struct xfile            *xf,
+       loff_t                  pos,
+       unsigned long long      count)
+{
+       fallocate(xf->fcb->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
+                       pos, count);
+}

diff --git a/libxfs/xfile.h b/libxfs/xfile.h
index 180a42bbbaa2adc17290b169573f0b3bdd0ad8b4..7ee8b90cdf30b461bf79dd0810d7d9a21cdecc55 100644 (file)
--- a/libxfs/xfile.h
+++ b/libxfs/xfile.h
@@ -30,5 +30,6 @@ ssize_t xfile_load(struct xfile *xf, void *buf, size_t count, loff_t pos);
 ssize_t xfile_store(struct xfile *xf, const void *buf, size_t count, loff_t pos);
 
 unsigned long long xfile_bytes(struct xfile *xf);
+void xfile_discard(struct xfile *xf, loff_t pos, unsigned long long count);
 
 #endif /* __LIBXFS_XFILE_H__ */