static int
do_version(xfs_agnumber_t agno, __uint16_t version, __uint32_t features)
{
xfs_sb_t tsb;
if (!get_sb(agno, &tsb))
return 0;
if (xfs_sb_has_mismatched_features2(&tsb)) {
dbprintf(_("Superblock has mismatched features2 fields, "
"skipping modification\n"));
return 0;
}
if ((version & XFS_SB_VERSION_LOGV2BIT) &&
!xfs_sb_version_haslogv2(&tsb)) {
tsb.sb_logsunit = 1;
}
tsb.sb_versionnum = version;
tsb.sb_features2 = features;
tsb.sb_bad_features2 = features;
libxfs_sb_to_disk(iocur_top->data, &tsb);
write_cur();
return 1;
}
void
write_primary_sb(xfs_sb_t *sbp, int size)
{
xfs_dsb_t *buf;
if (no_modify)
return;
buf = memalign(libxfs_device_alignment(), size);
if (buf == NULL) {
do_error(_("failed to memalign superblock buffer\n"));
return;
}
memset(buf, 0, size);
if (lseek64(x.dfd, 0LL, SEEK_SET) != 0LL) {
free(buf);
do_error(_("couldn't seek to offset 0 in filesystem\n"));
}
libxfs_sb_to_disk(buf, sbp, XFS_SB_ALL_BITS);
if (write(x.dfd, buf, size) != size) {
free(buf);
do_error(_("primary superblock write failed!\n"));
}
free(buf);
}
static uuid_t *
do_uuid(xfs_agnumber_t agno, uuid_t *uuid)
{
xfs_sb_t tsb;
static uuid_t uu;
if (!get_sb(agno, &tsb))
return NULL;
if (!uuid) { /* get uuid */
memcpy(&uu, &tsb.sb_uuid, sizeof(uuid_t));
pop_cur();
return &uu;
}
/* set uuid */
if (!xfs_sb_version_hascrc(&tsb))
goto write;
/*
* If we have CRCs, and this UUID differs from that stamped in the
* metadata, set the incompat flag and copy the old one to the
* metadata-specific location.
*
* If we are setting the user-visible UUID back to match the metadata
* UUID, clear the metadata-specific location and the incompat flag.
*/
if (!xfs_sb_version_hasmetauuid(&tsb) &&
!uuid_equal(uuid, &mp->m_sb.sb_meta_uuid)) {
mp->m_sb.sb_features_incompat |= XFS_SB_FEAT_INCOMPAT_META_UUID;
tsb.sb_features_incompat |= XFS_SB_FEAT_INCOMPAT_META_UUID;
memcpy(&tsb.sb_meta_uuid, &tsb.sb_uuid, sizeof(uuid_t));
} else if (xfs_sb_version_hasmetauuid(&tsb) &&
uuid_equal(uuid, &mp->m_sb.sb_meta_uuid)) {
memset(&tsb.sb_meta_uuid, 0, sizeof(uuid_t));
/* Write those zeros now; it's ignored once we clear the flag */
libxfs_sb_to_disk(iocur_top->data, &tsb);
mp->m_sb.sb_features_incompat &=
~XFS_SB_FEAT_INCOMPAT_META_UUID;
tsb.sb_features_incompat &= ~XFS_SB_FEAT_INCOMPAT_META_UUID;
}
write:
memcpy(&tsb.sb_uuid, uuid, sizeof(uuid_t));
libxfs_sb_to_disk(iocur_top->data, &tsb);
write_cur();
return uuid;
}
/*
* update the superblock counters, sync the sb version numbers and
* feature bits to the filesystem, and sync up the on-disk superblock
* to match the incore superblock.
*/
static void
sync_sb(xfs_mount_t *mp)
{
xfs_buf_t *bp;
bp = libxfs_getsb(mp, 0);
if (!bp)
do_error(_("couldn't get superblock\n"));
mp->m_sb.sb_icount = sb_icount;
mp->m_sb.sb_ifree = sb_ifree;
mp->m_sb.sb_fdblocks = sb_fdblocks;
mp->m_sb.sb_frextents = sb_frextents;
update_sb_version(mp);
libxfs_sb_to_disk(XFS_BUF_TO_SBP(bp), &mp->m_sb);
libxfs_writebuf(bp, 0);
}
static char *
do_label(xfs_agnumber_t agno, char *label)
{
size_t len;
xfs_sb_t tsb;
static char lbl[sizeof(tsb.sb_fname) + 1];
if (!get_sb(agno, &tsb))
return NULL;
memset(&lbl[0], 0, sizeof(lbl));
if (!label) { /* get label */
pop_cur();
memcpy(&lbl[0], &tsb.sb_fname, sizeof(tsb.sb_fname));
return &lbl[0];
}
/* set label */
if ((len = strlen(label)) > sizeof(tsb.sb_fname)) {
if (agno == 0)
dbprintf(_("%s: truncating label length from %d to %d\n"),
progname, (int)len, (int)sizeof(tsb.sb_fname));
len = sizeof(tsb.sb_fname);
}
if ( len == 2 &&
(strcmp(label, "\"\"") == 0 ||
strcmp(label, "''") == 0 ||
strcmp(label, "--") == 0) )
label[0] = label[1] = '\0';
memset(&tsb.sb_fname, 0, sizeof(tsb.sb_fname));
memcpy(&tsb.sb_fname, label, len);
memcpy(&lbl[0], &tsb.sb_fname, sizeof(tsb.sb_fname));
libxfs_sb_to_disk(iocur_top->data, &tsb);
write_cur();
return &lbl[0];
}
