roundup
#ifndef roundup
if (*ps + 1 >= roundup(*ps, count_inc)) {
size_t newsz = roundup(*ps + 2, count_inc);
mapsize = roundup(howmany(maxino, NBBY), TP_BSIZE);
start = roundup(start, dos_sectors);
idesc->id_filesize = roundup(idesc->id_filesize, DIRBLKSIZ);
dp->di_size = roundup(dp->di_size, DIRBLKSIZ);
inp->i_isize = roundup(MINDIRSIZE, DIRBLKSIZ);
inp->i_isize = roundup(inp->i_isize, DIRBLKSIZ);
dp->di_size = roundup(inp->i_isize, DIRBLKSIZ);
roundup(newcg->cg_clustersumoff, sizeof(u_int32_t));
bmapsize = roundup(howmany(maxfsblock, NBBY), sizeof(short));
if(roundup(d, sblock.fs_frag) >= dupper) {
f<roundup(dupper, sblock.fs_frag);
roundup(acg.cg_clustersumoff, sizeof(u_int32_t));
f<roundup(frag+1, sblock.fs_frag);
if(roundup(osblock.fs_size, sblock.fs_frag)<=sblock.fs_size) {
for(i=roundup(osblock.fs_size-cbase, sblock.fs_frag)-1;
for(i=roundup(osblock.fs_size-cbase, sblock.fs_frag);
new_ipg = roundup(new_ipg, INOPB(&sblock));
roundup(howmany(bbsize + sbsize, sblock.fs_fsize), sblock.fs_frag);
roundup(howmany(sbsize, sblock.fs_fsize), sblock.fs_frag));
sblock.fs_cgoffset = roundup(
inospercg = roundup(bpcg / sizeof(struct ufs1_dinode), INOPB(&sblock));
mincpg = roundup(mincpgcnt, mincpc);
mincpg = roundup(mincpgcnt, mincpc);
sblock.fs_cpg = roundup(mincpgcnt, mincpc);
sblock.fs_cpg = roundup(sblock.fs_cpg, mincpc);
#define MAXIPG(fs) roundup((fs)->fs_bsize * NBBY / 3, INOPB(fs))
roundup(acg.cg_clustersumoff, sizeof(u_int32_t));
lastaddr = roundup(lastaddr, sizeof(long));
lastaddr = roundup(lastaddr, sizeof(size));
dest = roundup(dest, PAGE_SIZE);
lastaddr = roundup(lastaddr, shdr[i].sh_addralign);
lastaddr = roundup(lastaddr, shdr[ef->symtabindex].sh_addralign);
lastaddr = roundup(lastaddr, shdr[symstrindex].sh_addralign);
lastaddr = roundup(lastaddr, shdr[ef->shstrindex].sh_addralign);
lastaddr = roundup(lastaddr, shdr[i].sh_addralign);
a += roundup(strlen(s) + 1, sizeof(u_long)); \
a += roundup(sizeof(s), sizeof(u_long)); \
a += roundup(mm->md_size, sizeof(u_long)); \
addr = roundup(addr, PAGE_SIZE);
addr = roundup(addr, PAGE_SIZE);
kernend = roundup(addr + size, PAGE_SIZE);
addr = roundup(addr, PAGE_SIZE);
addr = roundup(addr, PAGE_SIZE);
kernend = roundup(addr + size, PAGE_SIZE);
a += roundup(strlen(s) + 1, sizeof(u_long));\
a += roundup(sizeof(s), sizeof(u_long)); \
a += roundup(mm->md_size, sizeof(u_long));\
addr = roundup(addr, PAGE_SIZE);
addr = roundup(addr, PAGE_SIZE);
kernend = roundup(addr + size, PAGE_SIZE);
a += roundup(strlen(s) + 1, sizeof(u_int64_t));\
a += roundup(sizeof(s), sizeof(u_int64_t)); \
a += roundup(mm->md_size, sizeof(u_int64_t));\
#define PTSIZE(pp) roundup(PTFIXSZ + isonum_711((pp)->namlen), 2)
len = 4 + roundup(len, 4);
len = 4 + roundup(len, 4);
buf += (sizeof(struct nfs_readdir_data) + roundup(htonl(rd->len),4));
lhs = roundup(lhs, rhs);
base = roundup(low, align);
page_align = roundup(bp->byte_align, PAGE_SIZE) >> PAGE_SHIFT;
mode_cmd.pitches[0] = roundup(mode_cmd.pitches[0],
batch_len = roundup(batch_len,
chunk = roundup(chunk, tile_row_pages(obj));
size = roundup(size, PAGE_SIZE);
return roundup(size, stride);
#define INTERVAL_1_28_US(us) roundup(((us) * 100) >> 7, 25)
final->t11_t12 = roundup(final->t11_t12, 100 * 10);
return roundup(j, hz);
return roundup(j, hz);
return roundup(j, hz);
size = roundup(nbx * nby * 4, track->npipes * (2 << 10));
size = roundup(nbx * nby * 4, track->npipes * (2 << 10));
args->size = roundup(args->size, PAGE_SIZE);
unsigned long page_align = roundup(byte_align, PAGE_SIZE) >> PAGE_SHIFT;
nr_free_pool = roundup(nr_free, page_nr) >> pool->order;
roundup(scp->sc->fbi->height * scp->sc->fbi->stride, PAGE_SIZE);
fsize = roundup(sc->age_max_frame_size, sizeof(uint64_t));
rx_page->cons += roundup(length + sizeof(struct rx_rs),
roundup(reg, TX_JUMBO_THRESH_UNIT) >>
reg = roundup(sc->ale_max_frame_size, RX_JUMBO_THRESH_UNIT);
sc->ale_pagesize = roundup(guard_size + ALE_RX_PAGE_SZ,
(roundup(ALE_MAX_FRAMELEN, ALE_RX_PAGE_ALIGN) * ALE_RX_FRAMES_PAGE)
roundup(IEEE80211_MS_TO_TU(100), bs.bs_intval);
bs.bs_sleepduration = roundup(bs.bs_sleepduration, bs.bs_dtimperiod);
ath_hal_computetxtime(ah, rt, roundup(m->m_len, 4),
segLenList[0] = roundup(m->m_len, 4);
nexttbtt = roundup(nexttbtt, intval);
sc->sc_tdmabintval = roundup((sc->sc_tdmaslotlen+sc->sc_tdmaguard) *
roundup(sizeof(uint16_t) * numChannels, sizeof(uint32_t)) +
roundup(sizeof(uint16_t) * numChannels, sizeof(uint32_t)));
roundup(sizeof(uint16_t) * pe->numChannels,
#ifndef roundup
HALASSERT(roundup(bs->bs_sleepduration, beaconintval) ==
roundup(bs->bs_sleepduration, dtimperiod) ==
HALASSERT(roundup(bs->bs_sleepduration, beaconintval) ==
roundup(bs->bs_sleepduration, dtimperiod) ==
tq->tq_used += roundup(m->m_pkthdr.len + BWN_HDRSIZE(mac), 4);
tq->tq_used -= roundup(tp->tp_m->m_pkthdr.len + BWN_HDRSIZE(mac), 4);
int pktlen = roundup(m->m_pkthdr.len + BWN_HDRSIZE(mac), 4);
roundup(frame_len + ET_MEM_TXSIZE_EX, ET_MEM_UNIT);
len = roundup(len, 4) / 4;
size = roundup(sizeof(*cmd), 4);
keep_alive = roundup(keep_alive, 1000) / 1000;
rx_desc_cnt = roundup(rx_desc_cnt, JME_NDESC_ALIGN);
roundup(sc->jme_cdata.jme_tx_data.jme_tx_desc_cnt, JME_NDESC_ALIGN);
gccb->gc_cmd_len = roundup(GDT_CMD_UNION + GDT_IOCTL_SZ,
gccb->gc_cmd_len = roundup(GDT_CMD_UNION + GDT_CACHE_SG_LST +
gccb->gc_cmd_len = roundup(GDT_CMD_UNION + GDT_RAW_SG_LST +
gccb->gc_cmd_len = roundup(GDT_CMD_UNION + GDT_CACHE_SG_LST +
gccb->gc_cmd_len = roundup(GDT_CMD_UNION + GDT_RAW_SG_LST +
gccb->gc_cmd_len = roundup(GDT_CMD_UNION + GDT_SCREEN_SZ,
gccb->gc_cmd_len = roundup(GDT_CMD_UNION + GDT_SCREEN_SZ,
gccb->gc_cmd_len = roundup(GDT_CMD_UNION + GDT_SCREEN_SZ,
if (roundup(GDT_CMD_UNION + GDT_RAW_SZ, sizeof(u_int32_t)) +
if (roundup(GDT_CMD_UNION + GDT_CACHE_SZ, sizeof(u_int32_t)) +
u_int16_t cp_count = roundup(gccb->gc_cmd_len, sizeof (u_int32_t));
ret = (void *)kmem_alloc(kernel_map, roundup(size, PAGE_SIZE),
kmem_free(kernel_map, (vaddr_t)ptr, roundup(size, PAGE_SIZE));
(roundup(sizeof(struct nvmm_comm_page), PAGE_SIZE))
ret = (void *)uvm_km_alloc(kernel_map, roundup(size, PAGE_SIZE), 0,
uvm_km_free(kernel_map, (vaddr_t)ptr, roundup(size, PAGE_SIZE),
allocsz = roundup(maxasid, 8) / 8;
allocsz = roundup(svm_maxasid, 8) / 8;
allocsz = roundup(maxasid, 8) / 8;
allocsz = roundup(vmx_maxasid, 8) / 8;
argsenvspace = roundup((ARG_MAX - imgp->args->space), sizeof(char *));
roundup(execpath_len, sizeof(char *)) -
roundup(execpath_len, sizeof(char *));
info->time += roundup(time - info->time, info->periodic);
base += roundup(symcnt, sizeof(long));
base += roundup(strcnt, sizeof(long));
next = roundup(next, sizeof(u_long));
next = roundup(next, sizeof(u_long));
next = roundup(next, sizeof(u_long));
next = roundup(next, sizeof(u_long));
next = roundup(next, sizeof(u_long));
next = roundup(next, sizeof(u_long));
bptr += roundup(len, sizeof(u_long)) / sizeof(uint32_t);
next = roundup(next, sizeof(u_long));
len = roundup(s->s_sect_len, pad) - s->s_sect_len;
grid_cnt = roundup(NETISR_CPUMAX, rm->rm_grid) / rm->rm_grid;
lo = roundup(lo, step);
bufsize = roundup(bufsize, mss);
bufsize = roundup(bufsize, mss);
size = roundup(size, sizeof(uint32_t));
size = roundup(size, sizeof(uint32_t));
return roundup(len, sizeof(uint32_t));
return roundup(sizeof(struct ieee80211req_sta_info) + *ielen,
hdrlen = roundup(hdrlen, sizeof(uint32_t));
hdrspace = roundup(hdrsize, sizeof(uint32_t));
hdrspace = roundup(hdrsize, sizeof(uint32_t));
m_adj(m, roundup(sizeof(uint32_t) - 2, 4) + 2);
size = roundup(offset + size, PAGE_SIZE);
size = roundup(offset + size, PAGE_SIZE);
#define ROUNDUP(x,y) roundup(x,y)
char kp_login[roundup(MAXLOGNAME, sizeof(long))];
char s_login[roundup(MAXLOGNAME, sizeof(long))]; /* Setlogin() name. */
cursize = roundup(dp->i_size, blksize);
cursize = roundup(ip->i_size, blksize);
cursize = roundup(ip->i_size, blksize);
roundup(size, fs->e2fs_fsize)
pmp->pm_fatblocksize = roundup(pmp->pm_fatblocksize,
nextblk += roundup(fs->fs_rotdelay * fs->fs_rps * fs->fs_nsect /
end = roundup(start, align);
grow_amount = roundup (stack_entry->ba.start - addr, PAGE_SIZE);
grow_amount = roundup (grow_amount, sgrowsiz);
roundup(phdr[i].p_filesz, PAGE_SIZE));
roundup(phdr[i].p_filesz, PAGE_SIZE);
atd.ad_out_size = roundup(
roundup(sizeof(u_int16_t) * exp->numChannels, sizeof(u_int32_t)));
maxlength = roundup(maxlength + 1, TAB);
while ((cnt = roundup(chcnt + 1, TAB)) <= endcol) {
while ((cnt = roundup(chcnt + 1, TAB)) <= endcol) {
sroom = roundup(sizeof(struct cjprivate), 8);
sroom2 = roundup(sroom2, 8);
msize = roundup(msize, 8);
if (reclen + dbuf->cur + llen > roundup(dbuf->size, DIRBLKSIZ)) {
roundup(fsopts->minsize, ffs_opts->bsize) > fsopts->maxsize)
roundup(SBLOCK_UFS1 + SBLOCKSIZE, ffs_opts->bsize);
fsopts->size += roundup(SBLOCKSIZE, ffs_opts->bsize);
roundup(fsopts->inodes, ffs_opts->bsize / DINODE1_SIZE);
roundup(SBLOCK_UFS2 + SBLOCKSIZE, ffs_opts->bsize);
fsopts->size += roundup(SBLOCKSIZE, ffs_opts->bsize);
roundup(fsopts->inodes, ffs_opts->bsize / DINODE2_SIZE);
fsopts->size = roundup(fsopts->size, ffs_opts->bsize);
if (fsopts->roundup > 0)
fsopts->size = roundup(fsopts->size, fsopts->roundup);
if (this + curdirsize > roundup(curdirsize, DIRBLKSIZ)) \
curdirsize = roundup(curdirsize, DIRBLKSIZ); \
fsopts->size += roundup((x), ffs_opts->fsize); \
fsopts->size += roundup((x), ffs_opts->bsize); \
roundup(howmany(sblock.fs_sblockloc + SBLOCKSIZE, sblock.fs_fsize),
roundup(howmany(8192 + SBLOCKSIZE, sblock.fs_fsize),
roundup(howmany(SBLOCKSIZE, sblock.fs_fsize), sblock.fs_frag));
sblock.fs_fpg = roundup(sblock.fs_iblkno +
sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode),
sblock.fs_fpg = roundup(sblock.fs_iblkno +
sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode),
sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode),
sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode),
lastminfpg = roundup(sblock.fs_iblkno +
sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode),
roundup(acg.cg_clustersumoff, sizeof(int32_t));
minsize = roundup(fsopts->minsize, HAMMER2_FREEMAP_LEVEL1_SIZE);
maxsize = roundup(fsopts->maxsize, HAMMER2_FREEMAP_LEVEL1_SIZE);
fsoptions.roundup =
off_t roundup; /* round image size up to this value */