@@ -77,6 +77,7 @@ struct iomap;
#include "xfs_refcount_btree.h"
#include "xfs_refcount.h"
#include "xfs_btree_staging.h"
+#include "xfs_ag_resv.h"
#ifndef ARRAY_SIZE
#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
@@ -21,6 +21,8 @@
#define xfs_ag_init_headers libxfs_ag_init_headers
#define xfs_ag_block_count libxfs_ag_block_count
+#define xfs_ag_resv_free libxfs_ag_resv_free
+#define xfs_ag_resv_init libxfs_ag_resv_init
#define xfs_alloc_ag_max_usable libxfs_alloc_ag_max_usable
#define xfs_allocbt_maxrecs libxfs_allocbt_maxrecs
@@ -109,6 +111,7 @@
#define xfs_highbit32 libxfs_highbit32
#define xfs_highbit64 libxfs_highbit64
#define xfs_ialloc_calc_rootino libxfs_ialloc_calc_rootino
+#define xfs_ialloc_read_agi libxfs_ialloc_read_agi
#define xfs_idata_realloc libxfs_idata_realloc
#define xfs_idestroy_fork libxfs_idestroy_fork
#define xfs_iext_lookup_extent libxfs_iext_lookup_extent
@@ -149,6 +149,36 @@ Upgrade a filesystem to support larger timestamps up to the year 2486.
The filesystem cannot be downgraded after this feature is enabled.
Once enabled, the filesystem will not be mountable by older kernels.
This feature was added to Linux 5.10.
+.TP 0.4i
+.B finobt
+Track free inodes through a separate free inode btree index to speed up inode
+allocation on old filesystems.
+This upgrade can fail if any AG has less than 1% free space remaining.
+The filesystem cannot be downgraded after this feature is enabled.
+This feature was added to Linux 3.16.
+.TP 0.4i
+.B reflink
+Enable sharing of file data blocks.
+This upgrade can fail if any AG has less than 2% free space remaining.
+The filesystem cannot be downgraded after this feature is enabled.
+This feature was added to Linux 4.9.
+.TP 0.4i
+.B rmapbt
+Store an index of the owners of on-disk blocks.
+This enables much stronger cross-referencing of various metadata structures
+and online repairs to space usage metadata.
+The filesystem cannot be downgraded after this feature is enabled.
+This upgrade can fail if any AG has less than 5% free space remaining.
+This feature was added to Linux 4.8.
+.TP 0.4i
+.B metadir
+Create a directory tree of metadata inodes instead of storing them all in the
+superblock.
+This is required for reverse mapping btrees and reflink support on the realtime
+device.
+The filesystem cannot be downgraded after this feature is enabled.
+This upgrade can fail if any AG has less than 5% free space remaining.
+This feature is not upstream yet.
.RE
.TP
.BI \-U " uuid"
@@ -50,6 +50,9 @@ int convert_lazy_count; /* Convert lazy-count mode on/off */
int lazy_count; /* What to set if to if converting */
bool add_inobtcount; /* add inode btree counts to AGI */
bool add_bigtime; /* add support for timestamps up to 2486 */
+bool add_finobt; /* add free inode btrees */
+bool add_reflink; /* add reference count btrees */
+bool add_rmapbt; /* add reverse mapping btrees */
/* misc status variables */
@@ -91,6 +91,9 @@ extern int convert_lazy_count; /* Convert lazy-count mode on/off */
extern int lazy_count; /* What to set if to if converting */
extern bool add_inobtcount; /* add inode btree counts to AGI */
extern bool add_bigtime; /* add support for timestamps up to 2486 */
+extern bool add_finobt; /* add free inode btrees */
+extern bool add_reflink; /* add reference count btrees */
+extern bool add_rmapbt; /* add reverse mapping btrees */
/* misc status variables */
@@ -133,7 +133,8 @@ zero_log(
static bool
set_inobtcount(
- struct xfs_mount *mp)
+ struct xfs_mount *mp,
+ struct xfs_sb *new_sb)
{
if (!xfs_sb_version_hascrc(&mp->m_sb)) {
printf(
@@ -153,14 +154,15 @@ set_inobtcount(
}
printf(_("Adding inode btree counts to filesystem.\n"));
- mp->m_sb.sb_features_ro_compat |= XFS_SB_FEAT_RO_COMPAT_INOBTCNT;
- mp->m_sb.sb_features_incompat |= XFS_SB_FEAT_INCOMPAT_NEEDSREPAIR;
+ new_sb->sb_features_ro_compat |= XFS_SB_FEAT_RO_COMPAT_INOBTCNT;
+ new_sb->sb_features_incompat |= XFS_SB_FEAT_INCOMPAT_NEEDSREPAIR;
return true;
}
static bool
set_bigtime(
- struct xfs_mount *mp)
+ struct xfs_mount *mp,
+ struct xfs_sb *new_sb)
{
if (!xfs_sb_version_hascrc(&mp->m_sb)) {
printf(
@@ -174,8 +176,193 @@ set_bigtime(
}
printf(_("Adding large timestamp support to filesystem.\n"));
- mp->m_sb.sb_features_incompat |= (XFS_SB_FEAT_INCOMPAT_NEEDSREPAIR |
- XFS_SB_FEAT_INCOMPAT_BIGTIME);
+ new_sb->sb_features_incompat |= (XFS_SB_FEAT_INCOMPAT_NEEDSREPAIR |
+ XFS_SB_FEAT_INCOMPAT_BIGTIME);
+ return true;
+}
+
+/* Make sure we can actually upgrade this (v5) filesystem. */
+static void
+check_new_v5_geometry(
+ struct xfs_mount *mp,
+ struct xfs_sb *new_sb)
+{
+ struct xfs_sb old_sb;
+ struct xfs_perag *pag;
+ xfs_agnumber_t agno;
+ xfs_ino_t rootino;
+ int min_logblocks;
+ int error;
+
+ /*
+ * Save the current superblock, then copy in the new one to do log size
+ * and root inode checks.
+ */
+ memcpy(&old_sb, &mp->m_sb, sizeof(struct xfs_sb));
+ memcpy(&mp->m_sb, new_sb, sizeof(struct xfs_sb));
+
+ /* Do we have a big enough log? */
+ min_logblocks = libxfs_log_calc_minimum_size(mp);
+ if (old_sb.sb_logblocks < min_logblocks) {
+ printf(
+ _("Filesystem log too small to upgrade filesystem; need %u blocks, have %u.\n"),
+ min_logblocks, old_sb.sb_logblocks);
+ exit(0);
+ }
+
+ rootino = libxfs_ialloc_calc_rootino(mp, new_sb->sb_unit);
+ if (old_sb.sb_rootino != rootino) {
+ printf(
+ _("Cannot upgrade filesystem, root inode (%llu) cannot be moved to %llu.\n"),
+ (unsigned long long)old_sb.sb_rootino,
+ (unsigned long long)rootino);
+ exit(0);
+ }
+
+ /* Make sure we have enough space for per-AG reservations. */
+ for_each_perag(mp, agno, pag) {
+ struct xfs_trans *tp;
+ struct xfs_agf *agf;
+ struct xfs_buf *agi_bp, *agf_bp;
+ unsigned int avail, agblocks;
+
+ /*
+ * Create a dummy transaction so that we can load the AGI and
+ * AGF buffers in memory with the old fs geometry and pin them
+ * there while we try to make a per-AG reservation with the new
+ * geometry.
+ */
+ error = -libxfs_trans_alloc_empty(mp, &tp);
+ if (error)
+ do_error(
+ _("Cannot reserve resources for upgrade check, err=%d.\n"),
+ error);
+
+ error = -libxfs_ialloc_read_agi(mp, tp, agno, &agi_bp);
+ if (error)
+ do_error(
+ _("Cannot read AGI %u for upgrade check, err=%d.\n"),
+ agno, error);
+
+ error = -libxfs_alloc_read_agf(mp, tp, agno, 0, &agf_bp);
+ if (error)
+ do_error(
+ _("Cannot read AGF %u for upgrade check, err=%d.\n"),
+ agno, error);
+ agf = agf_bp->b_addr;
+ agblocks = be32_to_cpu(agf->agf_length);
+
+ error = -libxfs_ag_resv_init(pag, tp);
+ if (error == ENOSPC) {
+ printf(
+ _("Not enough free space would remain in AG %u for metadata.\n"),
+ agno);
+ exit(0);
+ }
+ if (error)
+ do_error(
+ _("Error %d while checking AG %u space reservation.\n"),
+ error, agno);
+
+ /*
+ * Would we have at least 10% free space in this AG after
+ * making per-AG reservations?
+ */
+ avail = pag->pagf_freeblks + pag->pagf_flcount;
+ avail -= pag->pag_meta_resv.ar_reserved;
+ avail -= pag->pag_rmapbt_resv.ar_asked;
+ if (avail < agblocks / 10)
+ printf(
+ _("AG %u will be low on space after upgrade.\n"),
+ agno);
+
+ libxfs_ag_resv_free(pag);
+
+ /*
+ * Mark the per-AG structure as uninitialized so that we don't
+ * trip over stale cached counters after the upgrade, and
+ * release all the resources.
+ */
+ libxfs_trans_cancel(tp);
+ pag->pagf_init = 0;
+ pag->pagi_init = 0;
+ }
+
+ /*
+ * Put back the old superblock.
+ */
+ memcpy(&mp->m_sb, &old_sb, sizeof(struct xfs_sb));
+}
+
+static bool
+set_finobt(
+ struct xfs_mount *mp,
+ struct xfs_sb *new_sb)
+{
+ if (!xfs_sb_version_hascrc(&mp->m_sb)) {
+ printf(
+ _("Free inode btree feature only supported on V5 filesystems.\n"));
+ exit(0);
+ }
+
+ if (xfs_sb_version_hasfinobt(&mp->m_sb)) {
+ printf(_("Filesystem already supports free inode btrees.\n"));
+ exit(0);
+ }
+
+ printf(_("Adding free inode btrees to filesystem.\n"));
+ new_sb->sb_features_ro_compat |= XFS_SB_FEAT_RO_COMPAT_FINOBT;
+ new_sb->sb_features_incompat |= XFS_SB_FEAT_INCOMPAT_NEEDSREPAIR;
+ return true;
+}
+
+static bool
+set_reflink(
+ struct xfs_mount *mp,
+ struct xfs_sb *new_sb)
+{
+ if (!xfs_sb_version_hascrc(&mp->m_sb)) {
+ printf(
+ _("Reflink feature only supported on V5 filesystems.\n"));
+ exit(0);
+ }
+
+ if (xfs_sb_version_hasreflink(&mp->m_sb)) {
+ printf(_("Filesystem already supports reflink.\n"));
+ exit(0);
+ }
+
+ printf(_("Adding reflink support to filesystem.\n"));
+ new_sb->sb_features_ro_compat |= XFS_SB_FEAT_RO_COMPAT_REFLINK;
+ new_sb->sb_features_incompat |= XFS_SB_FEAT_INCOMPAT_NEEDSREPAIR;
+ return true;
+}
+
+static bool
+set_rmapbt(
+ struct xfs_mount *mp,
+ struct xfs_sb *new_sb)
+{
+ if (!xfs_sb_version_hascrc(&mp->m_sb)) {
+ printf(
+ _("Reverse mapping btree feature only supported on V5 filesystems.\n"));
+ exit(0);
+ }
+
+ if (xfs_sb_version_hasreflink(&mp->m_sb)) {
+ printf(
+ _("Reverse mapping btrees cannot be added when reflink is enabled.\n"));
+ exit(0);
+ }
+
+ if (xfs_sb_version_hasrmapbt(&mp->m_sb)) {
+ printf(_("Filesystem already supports reverse mapping btrees.\n"));
+ exit(0);
+ }
+
+ printf(_("Adding reverse mapping btrees to filesystem.\n"));
+ new_sb->sb_features_ro_compat |= XFS_SB_FEAT_RO_COMPAT_RMAPBT;
+ new_sb->sb_features_incompat |= XFS_SB_FEAT_INCOMPAT_NEEDSREPAIR;
return true;
}
@@ -184,16 +371,30 @@ static void
upgrade_filesystem(
struct xfs_mount *mp)
{
+ struct xfs_sb new_sb;
struct xfs_buf *bp;
bool dirty = false;
int error;
+ memcpy(&new_sb, &mp->m_sb, sizeof(struct xfs_sb));
+
if (add_inobtcount)
- dirty |= set_inobtcount(mp);
+ dirty |= set_inobtcount(mp, &new_sb);
if (add_bigtime)
- dirty |= set_bigtime(mp);
-
- if (no_modify || !dirty)
+ dirty |= set_bigtime(mp, &new_sb);
+ if (add_finobt)
+ dirty |= set_finobt(mp, &new_sb);
+ if (add_reflink)
+ dirty |= set_reflink(mp, &new_sb);
+ if (add_rmapbt)
+ dirty |= set_rmapbt(mp, &new_sb);
+
+ if (!dirty)
+ return;
+
+ check_new_v5_geometry(mp, &new_sb);
+ memcpy(&mp->m_sb, &new_sb, sizeof(struct xfs_sb));
+ if (no_modify)
return;
bp = libxfs_getsb(mp);
@@ -49,8 +49,8 @@ bool
rmap_needs_work(
struct xfs_mount *mp)
{
- return xfs_sb_version_hasreflink(&mp->m_sb) ||
- xfs_sb_version_hasrmapbt(&mp->m_sb);
+ return xfs_sb_version_hasreflink(&mp->m_sb) || add_reflink ||
+ xfs_sb_version_hasrmapbt(&mp->m_sb) || add_rmapbt;
}
/*
@@ -67,6 +67,9 @@ enum c_opt_nums {
CONVERT_LAZY_COUNT = 0,
CONVERT_INOBTCOUNT,
CONVERT_BIGTIME,
+ CONVERT_FINOBT,
+ CONVERT_REFLINK,
+ CONVERT_RMAPBT,
C_MAX_OPTS,
};
@@ -74,6 +77,9 @@ static char *c_opts[] = {
[CONVERT_LAZY_COUNT] = "lazycount",
[CONVERT_INOBTCOUNT] = "inobtcount",
[CONVERT_BIGTIME] = "bigtime",
+ [CONVERT_FINOBT] = "finobt",
+ [CONVERT_REFLINK] = "reflink",
+ [CONVERT_RMAPBT] = "rmapbt",
[C_MAX_OPTS] = NULL,
};
@@ -324,6 +330,33 @@ process_args(int argc, char **argv)
_("-c bigtime only supports upgrades\n"));
add_bigtime = true;
break;
+ case CONVERT_FINOBT:
+ if (!val)
+ do_abort(
+ _("-c finobt requires a parameter\n"));
+ if (strtol(val, NULL, 0) != 1)
+ do_abort(
+ _("-c finobt only supports upgrades\n"));
+ add_finobt = true;
+ break;
+ case CONVERT_REFLINK:
+ if (!val)
+ do_abort(
+ _("-c reflink requires a parameter\n"));
+ if (strtol(val, NULL, 0) != 1)
+ do_abort(
+ _("-c reflink only supports upgrades\n"));
+ add_reflink = true;
+ break;
+ case CONVERT_RMAPBT:
+ if (!val)
+ do_abort(
+ _("-c rmapbt requires a parameter\n"));
+ if (strtol(val, NULL, 0) != 1)
+ do_abort(
+ _("-c rmapbt only supports upgrades\n"));
+ add_rmapbt = true;
+ break;
default:
unknown('c', val);
break;