}
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 */
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);
}
}
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();
inomap = xmalloc((mp->m_sb.sb_agcount + rt) * sizeof(*inomap));
inodata = xmalloc(mp->m_sb.sb_agcount * sizeof(*inodata));
inodata_hash_size =
- (int)MAX(MIN(mp->m_sb.sb_icount /
+ (int)max(min(mp->m_sb.sb_icount /
(INODATA_AVG_HASH_LENGTH * mp->m_sb.sb_agcount),
MAX_INODATA_HASH_SIZE),
MIN_INODATA_HASH_SIZE);
goto next_buf;
check_set_dbmap(seqno, agbno,
- (xfs_extlen_t)MAX(1,
+ (xfs_extlen_t)max(1,
inodes_per_buf >>
mp->m_sb.sb_inopblog),
DBM_INODE, DBM_INODE, seqno, bno);
* previous cycle.
*/
len = ((version == 2) && sunit) ? BTOBB(sunit) : 2;
- len = MAX(len, 2);
+ len = max(len, 2);
lsn = xlog_assign_lsn(cycle, 0);
if (cycle == XLOG_INIT_CYCLE)
tail_lsn = lsn;
head->h_prev_block = cpu_to_be32(-1);
head->h_num_logops = cpu_to_be32(1);
head->h_fmt = cpu_to_be32(fmt);
- head->h_size = cpu_to_be32(MAX(sunit, XLOG_BIG_RECORD_BSIZE));
+ head->h_size = cpu_to_be32(max(sunit, XLOG_BIG_RECORD_BSIZE));
head->h_lsn = cpu_to_be64(lsn);
head->h_tail_lsn = cpu_to_be64(tail_lsn);
* minimum (1 hdr blk + 1 data blk). The record length is the total
* minus however many header blocks are required.
*/
- head->h_len = cpu_to_be32(MAX(BBTOB(2), sunit) - hdrs * BBSIZE);
+ head->h_len = cpu_to_be32(max(BBTOB(2), sunit) - hdrs * BBSIZE);
/*
* Write out the unmount record, pack the first word into the record
* the cycle. We don't need to pack any of these blocks because the
* cycle data in the headers has already been zeroed.
*/
- len = MAX(len, hdrs + 1);
+ len = max(len, hdrs + 1);
for (i = hdrs + 1; i < len; i++) {
p = nextfunc(p, BBSIZE, private);
memset(p, 0, BBSIZE);
* memmove to ensure 8-byte alignment for the long longs in
* buf_log_format_t structure
*/
- memmove(&lbuf, *ptr, MIN(sizeof(xfs_buf_log_format_t), len));
+ memmove(&lbuf, *ptr, min(sizeof(xfs_buf_log_format_t), len));
f = &lbuf;
*ptr += len;
xfs_qoff_logformat_t *f;
xfs_qoff_logformat_t lbuf;
- memmove(&lbuf, *ptr, MIN(sizeof(xfs_qoff_logformat_t), len));
+ memmove(&lbuf, *ptr, min(sizeof(xfs_qoff_logformat_t), len));
f = &lbuf;
*ptr += len;
if (len >= sizeof(xfs_qoff_logformat_t)) {
* len can be smaller than struct xfs_inode_log_format
* if format data is split over operations
*/
- memmove(&src_lbuf, *ptr, MIN(sizeof(src_lbuf), len));
+ memmove(&src_lbuf, *ptr, min(sizeof(src_lbuf), len));
(*i)++; /* bump index */
*ptr += len;
if (!continued &&
* memmove to ensure 8-byte alignment for the long longs in
* xfs_dq_logformat_t structure
*/
- memmove(&lbuf, *ptr, MIN(sizeof(xfs_dq_logformat_t), len));
+ memmove(&lbuf, *ptr, min(sizeof(xfs_dq_logformat_t), len));
f = &lbuf;
(*i)++; /* bump index */
*ptr += len;
struct xfs_icreate_log icl_buf = {0};
struct xfs_icreate_log *icl;
- memmove(&icl_buf, *ptr, MIN(sizeof(struct xfs_icreate_log), len));
+ memmove(&icl_buf, *ptr, min(sizeof(struct xfs_icreate_log), len));
icl = &icl_buf;
*ptr += len;
if (print_overwrite) {
printf(_("cycle num overwrites: "));
- for (i=0; i< MIN(bbs, XLOG_HEADER_CYCLE_SIZE / BBSIZE); i++)
+ for (i=0; i< min(bbs, XLOG_HEADER_CYCLE_SIZE / BBSIZE); i++)
printf("%d - 0x%x ",
i,
be32_to_cpu(head->h_cycle_data[i]));
* memmove to ensure 8-byte alignment for the long longs in
* xfs_efd_log_format_t structure
*/
- memmove(&lbuf, *ptr, MIN(core_size, len));
+ memmove(&lbuf, *ptr, min(core_size, len));
f = &lbuf;
*ptr += len;
if (len >= core_size) {
* memmove to ensure 8-byte alignment for the long longs in
* xfs_efd_log_format_t structure
*/
- memmove(&lbuf, *ptr, MIN(core_size, len));
+ memmove(&lbuf, *ptr, min(core_size, len));
f = &lbuf;
*ptr += len;
if (len >= core_size) {
/* size without extents at end */
uint core_size = sizeof(struct xfs_cud_log_format);
- memcpy(&lbuf, *ptr, MIN(core_size, len));
+ memcpy(&lbuf, *ptr, min(core_size, len));
f = &lbuf;
*ptr += len;
if (len >= core_size) {
/* size without extents at end */
uint core_size = sizeof(struct xfs_bud_log_format);
- memcpy(&lbuf, *ptr, MIN(core_size, len));
+ memcpy(&lbuf, *ptr, min(core_size, len));
f = &lbuf;
*ptr += len;
if (len >= core_size) {
stripe unit configured at mkfs time.
.sp
The default value for version 1 logs is 32768, while the
-default value for version 2 logs is MAX(32768, log_sunit).
+default value for version 2 logs is max(32768, log_sunit).
.TP
.BR logdev=device " and " rtdev=device
Use an external log (metadata journal) and/or real-time device.
int maxsz;
fprintf(stderr, _("illegal inode size %d\n"), cfg->inodesize);
- maxsz = MIN(cfg->blocksize / XFS_MIN_INODE_PERBLOCK,
+ maxsz = min(cfg->blocksize / XFS_MIN_INODE_PERBLOCK,
XFS_DINODE_MAX_SIZE);
if (XFS_DINODE_MIN_SIZE == maxsz)
fprintf(stderr,
* So, we reduce the size (in basic blocks) to a perfect
* multiple of the sector size, or 1024, whichever is larger.
*/
- sector_mask = (uint64_t)-1 << (MAX(cfg->sectorlog, 10) - BBSHIFT);
+ sector_mask = (uint64_t)-1 << (max(cfg->sectorlog, 10) - BBSHIFT);
xi->dsize &= sector_mask;
xi->rtsize &= sector_mask;
- xi->logBBsize &= (uint64_t)-1 << (MAX(cfg->lsectorlog, 10) - BBSHIFT);
+ xi->logBBsize &= (uint64_t)-1 << (max(cfg->lsectorlog, 10) - BBSHIFT);
if (!discard)
libxfs_umount(&mount);
ASSERT(min_logblocks);
- min_logblocks = MAX(XFS_MIN_LOG_BLOCKS, min_logblocks);
+ min_logblocks = max(XFS_MIN_LOG_BLOCKS, min_logblocks);
/* if we have lots of blocks, check against XFS_MIN_LOG_BYTES, too */
if (!cli->logsize &&
cfg->dblocks >= (1024*1024*1024) >> cfg->blocklog)
- min_logblocks = MAX(min_logblocks,
+ min_logblocks = max(min_logblocks,
XFS_MIN_LOG_BYTES >> cfg->blocklog);
/*
* XFS_MIN_LOG_BYTES for filesystems smaller than 16G if
* at all possible, ramping up to 128MB at 256GB.
*/
- cfg->logblocks = MIN(XFS_MIN_LOG_BYTES >> cfg->blocklog,
+ cfg->logblocks = min(XFS_MIN_LOG_BYTES >> cfg->blocklog,
min_logblocks * XFS_DFL_LOG_FACTOR);
} else {
/*
}
/* Ensure the chosen size meets minimum log size requirements */
- cfg->logblocks = MAX(min_logblocks, cfg->logblocks);
+ cfg->logblocks = max(min_logblocks, cfg->logblocks);
/*
* Make sure the log fits wholly within an AG
* opened to decide what is the valid maximum size of a log in
* an AG.
*/
- cfg->logblocks = MIN(cfg->logblocks,
+ cfg->logblocks = min(cfg->logblocks,
libxfs_alloc_ag_max_usable(mp) - 1);
/* and now clamp the size to the maximum supported size */
- cfg->logblocks = MIN(cfg->logblocks, XFS_MAX_LOG_BLOCKS);
+ cfg->logblocks = min(cfg->logblocks, XFS_MAX_LOG_BLOCKS);
if ((cfg->logblocks << cfg->blocklog) > XFS_MAX_LOG_BYTES)
cfg->logblocks = XFS_MAX_LOG_BYTES >> cfg->blocklog;
timer = origin;
} else {
time(&now);
- timer = MAX(origin - now, 0);
+ timer = max(origin - now, 0);
}
/*
ASSERT(mp->m_sb.sb_blocksize == bp->b_bcount);
- length = MIN(bp->b_bcount - hdrsize, valuelen - amountdone);
+ length = min(bp->b_bcount - hdrsize, valuelen - amountdone);
memmove(value, bp->b_addr + hdrsize, length);
amountdone += length;
value += length;
nb * sizeof(bmap_ext_t));
bmp[nex].startblock = ext->startblock + (o - ext->startoff);
- bmp[nex].blockcount = MIN(nb, ext->blockcount -
+ bmp[nex].blockcount = min(nb, ext->blockcount -
(bmp[nex].startblock - ext->startblock));
o += bmp[nex].blockcount;
nb -= bmp[nex].blockcount;
if (!btree_copy_cursor_prev(root, tmp_cursor, level + 1))
return -1;
- n = MIN(*index, (BTREE_PTR_MAX - tmp_cursor[level].node->num_keys) / 2);
+ n = min(*index, (BTREE_PTR_MAX - tmp_cursor[level].node->num_keys) / 2);
if (!n || !btree_shift_to_prev(root, level, tmp_cursor, n))
return -1;
if (!btree_copy_cursor_next(root, tmp_cursor, level + 1))
return -1;
- n = MIN(BTREE_KEY_MAX - *index,
+ n = min(BTREE_KEY_MAX - *index,
(BTREE_PTR_MAX - tmp_cursor[level].node->num_keys) / 2);
if (!n || !btree_shift_to_next(root, level, tmp_cursor, n))
return -1;
* we must find the buffer for its cluster, add the appropriate
* offset, and return that.
*/
- cluster_size = MAX(mp->m_inode_cluster_size, mp->m_sb.sb_blocksize);
+ cluster_size = max(mp->m_inode_cluster_size, mp->m_sb.sb_blocksize);
ino_per_cluster = cluster_size / mp->m_sb.sb_inodesize;
cluster_agino = agino & ~(ino_per_cluster - 1);
- cluster_blks = XFS_FSB_TO_DADDR(mp, MAX(1,
+ cluster_blks = XFS_FSB_TO_DADDR(mp, max(1,
mp->m_inode_cluster_size >> mp->m_sb.sb_blocklog));
cluster_daddr = XFS_AGB_TO_DADDR(mp, agno,
XFS_AGINO_TO_AGBNO(mp, cluster_agino));
}
byte_cnt = XFS_SYMLINK_BUF_SPACE(mp, byte_cnt);
- byte_cnt = MIN(pathlen, byte_cnt);
+ byte_cnt = min(pathlen, byte_cnt);
src = bp->b_addr;
if (xfs_sb_version_hascrc(&mp->m_sb)) {
if (blen) {
if (!btree_peek_next(ag_bmap[agno], &key))
return -1;
- *blen = MIN(maxbno, key) - agbno;
+ *blen = min(maxbno, key) - agbno;
}
return *statep;
}
if (!statep)
return -1;
if (blen)
- *blen = MIN(maxbno, key) - agbno;
+ *blen = min(maxbno, key) - agbno;
return *statep;
}
* XFS_INODES_PER_CHUNK (64) inode chunk
*
* Each inode resides in a 64-inode chunk which can be part one or more chunks
- * (MAX(64, inodes-per-block). The fs allocates in chunks (as opposed to 1
+ * (max(64, inodes-per-block). The fs allocates in chunks (as opposed to 1
* chunk) when a block can hold more than one chunk (inodes per block > 64).
* Allocating in one chunk pieces causes us problems when it takes more than
* one fs block to contain an inode chunk because the chunks can start on
num = 0;
if (which == PF_SECONDARY) {
bplist[0] = btree_find(args->io_queue, 0, &fsbno);
- max_fsbno = MIN(fsbno + pf_max_fsbs,
+ max_fsbno = min(fsbno + pf_max_fsbs,
args->last_bno_read);
} else {
bplist[0] = btree_find(args->io_queue,
chunks_pblock = mp->m_sb.sb_inopblock / XFS_INODES_PER_CHUNK;
max_symlink_blocks = libxfs_symlink_blocks(mp, XFS_SYMLINK_MAXLEN);
- inodes_per_cluster = MAX(mp->m_sb.sb_inopblock,
+ inodes_per_cluster = max(mp->m_sb.sb_inopblock,
mp->m_inode_cluster_size >> mp->m_sb.sb_inodelog);
/*
rlim.rlim_cur = rlim.rlim_max;
setrlimit(RLIMIT_AS, &rlim);
/* use approximately 80% of rlimit to avoid overrun */
- max_mem = MIN(max_mem, rlim.rlim_cur / 1280);
+ max_mem = min(max_mem, rlim.rlim_cur / 1280);
} else
- max_mem = MIN(max_mem, (LONG_MAX >> 10) + 1);
+ max_mem = min(max_mem, (LONG_MAX >> 10) + 1);
if (verbose > 1)
do_log(
projects / thirdparty / xfsprogs-dev.git / commitdiff
