va_list ap;
int eek = 0;
- va_start(ap, fmt);
- if (flags & LOG)
+ if (flags & LOG) {
+ va_start(ap, fmt);
if (vfprintf(logerr, fmt, ap) <= 0)
eek = 1;
+ va_end(ap);
+ }
if (eek)
flags |= ERR; /* failed, force stderr */
- if (flags & ERR)
+ if (flags & ERR) {
+ va_start(ap, fmt);
vfprintf(stderr, fmt, ap);
- else if (flags & OUT)
+ va_end(ap);
+ } else if (flags & OUT) {
+ va_start(ap, fmt);
vfprintf(stdout, fmt, ap);
- va_end(ap);
+ va_end(ap);
+ }
if (flags & PRE) {
do_message(flags & ~PRE, 0, ": %s\n", strerror(code));
}
void
-handler()
+handler(int sig)
{
pid_t pid = getpid();
int status, i;
wbuf *
wbuf_init(wbuf *buf, int data_size, int data_align, int min_io_size, int id)
{
- buf->id = id;
- if ((buf->data = memalign(data_align, data_size)) == NULL)
- return NULL;
+ ASSERT(data_size % BBSIZE == 0);
+ while ((buf->data = memalign(data_align, data_size)) == NULL) {
+ data_size >>= 1;
+ if (data_size < min_io_size)
+ return NULL;
+ }
ASSERT(min_io_size % BBSIZE == 0);
buf->min_io_size = min_io_size;
- buf->size = MAX(data_size, 2*min_io_size);
+ buf->size = data_size;
+ buf->id = id;
return buf;
}
off = XFS_AG_DADDR(mp, agno, XFS_SB_DADDR);
buf->position = (xfs_off_t) off * (xfs_off_t) BBSIZE;
length = buf->length = first_agbno * blocksize;
-
+
/* handle alignment stuff */
newpos = rounddown(buf->position, (xfs_off_t) buf->min_io_size);
read_wbuf(fd, buf, mp);
ASSERT(buf->length >= length);
- ag->xfs_sb = (xfs_sb_t *) (buf->data + diff);
- ASSERT(INT_GET(ag->xfs_sb->sb_magicnum, ARCH_CONVERT)==XFS_SB_MAGIC);
+ ag->xfs_sb = (xfs_dsb_t *) (buf->data + diff);
+ ASSERT(be32_to_cpu(ag->xfs_sb->sb_magicnum) == XFS_SB_MAGIC);
ag->xfs_agf = (xfs_agf_t *) (buf->data + diff + sectorsize);
- ASSERT(INT_GET(ag->xfs_agf->agf_magicnum, ARCH_CONVERT)==XFS_AGF_MAGIC);
- ag->xfs_agi = (xfs_agi_t *) (buf->data + diff + 2*sectorsize);
- ASSERT(INT_GET(ag->xfs_agi->agi_magicnum, ARCH_CONVERT)==XFS_AGI_MAGIC);
- ag->xfs_agfl = (xfs_agfl_t *) (buf->data + diff + 3*sectorsize);
+ ASSERT(be32_to_cpu(ag->xfs_agf->agf_magicnum) == XFS_AGF_MAGIC);
+ ag->xfs_agi = (xfs_agi_t *) (buf->data + diff + 2 * sectorsize);
+ ASSERT(be32_to_cpu(ag->xfs_agi->agi_magicnum) == XFS_AGI_MAGIC);
+ ag->xfs_agfl = (xfs_agfl_t *) (buf->data + diff + 3 * sectorsize);
}
xfs_agnumber_t num_ags, agno;
xfs_agblock_t bno;
xfs_daddr_t begin, next_begin, ag_begin, new_begin, ag_end;
- xfs_alloc_block_t *block;
+ struct xfs_btree_block *block;
xfs_alloc_ptr_t *ptr;
xfs_alloc_rec_t *rec_ptr;
extern char *optarg;
}
wbuf_align = d.d_mem;
- wbuf_size = d.d_maxiosz;
+ 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 */
- wbuf_align = 4096*4;
- wbuf_size = 1024 * 4000;
+ wbuf_align = getpagesize();
+ wbuf_size = 1 * 1024 * 1024;
wbuf_miniosize = -1; /* set after mounting source fs */
}
/* prepare the libxfs_init structure */
memset(&xargs, 0, sizeof(xargs));
- xargs.notvolmsg = "oh no %s";
+ xargs.isdirect = LIBXFS_DIRECT;
xargs.isreadonly = LIBXFS_ISREADONLY;
- xargs.notvolok = 1;
if (source_is_file) {
xargs.dname = source_name;
sbp = libxfs_readbuf(xargs.ddev, XFS_SB_DADDR, 1, 0);
memset(&mbuf, 0, sizeof(xfs_mount_t));
sb = &mbuf.m_sb;
- libxfs_xlate_sb(XFS_BUF_PTR(sbp), sb, 1, XFS_SB_ALL_BITS);
+ libxfs_sb_from_disk(sb, XFS_BUF_TO_SBP(sbp));
mp = libxfs_mount(&mbuf, sb, xargs.ddev, xargs.logdev, xargs.rtdev, 1);
if (mp == NULL) {
for (i = 0; i < num_targets; i++) {
int write_last_block = 0;
-
+
if (stat64(target[i].name, &statbuf) < 0) {
/* ok, assume it's a file and create it */
}
}
} else {
- char *lb[XFS_MAX_SECTORSIZE] = { 0 };
+ char *lb[XFS_MAX_SECTORSIZE] = { NULL };
off64_t off;
/* ensure device files are sufficiently large */
exit(1);
}
/* need to start out blocking */
- pthread_mutex_lock(&mainwait);
+ pthread_mutex_lock(&mainwait);
/* set up sigchild signal handler */
for (i = 0, tcarg = targ; i < num_targets; i++, tcarg++) {
if (!duplicate)
- uuid_generate(tcarg->uuid);
+ platform_uuid_generate(&tcarg->uuid);
else
- uuid_copy(tcarg->uuid, mp->m_sb.sb_uuid);
+ platform_uuid_copy(&tcarg->uuid, &mp->m_sb.sb_uuid);
if (pthread_mutex_init(&tcarg->wait, NULL) != 0) {
do_log(_("Error creating thread mutex %d\n"), i);
exit(1);
}
/* need to start out blocking */
- pthread_mutex_lock(&tcarg->wait);
+ pthread_mutex_lock(&tcarg->wait);
}
for (i = 0, tcarg = targ; i < num_targets; i++, tcarg++) {
- (__uint64_t)mp->m_sb.sb_fdblocks + 10 * num_ags));
kids = num_targets;
- block = (xfs_alloc_block_t *) btree_buf.data;
+ block = (struct xfs_btree_block *) btree_buf.data;
for (agno = 0; agno < num_ags && kids > 0; agno++) {
/* read in first blocks of the ag */
/* set the in_progress bit for the first AG */
if (agno == 0)
- INT_SET(ag_hdr.xfs_sb->sb_inprogress, ARCH_CONVERT, 1);
+ ag_hdr.xfs_sb->sb_inprogress = 1;
/* save what we need (agf) in the btree buffer */
- bcopy(ag_hdr.xfs_agf, btree_buf.data, source_sectorsize);
+ memmove(btree_buf.data, ag_hdr.xfs_agf, source_sectorsize);
ag_hdr.xfs_agf = (xfs_agf_t *) btree_buf.data;
btree_buf.length = source_blocksize;
/* traverse btree until we get to the leftmost leaf node */
- bno = INT_GET(ag_hdr.xfs_agf->agf_roots[XFS_BTNUM_BNOi],
- ARCH_CONVERT);
+ bno = be32_to_cpu(ag_hdr.xfs_agf->agf_roots[XFS_BTNUM_BNOi]);
current_level = 0;
- btree_levels = INT_GET(
- ag_hdr.xfs_agf->agf_levels[XFS_BTNUM_BNOi],
- ARCH_CONVERT);
+ btree_levels = be32_to_cpu(ag_hdr.xfs_agf->
+ agf_levels[XFS_BTNUM_BNOi]);
ag_end = XFS_AGB_TO_DADDR(mp, agno,
- INT_GET(ag_hdr.xfs_agf->agf_length,ARCH_CONVERT) - 1)
- + source_blocksize/BBSIZE;
+ be32_to_cpu(ag_hdr.xfs_agf->agf_length) - 1)
+ + source_blocksize / BBSIZE;
for (;;) {
/* none of this touches the w_buf buffer */
btree_buf.length = source_blocksize;
read_wbuf(source_fd, &btree_buf, mp);
- block = (xfs_alloc_block_t *) ((char *) btree_buf.data
- + pos - btree_buf.position);
+ block = (struct xfs_btree_block *)
+ ((char *)btree_buf.data +
+ pos - btree_buf.position);
- ASSERT(INT_GET(block->bb_magic,ARCH_CONVERT) ==
- XFS_ABTB_MAGIC);
+ ASSERT(be32_to_cpu(block->bb_magic) == XFS_ABTB_MAGIC);
- if (INT_GET(block->bb_level,ARCH_CONVERT) == 0)
+ if (be16_to_cpu(block->bb_level) == 0)
break;
- ptr = XFS_BTREE_PTR_ADDR(sourceb_blocksize, xfs_alloc,
- block, 1, mp->m_alloc_mxr[1]),
-
- bno = INT_GET(ptr[0], ARCH_CONVERT);
+ ptr = XFS_ALLOC_PTR_ADDR(mp, block, 1,
+ mp->m_alloc_mxr[1]);
+ bno = be32_to_cpu(ptr[0]);
}
/* align first data copy but don't overwrite ag header */
/* handle the rest of the ag */
for (;;) {
- if (INT_GET(block->bb_level,ARCH_CONVERT) != 0) {
+ if (be16_to_cpu(block->bb_level) != 0) {
do_log(
_("WARNING: source filesystem inconsistent.\n"));
do_log(
exit(1);
}
- rec_ptr = XFS_BTREE_REC_ADDR(source_blocksize,
- xfs_alloc, block, 1, mp->m_alloc_mxr[0]);
-
- for (i = 0;
- i < INT_GET(block->bb_numrecs,ARCH_CONVERT);
- i++, rec_ptr++) {
+ rec_ptr = XFS_ALLOC_REC_ADDR(mp, block, 1);
+ for (i = 0; i < be16_to_cpu(block->bb_numrecs);
+ i++, rec_ptr++) {
/* calculate in daddr's */
begin = next_begin;
* range bigger than required
*/
- sizeb = XFS_AGB_TO_DADDR(mp, agno,
- INT_GET(rec_ptr->ar_startblock,
- ARCH_CONVERT)) - begin;
+ sizeb = XFS_AGB_TO_DADDR(mp, agno,
+ be32_to_cpu(rec_ptr->ar_startblock)) -
+ begin;
size = roundup(sizeb <<BBSHIFT, wbuf_miniosize);
if (size > 0) {
/* copy extent */
/* round next starting point down */
new_begin = XFS_AGB_TO_DADDR(mp, agno,
- INT_GET(rec_ptr->ar_startblock,
- ARCH_CONVERT) +
- INT_GET(rec_ptr->ar_blockcount,
- ARCH_CONVERT));
+ be32_to_cpu(rec_ptr->ar_startblock) +
+ be32_to_cpu(rec_ptr->ar_blockcount));
next_begin = rounddown(new_begin,
w_buf.min_io_size >> BBSHIFT);
}
- if (INT_GET(block->bb_rightsib,ARCH_CONVERT) ==
- NULLAGBLOCK)
+ if (be32_to_cpu(block->bb_u.s.bb_rightsib) == NULLAGBLOCK)
break;
/* read in next btree record block */
btree_buf.position = pos = (xfs_off_t)
- XFS_AGB_TO_DADDR(mp, agno,
- INT_GET(block->bb_rightsib,
- ARCH_CONVERT)) << BBSHIFT;
+ XFS_AGB_TO_DADDR(mp, agno, be32_to_cpu(
+ block->bb_u.s.bb_rightsib)) << BBSHIFT;
btree_buf.length = source_blocksize;
/* let read_wbuf handle alignment */
read_wbuf(source_fd, &btree_buf, mp);
- block = (xfs_alloc_block_t *) ((char *) btree_buf.data
- + pos - btree_buf.position);
+ block = (struct xfs_btree_block *)
+ ((char *) btree_buf.data +
+ pos - btree_buf.position);
- ASSERT(INT_GET(block->bb_magic,ARCH_CONVERT) ==
- XFS_ABTB_MAGIC);
+ ASSERT(be32_to_cpu(block->bb_magic) == XFS_ABTB_MAGIC);
}
/*
/* do each thread in turn, each has its own UUID */
for (j = 0, tcarg = targ; j < num_targets; j++) {
- uuid_copy(ag_hdr.xfs_sb->sb_uuid, tcarg->uuid);
+ platform_uuid_copy(&ag_hdr.xfs_sb->sb_uuid,
+ &tcarg->uuid);
do_write(tcarg);
tcarg++;
}
check_errors();
killall();
- pthread_exit(NULL);
+ pthread_exit(NULL);
/*NOTREACHED*/
return 0;
}
/*
* Writes a log header at the start of the log (with the real
* filesystem UUID embedded into it), and writes to all targets.
- *
+ *
* Returns the next buffer-length-aligned disk address.
*/
xfs_off_t
}
offset = libxfs_log_header(p, &buf->owner->uuid,
- XFS_SB_VERSION_HASLOGV2(&mp->m_sb) ? 2 : 1,
+ xfs_sb_version_haslogv2(&mp->m_sb) ? 2 : 1,
mp->m_sb.sb_logsunit, XLOG_FMT,
next_log_chunk, buf);
do_write(buf->owner);
- return logstart + roundup(offset, buf->length);
+ return roundup(logstart + offset, buf->length);
}
/*
projects / thirdparty / xfsprogs-dev.git / blobdiff