+// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2000-2005 Silicon Graphics, Inc.
* All Rights Reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it would be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
-#include <xfs/libxfs.h>
+#include "libxfs.h"
#include <sys/stat.h>
#include <sys/wait.h>
#include <pthread.h>
#include <signal.h>
#include <stdarg.h>
#include "xfs_copy.h"
+#include "libxlog.h"
#define rounddown(x, y) (((x)/(y))*(y))
+#define uuid_equal(s,d) (platform_uuid_compare((s),(d)) == 0)
-extern int platform_check_ismounted(char *, char *, struct stat64 *, int);
+extern int platform_check_ismounted(char *, char *, struct stat *, int);
-int logfd;
-char *logfile_name;
-FILE *logerr;
-char LOGFILE_NAME[] = "/var/tmp/xfs_copy.log.XXXXXX";
+static char *logfile_name;
+static FILE *logerr;
+static char LOGFILE_NAME[] = "/var/tmp/xfs_copy.log.XXXXXX";
-char *source_name;
-int source_fd;
+static char *source_name;
+static int source_fd;
-unsigned int source_blocksize; /* source filesystem blocksize */
-unsigned int source_sectorsize; /* source disk sectorsize */
+static unsigned int source_blocksize; /* source filesystem blocksize */
+static unsigned int source_sectorsize; /* source disk sectorsize */
-xfs_agblock_t first_agbno;
+static xfs_agblock_t first_agbno;
-__uint64_t barcount[11];
+static uint64_t barcount[11];
-unsigned int num_targets;
-target_control *target;
+static unsigned int num_targets;
+static target_control *target;
-wbuf w_buf;
-wbuf btree_buf;
+static wbuf w_buf;
+static wbuf btree_buf;
-pid_t parent_pid;
-unsigned int kids;
+static unsigned int kids;
-thread_control glob_masks;
-thread_args *targ;
+static thread_control glob_masks;
+static thread_args *targ;
-pthread_mutex_t mainwait;
+static pthread_mutex_t mainwait;
#define ACTIVE 1
#define INACTIVE 2
-xfs_off_t write_log_trailer(int fd, wbuf *w, xfs_mount_t *mp);
-xfs_off_t write_log_header(int fd, wbuf *w, xfs_mount_t *mp);
+xfs_off_t write_log_trailer(int fd, wbuf *w, xfs_mount_t *mp);
+xfs_off_t write_log_header(int fd, wbuf *w, xfs_mount_t *mp);
+static int format_logs(struct xfs_mount *);
/* general purpose message reporting routine */
#define PRE 0x08 /* append strerror string */
#define LAST 0x10 /* final message we print */
-void
+static void
+signal_maskfunc(int addset, int newset)
+{
+ sigset_t set;
+
+ sigemptyset(&set);
+ sigaddset(&set, addset);
+ sigprocmask(newset, &set, NULL);
+}
+
+static void
do_message(int flags, int code, const char *fmt, ...)
{
va_list ap;
exit(1); \
} while (0)
-void
+/* workaround craziness in the xlog routines */
+int xlog_recover_do_trans(struct xlog *log, struct xlog_recover *t, int p)
+{
+ return 0;
+}
+
+static void
check_errors(void)
{
int i, first_error = 0;
if (target[i].err_type == 0)
do_log(_("write error"));
else
- do_log(_("lseek64 error"));
+ do_log(_("lseek error"));
do_log(_(" at offset %lld\n"), target[i].position);
}
}
* don't have to worry about alignment and mins because those
* are taken care of when the buffer's read in
*/
-int
-do_write(thread_args *args)
+static int
+do_write(
+ thread_args *args,
+ wbuf *buf)
{
- int res, error = 0;
+ int res;
+ int error = 0;
+
+ if (!buf)
+ buf = &w_buf;
- if (target[args->id].position != w_buf.position) {
- if (lseek64(args->fd, w_buf.position, SEEK_SET) < 0) {
+ if (target[args->id].position != buf->position) {
+ if (lseek(args->fd, buf->position, SEEK_SET) < 0) {
error = target[args->id].err_type = 1;
} else {
- target[args->id].position = w_buf.position;
+ target[args->id].position = buf->position;
}
}
- if ((res = write(target[args->id].fd, w_buf.data,
- w_buf.length)) == w_buf.length) {
+ if ((res = write(target[args->id].fd, buf->data,
+ buf->length)) == buf->length) {
target[args->id].position += res;
} else {
error = 2;
if (error) {
target[args->id].error = errno;
- target[args->id].position = w_buf.position;
+ target[args->id].position = buf->position;
}
return error;
}
-void *
+static void *
begin_reader(void *arg)
{
thread_args *args = arg;
for (;;) {
pthread_mutex_lock(&args->wait);
- if (do_write(args))
+ if (do_write(args, NULL))
goto handle_error;
pthread_mutex_lock(&glob_masks.mutex);
if (--glob_masks.num_working == 0)
return NULL;
}
-void
+static void
handler(int sig)
{
pid_t pid;
target[i].position);
} else {
do_warn(
- _("%s: lseek64 error on target %d \"%s\" at offset %lld\n"),
+ _("%s: lseek error on target %d \"%s\" at offset %lld\n"),
progname, i, target[i].name,
target[i].position);
}
signal(SIGCHLD, handler);
}
-void
+static void
usage(void)
{
fprintf(stderr,
exit(1);
}
-void
-init_bar(__uint64_t source_blocks)
+static void
+init_bar(uint64_t source_blocks)
{
int i;
barcount[i] = (source_blocks/10)*i;
}
-int
-bump_bar(int tenths, __uint64_t numblocks)
+static int
+bump_bar(int tenths, uint64_t numblocks)
{
static char *bar[11] = {
" 0% ",
static xfs_off_t source_position = -1;
-wbuf *
+static wbuf *
wbuf_init(wbuf *buf, int data_size, int data_align, int min_io_size, int id)
{
ASSERT(data_size % BBSIZE == 0);
return NULL;
}
ASSERT(min_io_size % BBSIZE == 0);
+ buf->data_align = data_align;
buf->min_io_size = min_io_size;
buf->size = data_size;
buf->id = id;
return buf;
}
-void
+static void
read_wbuf(int fd, wbuf *buf, xfs_mount_t *mp)
{
int res = 0;
}
if (source_position != buf->position) {
- lres = lseek64(fd, buf->position, SEEK_SET);
+ lres = lseek(fd, buf->position, SEEK_SET);
if (lres < 0LL) {
- do_warn(_("%s: lseek64 failure at offset %lld\n"),
+ do_warn(_("%s: lseek failure at offset %lld\n"),
progname, source_position);
die_perror();
}
buf->length = res;
}
-void
+static void
read_ag_header(int fd, xfs_agnumber_t agno, wbuf *buf, ag_header_t *ag,
xfs_mount_t *mp, int blocksize, int sectorsize)
{
}
-void
+static void
write_wbuf(void)
{
int i;
+ int badness = 0;
/* verify target threads */
for (i = 0; i < num_targets; i++)
for (i = 0; i < num_targets; i++)
if (target[i].state != INACTIVE)
pthread_mutex_unlock(&targ[i].wait); /* wake up */
+ else
+ badness++;
+
+ /*
+ * If all the targets are inactive then there won't be any io
+ * threads left to release mainwait. We're screwed, so bail out.
+ */
+ if (badness == num_targets) {
+ check_errors();
+ exit(1);
+ }
- sigrelse(SIGCHLD);
+ signal_maskfunc(SIGCHLD, SIG_UNBLOCK);
pthread_mutex_lock(&mainwait);
- sighold(SIGCHLD);
+ signal_maskfunc(SIGCHLD, SIG_BLOCK);
}
+static void
+sb_update_uuid(
+ xfs_sb_t *sb, /* Original fs superblock */
+ ag_header_t *ag_hdr, /* AG hdr to update for this copy */
+ thread_args *tcarg) /* Args for this thread, with UUID */
+{
+ /*
+ * If this filesystem has CRCs, the original UUID is stamped into
+ * all metadata. If we don't have an existing meta_uuid field in the
+ * the original filesystem and we are changing the UUID in this copy,
+ * we must copy the original sb_uuid to the sb_meta_uuid slot and set
+ * the incompat flag for the feature on this copy.
+ */
+ if (xfs_sb_version_hascrc(sb) && !xfs_sb_version_hasmetauuid(sb) &&
+ !uuid_equal(&tcarg->uuid, &sb->sb_uuid)) {
+ __be32 feat;
+
+ feat = be32_to_cpu(ag_hdr->xfs_sb->sb_features_incompat);
+ feat |= XFS_SB_FEAT_INCOMPAT_META_UUID;
+ ag_hdr->xfs_sb->sb_features_incompat = cpu_to_be32(feat);
+ platform_uuid_copy(&ag_hdr->xfs_sb->sb_meta_uuid,
+ &sb->sb_uuid);
+ }
+
+ /* Copy the (possibly new) fs-identifier UUID into sb_uuid */
+ platform_uuid_copy(&ag_hdr->xfs_sb->sb_uuid, &tcarg->uuid);
+
+ /* We may have changed the UUID, so update the superblock CRC */
+ if (xfs_sb_version_hascrc(sb))
+ xfs_update_cksum((char *)ag_hdr->xfs_sb, sb->sb_sectsize,
+ XFS_SB_CRC_OFF);
+}
int
main(int argc, char **argv)
{
int i, j;
+ int logfd;
int howfar = 0;
int open_flags;
- xfs_off_t pos, end_pos;
+ xfs_off_t pos;
size_t length;
int c;
- __uint64_t size, sizeb;
- __uint64_t numblocks = 0;
+ uint64_t size, sizeb;
+ uint64_t numblocks = 0;
int wblocks = 0;
int num_threads = 0;
struct dioattr d;
ag_header_t ag_hdr;
xfs_mount_t *mp;
xfs_mount_t mbuf;
+ struct xlog xlog;
xfs_buf_t *sbp;
xfs_sb_t *sb;
xfs_agnumber_t num_ags, agno;
extern int optind;
libxfs_init_t xargs;
thread_args *tcarg;
- struct stat64 statbuf;
+ struct stat statbuf;
progname = basename(argv[0]);
target[i].err_type = 0;
}
- parent_pid = getpid();
-
/* open up source -- is it a file? */
open_flags = O_RDONLY;
die_perror();
}
- if (fstat64(source_fd, &statbuf) < 0) {
+ if (fstat(source_fd, &statbuf) < 0) {
do_log(_("%s: couldn't stat source \"%s\"\n"),
progname, source_name);
die_perror();
}
wbuf_align = d.d_mem;
- wbuf_size = MIN(d.d_maxiosz, 1 * 1024 * 1024);
+ wbuf_size = min(d.d_maxiosz, 1 * 1024 * 1024);
wbuf_miniosize = d.d_miniosz;
} else {
/* set arbitrary I/O params, miniosize at least 1 disk block */
exit(1);
}
- /* prepare the mount structure */
-
memset(&mbuf, 0, sizeof(xfs_mount_t));
+
+ /* We don't yet know the sector size, so read maximal size */
libxfs_buftarg_init(&mbuf, xargs.ddev, xargs.logdev, xargs.rtdev);
- sbp = libxfs_readbuf(mbuf.m_ddev_targp, XFS_SB_DADDR, 1, 0,
- &xfs_sb_buf_ops);
+ sbp = libxfs_readbuf(mbuf.m_ddev_targp, XFS_SB_DADDR,
+ 1 << (XFS_MAX_SECTORSIZE_LOG - BBSHIFT), 0, NULL);
sb = &mbuf.m_sb;
libxfs_sb_from_disk(sb, XFS_BUF_TO_SBP(sbp));
- /*
- * For now, V5 superblock filesystems are not supported without -d;
- * we do not have the infrastructure yet to fix CRCs when a new UUID
- * is generated.
- */
- if (xfs_sb_version_hascrc(sb) && !duplicate) {
- do_log(_("%s: Cannot yet copy V5 fs without '-d'\n"), progname);
- exit(1);
- }
+ /* Do it again, now with proper length and verifier */
+ libxfs_putbuf(sbp);
+ libxfs_purgebuf(sbp);
+ sbp = libxfs_readbuf(mbuf.m_ddev_targp, XFS_SB_DADDR,
+ 1 << (sb->sb_sectlog - BBSHIFT),
+ 0, &xfs_sb_buf_ops);
+ libxfs_putbuf(sbp);
mp = libxfs_mount(&mbuf, sb, xargs.ddev, xargs.logdev, xargs.rtdev, 0);
if (mp == NULL) {
exit(1);
}
+
+ /*
+ * Set up the mount pointer to access the log and check whether the log
+ * is clean. Fail on a dirty or corrupt log in non-duplicate mode
+ * because the log is formatted as part of the copy and we don't want to
+ * destroy data. We also need the current log cycle to format v5
+ * superblock logs correctly.
+ */
+ memset(&xlog, 0, sizeof(struct xlog));
+ mp->m_log = &xlog;
+ c = xlog_is_dirty(mp, mp->m_log, &xargs, 0);
+ if (!duplicate) {
+ if (c == 1) {
+ do_log(_(
+"Error: source filesystem log is dirty. Mount the filesystem to replay the\n"
+"log, unmount and retry xfs_copy.\n"));
+ exit(1);
+ } else if (c < 0) {
+ do_log(_(
+"Error: could not determine the log head or tail of the source filesystem.\n"
+"Mount the filesystem to replay the log or run xfs_repair.\n"));
+ exit(1);
+ }
+ }
+
source_blocksize = mp->m_sb.sb_blocksize;
source_sectorsize = mp->m_sb.sb_sectsize;
for (i = 0; i < num_targets; i++) {
int write_last_block = 0;
- if (stat64(target[i].name, &statbuf) < 0) {
+ if (stat(target[i].name, &statbuf) < 0) {
/* ok, assume it's a file and create it */
do_out(_("Creating file %s\n"), target[i].name);
if (write_last_block) {
/* ensure regular files are correctly sized */
- if (ftruncate64(target[i].fd, mp->m_sb.sb_dblocks *
+ if (ftruncate(target[i].fd, mp->m_sb.sb_dblocks *
source_blocksize)) {
do_log(_("%s: cannot grow data section.\n"),
progname);
progname, target[i].name);
die_perror();
} else {
- wbuf_align = MAX(wbuf_align, d.d_mem);
- wbuf_size = MIN(d.d_maxiosz, wbuf_size);
- wbuf_miniosize = MAX(d.d_miniosz,
+ wbuf_align = max(wbuf_align, d.d_mem);
+ wbuf_size = min(d.d_maxiosz, wbuf_size);
+ wbuf_miniosize = max(d.d_miniosz,
wbuf_miniosize);
}
}
off = mp->m_sb.sb_dblocks * source_blocksize;
off -= sizeof(lb);
- if (pwrite64(target[i].fd, lb, sizeof(lb), off) < 0) {
+ if (pwrite(target[i].fd, lb, sizeof(lb), off) < 0) {
do_log(_("%s: failed to write last block\n"),
progname);
do_log(_("\tIs target \"%s\" too small?\n"),
wblocks = wbuf_size / BBSIZE;
- if (wbuf_init(&btree_buf, MAX(source_blocksize, wbuf_miniosize),
+ if (wbuf_init(&btree_buf, max(source_blocksize, wbuf_miniosize),
wbuf_align, wbuf_miniosize, 1) == NULL) {
do_log(_("Error initializing btree buf 1\n"));
die_perror();
/* set up sigchild signal handler */
signal(SIGCHLD, handler);
- sighold(SIGCHLD);
+ signal_maskfunc(SIGCHLD, SIG_BLOCK);
/* make children */
num_ags = mp->m_sb.sb_agcount;
init_bar(mp->m_sb.sb_blocksize / BBSIZE
- * ((__uint64_t)mp->m_sb.sb_dblocks
- - (__uint64_t)mp->m_sb.sb_fdblocks + 10 * num_ags));
+ * ((uint64_t)mp->m_sb.sb_dblocks
+ - (uint64_t)mp->m_sb.sb_fdblocks + 10 * num_ags));
kids = num_targets;
* range bigger than required
*/
- sizeb = XFS_AGB_TO_DADDR(mp, agno,
- be32_to_cpu(rec_ptr->ar_startblock)) -
+ sizeb = XFS_AGB_TO_DADDR(mp, agno,
+ be32_to_cpu(rec_ptr->ar_startblock)) -
begin;
size = roundup(sizeb <<BBSHIFT, wbuf_miniosize);
if (size > 0) {
((char *) btree_buf.data +
pos - btree_buf.position);
- ASSERT(be32_to_cpu(block->bb_magic) == XFS_ABTB_MAGIC);
+ ASSERT(be32_to_cpu(block->bb_magic) == XFS_ABTB_MAGIC ||
+ be32_to_cpu(block->bb_magic) == XFS_ABTB_CRC_MAGIC);
}
/*
}
if (kids > 0) {
- if (!duplicate) {
-
+ if (!duplicate)
/* write a clean log using the specified UUID */
- for (j = 0, tcarg = targ; j < num_targets; j++) {
- w_buf.owner = tcarg;
- w_buf.length = rounddown(w_buf.size,
- w_buf.min_io_size);
- pos = write_log_header(
- source_fd, &w_buf, mp);
- end_pos = write_log_trailer(
- source_fd, &w_buf, mp);
- w_buf.position = pos;
- memset(w_buf.data, 0, w_buf.length);
-
- while (w_buf.position < end_pos) {
- do_write(tcarg);
- w_buf.position += w_buf.length;
- }
- tcarg++;
- }
- } else {
+ format_logs(mp);
+ else
num_ags = 1;
- }
/* reread and rewrite superblocks (UUID and in-progress) */
/* [backwards, so inprogress bit only updated when done] */
/* do each thread in turn, each has its own UUID */
for (j = 0, tcarg = targ; j < num_targets; j++) {
- platform_uuid_copy(&ag_hdr.xfs_sb->sb_uuid,
- &tcarg->uuid);
- do_write(tcarg);
+ sb_update_uuid(sb, &ag_hdr, tcarg);
+ do_write(tcarg, NULL);
tcarg++;
}
}
}
check_errors();
+ libxfs_umount(mp);
+ libxfs_destroy();
+
return 0;
}
-xfs_caddr_t
-next_log_chunk(xfs_caddr_t p, int offset, void *private)
+static char *
+next_log_chunk(char *p, int offset, void *private)
{
wbuf *buf = (wbuf *)private;
if (buf->length < (int)(p - buf->data) + offset) {
/* need to flush this one, then start afresh */
- do_write(buf->owner);
+ do_write(buf->owner, NULL);
memset(buf->data, 0, buf->length);
return buf->data;
}
xfs_off_t
write_log_header(int fd, wbuf *buf, xfs_mount_t *mp)
{
- xfs_caddr_t p = buf->data;
+ char *p = buf->data;
xfs_off_t logstart;
int offset;
offset = libxfs_log_header(p, &buf->owner->uuid,
xfs_sb_version_haslogv2(&mp->m_sb) ? 2 : 1,
- mp->m_sb.sb_logsunit, XLOG_FMT,
- next_log_chunk, buf);
- do_write(buf->owner);
+ mp->m_sb.sb_logsunit, XLOG_FMT, NULLCOMMITLSN,
+ NULLCOMMITLSN, next_log_chunk, buf);
+ do_write(buf->owner, NULL);
return roundup(logstart + offset, buf->length);
}
read_wbuf(fd, buf, mp);
offset = (int)(logend - buf->position);
memset(buf->data, 0, offset);
- do_write(buf->owner);
+ do_write(buf->owner, NULL);
}
return buf->position;
}
+
+/*
+ * Clear a log by writing a record at the head, the tail and zeroing everything
+ * in between.
+ */
+static void
+clear_log(
+ struct xfs_mount *mp,
+ thread_args *tcarg)
+{
+ xfs_off_t pos;
+ xfs_off_t end_pos;
+
+ w_buf.owner = tcarg;
+ w_buf.length = rounddown(w_buf.size, w_buf.min_io_size);
+ pos = write_log_header(source_fd, &w_buf, mp);
+ end_pos = write_log_trailer(source_fd, &w_buf, mp);
+ w_buf.position = pos;
+ memset(w_buf.data, 0, w_buf.length);
+
+ while (w_buf.position < end_pos) {
+ do_write(tcarg, NULL);
+ w_buf.position += w_buf.length;
+ }
+}
+
+/*
+ * Format the log to a particular cycle number. This is required for version 5
+ * superblock filesystems to provide metadata LSN validity guarantees.
+ */
+static void
+format_log(
+ struct xfs_mount *mp,
+ thread_args *tcarg,
+ wbuf *buf)
+{
+ int logstart;
+ int length;
+ int cycle = XLOG_INIT_CYCLE;
+
+ buf->owner = tcarg;
+ buf->length = buf->size;
+ buf->position = XFS_FSB_TO_DADDR(mp, mp->m_sb.sb_logstart) << BBSHIFT;
+
+ logstart = XFS_FSB_TO_BB(mp, mp->m_sb.sb_logstart);
+ length = XFS_FSB_TO_BB(mp, mp->m_sb.sb_logblocks);
+
+ /*
+ * Bump the cycle number on v5 superblock filesystems to guarantee that
+ * all existing metadata LSNs are valid (behind the current LSN) on the
+ * target fs.
+ */
+ if (xfs_sb_version_hascrc(&mp->m_sb))
+ cycle = mp->m_log->l_curr_cycle + 1;
+
+ /*
+ * Format the entire log into the memory buffer and write it out. If the
+ * write fails, mark the target inactive so the failure is reported.
+ */
+ libxfs_log_clear(NULL, buf->data, logstart, length, &buf->owner->uuid,
+ xfs_sb_version_haslogv2(&mp->m_sb) ? 2 : 1,
+ mp->m_sb.sb_logsunit, XLOG_FMT, cycle, true);
+ if (do_write(buf->owner, buf))
+ target[tcarg->id].state = INACTIVE;
+}
+
+static int
+format_logs(
+ struct xfs_mount *mp)
+{
+ thread_args *tcarg;
+ int i;
+ wbuf logbuf;
+ int logsize;
+
+ if (xfs_sb_version_hascrc(&mp->m_sb)) {
+ logsize = XFS_FSB_TO_B(mp, mp->m_sb.sb_logblocks);
+ if (!wbuf_init(&logbuf, logsize, w_buf.data_align,
+ w_buf.min_io_size, w_buf.id))
+ return -ENOMEM;
+ }
+
+ for (i = 0, tcarg = targ; i < num_targets; i++) {
+ if (xfs_sb_version_hascrc(&mp->m_sb))
+ format_log(mp, tcarg, &logbuf);
+ else
+ clear_log(mp, tcarg);
+ tcarg++;
+ }
+
+ if (xfs_sb_version_hascrc(&mp->m_sb))
+ free(logbuf.data);
+
+ return 0;
+}
projects / thirdparty / xfsprogs-dev.git / blobdiff