bin/ls/ls.c

635

(long long)howmany(maxblock, blocksize));

bin/ls/print.c

158

(unsigned long long)howmany(sp->st_blocks,

bin/ls/print.c

388

howmany(sp->st_blocks, blocksize));

bin/ls/print.c

452

howmany(dp->btotal, blocksize));

games/warp/term.c

619

int howmany;

games/warp/term.c

623

howmany = read(devtty,circlebuf+nextin,metakey?1:PUSHSIZE-nextin);

games/warp/term.c

624

if (howmany > 0) {

games/warp/term.c

632

for (i = howmany+nextin-1; i >= nextin; i--)

games/warp/term.c

634

nextin += howmany;

games/warp/term.c

637

return howmany;

lib/libc/locale/newlocale.c

50

int i, howmany, categories[_LC_LAST - 1];

lib/libc/locale/newlocale.c

76

howmany = 0;

lib/libc/locale/newlocale.c

79

categories[howmany++] = i;

lib/libc/locale/newlocale.c

81

if (howmany-- > 0) {

lib/libc/locale/newlocale.c

82

for (i = 1; i < howmany; ++i) {

lib/libc/locale/newlocale.c

92

tokens[howmany] = tail;

lib/libc/locale/newlocale.c

93

tail = __UNCONST(strchr(tokens[howmany], '/'));

lib/libc/locale/newlocale.c

98

for (i = 0; i <= howmany; ++i) {

lib/libc/stdio/vfwprintf.c

738

#define PAD(howmany, with) do { \

lib/libc/stdio/vfwprintf.c

739

if ((n = (howmany)) > 0) { \

lib/libc/stdlib/strfmon.c

92

#define GRPCPY(howmany) do { \

lib/libc/stdlib/strfmon.c

93

int i = howmany; \

lib/libkvm/kvm_aarch64.c

117

u_int levels = howmany(inputsz - page_shift, pte_shift);

libexec/lfs_cleanerd/coalesce.c

157

if (fss[i].dc_count < 2 * howmany(fss[i].nblk,

sbin/dump/main.c

563

mapsize = roundup(howmany(maxino, NBBY), TP_BSIZE);

sbin/dump/main.c

567

tapesize = 3 * (howmany(mapsize * sizeof(char), TP_BSIZE) + 1);

sbin/dump/main.c

625

(howmany(mapsize * sizeof(char), TP_BSIZE) + 1);

sbin/dump/rcache.c

115

nblksread = howmany(readblksize, ufsib->ufs_bsize);

sbin/dump/rcache.c

276

daddr_t numBlocks = howmany(size, dev_bsize);

sbin/dump/rcache.c

355

blkno += howmany(toCopy, dev_bsize);

sbin/dump/rcache.c

356

numBlocks -= howmany(toCopy, dev_bsize);

sbin/dump/rcache.c

367

howmany(toCopy, dev_bsize);

sbin/dump/traverse.c

104

howmany(sizeest - UFS_NDADDR * ufsib->ufs_bsize / TP_BSIZE,

sbin/dump/traverse.c

584

cnt = howmany(DIP(dp, size), ufsib->ufs_fsize);

sbin/dump/traverse.c

626

cnt = howmany(*size, ufsib->ufs_fsize);

sbin/dump/traverse.c

660

blks = howmany(frags * ufsib->ufs_fsize, TP_BSIZE);

sbin/dump/traverse.c

693

blks = howmany(frags * ufsib->ufs_fsize, TP_BSIZE);

sbin/dump/traverse.c

699

resid = howmany(ufsib->ufs_qfmask & extsize,

sbin/dump/traverse.c

702

resid = howmany(ufsib->ufs_qfmask & dp->dp2.di_size,

sbin/dump/traverse.c

705

blks -= howmany(ufsib->ufs_fsize, TP_BSIZE) - resid;

sbin/dump/traverse.c

770

blks = howmany(UFS_NXADDR * ufsib->ufs_bsize, TP_BSIZE);

sbin/dump/traverse.c

772

blks = howmany(extsize, TP_BSIZE);

sbin/dump/traverse.c

820

frags = howmany(extsize, ufsib->ufs_fsize);

sbin/dump/traverse.c

826

blks = howmany(UFS_NXADDR * ufsib->ufs_bsize, TP_BSIZE);

sbin/dump/traverse.c

828

blks = howmany(extsize, TP_BSIZE);

sbin/dump/traverse.c

866

spcl.c_count = iswap32(howmany(mapsize * sizeof(char), TP_BSIZE));

sbin/dump/traverse.c

96

blkest = howmany(ufs_fragroundup(ufsib,

sbin/dump/traverse.c

98

sizeest = howmany(ufs_fragroundup(ufsib, DIP(dp, size)), TP_BSIZE);

sbin/fsck_ext2fs/inode.c

185

ndb = howmany(inosize(&dino), sblock.e2fs_bsize);

sbin/fsck_ext2fs/inode.c

280

nif = howmany(isize, sizepb);

sbin/fsck_ext2fs/inode.c

501

blks = howmany(inosize(dp), sblock.e2fs_bsize);

sbin/fsck_ext2fs/pass1.c

227

ndb = howmany(inosize(dp), sblock.e2fs_bsize);

sbin/fsck_ext2fs/pass1.c

243

ndb = howmany(inosize(dp), sizeof(u_int32_t));

sbin/fsck_ext2fs/setup.c

250

bmapsize = roundup(howmany(maxfsblock, NBBY), sizeof(int16_t));

sbin/fsck_ext2fs/setup.c

334

howmany(sblock.e2fs.e2fs_bcount - sblock.e2fs.e2fs_first_dblock,

sbin/fsck_ext2fs/setup.c

341

sblock.e2fs_ngdb = howmany(sblock.e2fs_ncg,

sbin/fsck_ext2fs/setup.c

344

sblock.e2fs_itpg = howmany(sblock.e2fs.e2fs_ipg, sblock.e2fs_ipb);

sbin/fsck_ext2fs/setup.c

532

howmany(fs->e2fs.e2fs_bcount - fs->e2fs.e2fs_first_dblock,

sbin/fsck_ext2fs/setup.c

535

fs->e2fs_ngdb = howmany(fs->e2fs_ncg,

sbin/fsck_ffs/inode.c

198

if (howmany(isize, sizepb) > (size_t)FFS_NINDIR(sblock))

sbin/fsck_ffs/inode.c

201

nif = howmany(isize, sizepb);

sbin/fsck_ffs/inode.c

495

blks = howmany(size, sblock->fs_bsize);

sbin/fsck_ffs/inode.c

97

ndb = howmany(iswap64(DIP(&dino, size)), sblock->fs_bsize);

sbin/fsck_ffs/main.c

512

n_blks += howmany(sblock->fs_cssize, sblock->fs_fsize);

sbin/fsck_ffs/pass1.c

290

ndb = howmany(size, sblock->fs_bsize);

sbin/fsck_ffs/pass1.c

335

ndb = howmany(size, sizeof(int64_t));

sbin/fsck_ffs/pass1.c

337

ndb = howmany(size, sizeof(int32_t));

sbin/fsck_ffs/pass1.c

446

ndb = howmany(iswap32(dp->dp2.di_extsize), sblock->fs_bsize);

sbin/fsck_ffs/pass1.c

91

cgd = i + howmany(sblock->fs_cssize, sblock->fs_fsize);

sbin/fsck_ffs/pass5.c

148

inomapsize = howmany(fs->fs_ipg, CHAR_BIT);

sbin/fsck_ffs/pass5.c

150

blkmapsize = howmany(fs->fs_fpg, CHAR_BIT);

sbin/fsck_ffs/pass5.c

167

howmany(ffs_fragstoblks(fs, fs->fs_fpg), CHAR_BIT);

sbin/fsck_ffs/pass5.c

178

mapsize = &ocg->cg_free[howmany(fs->fs_fpg, NBBY)] -

sbin/fsck_ffs/pass5.c

180

blkmapsize = howmany(fs->fs_fpg, NBBY);

sbin/fsck_ffs/pass5.c

284

newcg->cg_old_ncyl = howmany(newcg->cg_ndblk,

sbin/fsck_ffs/quota2.c

360

quotamap[i] = calloc(roundup(howmany(nq2e, NBBY),

sbin/fsck_ffs/setup.c

1130

fs->fs_ncg = howmany(fs->fs_size, fs->fs_fpg);

sbin/fsck_ffs/setup.c

1138

howmany(geo.dg_nsectors, nspf), fs->fs_frag);

sbin/fsck_ffs/setup.c

1140

fs->fs_ncg = howmany(fs->fs_size / geo.dg_secpercyl,

sbin/fsck_ffs/setup.c

498

bmapsize = roundup(howmany(maxfsblock, NBBY), sizeof(int16_t));

sbin/fsck_lfs/inode.c

147

ndb = howmany(lfs_dino_getsize(fs, &dino), lfs_sb_getbsize(fs));

sbin/fsck_lfs/inode.c

261

nif = howmany(isize, sizepb);

sbin/fsck_lfs/inode.c

369

blks = howmany(lfs_dino_getsize(fs, dp), lfs_sb_getbsize(fs));

sbin/fsck_lfs/lfs.c

800

nblocks = howmany(lfs_ss_getninos(fs, sp), LFS_INOPB(fs));

sbin/fsck_lfs/lfs.c

823

i < lfs_ss_getnfinfo(fs, sp) || j < howmany(lfs_ss_getninos(fs, sp), LFS_INOPB(fs)); i++) {

sbin/fsck_lfs/lfs.c

827

pseg_addr, j, howmany(lfs_ss_getninos(fs, sp),

sbin/fsck_lfs/lfs.c

835

while (j < howmany(lfs_ss_getninos(fs, sp), LFS_INOPB(fs)) && lfs_ii_getblock(fs, iip) == daddr) {

sbin/fsck_lfs/pass1.c

238

ndb = howmany(lfs_dino_getsize(fs, dp), lfs_sb_getbsize(fs));

sbin/fsck_lfs/pass1.c

254

ndb = howmany(lfs_dino_getsize(fs, dp), LFS_BLKPTRSIZE(fs));

sbin/fsck_lfs/pass6.c

642

sup->su_ninos += howmany(lfs_ss_getninos(fs, sp), LFS_INOPB(fs));

sbin/fsck_lfs/pass6.c

644

lfs_sb_adddmeta(fs, lfs_btofsb(fs, howmany(lfs_ss_getninos(fs, sp),

sbin/fsck_lfs/pass6.c

649

for (i = 0; i < howmany(lfs_ss_getninos(fs, sp), LFS_INOPB(fs)); i++) {

sbin/fsck_lfs/segwrite.c

381

blksinblk = howmany(bp->b_bcount, lfs_sb_getbsize(fs));

sbin/fsck_lfs/segwrite.c

578

num = howmany(sp->start_bpp[i]->b_bcount, lfs_sb_getbsize(fs));

sbin/fsck_lfs/setup.c

273

bc = howmany(lfs_ss_getninos(fs, sp), LFS_INOPB(fs)) <<

sbin/fsck_lfs/setup.c

442

bmapsize = roundup(howmany(maxfsblock, NBBY), sizeof(int16_t));

sbin/newfs/mkfs.c

1341

frag = howmany(size, sblock.fs_fsize);

sbin/newfs/mkfs.c

344

roundup(howmany(sblock.fs_sblockloc + SBLOCKSIZE, sblock.fs_fsize),

sbin/newfs/mkfs.c

347

roundup(howmany(SBLOCKSIZE, sblock.fs_fsize), sblock.fs_frag));

sbin/newfs/mkfs.c

384

inodeblks = howmany(num_inodes, FFS_INOPB(&sblock));

sbin/newfs/mkfs.c

409

ncg = howmany(cgall - cgzero, sblock.fs_bsize - cgzero);

sbin/newfs/mkfs.c

431

sblock.fs_fpg = roundup(howmany(sblock.fs_size, ncg), sblock.fs_frag);

sbin/newfs/mkfs.c

440

ncg = howmany(sblock.fs_size, sblock.fs_fpg);

sbin/newfs/mkfs.c

521

csfrags = howmany(sblock.fs_cssize, sblock.fs_fsize);

sbin/newfs/mkfs.c

526

howmany(csfrags, sblock.fs_frag);

sbin/newfs/mkfs.c

798

dupper += howmany(sblock.fs_cssize, sblock.fs_fsize);

sbin/newfs/mkfs.c

832

acg.cg_freeoff = acg.cg_iusedoff + howmany(sblock.fs_ipg, CHAR_BIT);

sbin/newfs/mkfs.c

835

howmany(sblock.fs_fpg, CHAR_BIT);

sbin/newfs/mkfs.c

838

howmany(sblock.fs_fpg, CHAR_BIT) - sizeof(int32_t);

sbin/newfs/mkfs.c

851

howmany(ffs_fragstoblks(&sblock, sblock.fs_fpg), CHAR_BIT);

sbin/newfs_ext2fs/mke2fs.c

294

ncg = howmany(bcount - sblock.e2fs.e2fs_first_dblock, blocks_per_cg);

sbin/newfs_ext2fs/mke2fs.c

295

blocks_gd = howmany(sizeof(struct ext2_gd) * ncg, bsize);

sbin/newfs_ext2fs/mke2fs.c

304

iblocks_per_cg = howmany(inodesize * inodes_per_cg, bsize);

sbin/newfs_ext2fs/mke2fs.c

329

blocks_gd = howmany(sizeof(struct ext2_gd) * ncg, bsize);

sbin/newfs_ext2fs/mke2fs.c

443

target_ncg = howmany(target_blocks, sblock.e2fs.e2fs_bpg);

sbin/newfs_ext2fs/mke2fs.c

444

target_ngdb = howmany(sizeof(struct ext2_gd) * target_ncg,

sbin/newfs_lfs/make_lfs.c

298

nblocks = howmany(nfrags, lfs_sb_getfrag(fs));

sbin/newfs_lfs/make_lfs.c

321

bb = howmany(bb, LFS_NINDIR(fs));

sbin/newfs_lfs/make_lfs.c

335

bb = howmany(nblocks - ULFS_NDADDR, LFS_NINDIR(fs)) - 1;

sbin/newfs_lfs/make_lfs.c

341

bb = howmany(bb, LFS_NINDIR(fs));

sbin/newfs_lfs/make_lfs.c

801

make_dinode(ULFS_ROOTINO, dip, howmany(LFS_DIRBLKSIZ, lfs_sb_getfsize(fs)), fs);

sbin/newfs_lfs/make_lfs.c

814

for (i = 0; i < ULFS_NDADDR && i < howmany(LFS_DIRBLKSIZ, lfs_sb_getbsize(fs)); i++)

sbin/newfs_lfs/make_lfs.c

827

make_dinode(LOSTFOUNDINO, dip, howmany(DIRBLKSIZ,fs->lfs_fsize), fs);

sbin/newfs_lfs/make_lfs.c

833

for (i = 0; i < ULFS_NDADDR && i < howmany(DIRBLKSIZ, lfs_sb_getbsize(fs)); i++)

sbin/newfs_msdos/mkfs_msdos.c

356

x1 = howmany(bpb.bsec, (1048576 / 512)); /* -> MB */

sbin/newfs_msdos/mkfs_msdos.c

486

howmany((RESFTE + (bpb.spc ? MINCLS16 : MAXCLS12 + 1)) *

sbin/newfs_msdos/mkfs_msdos.c

489

howmany(bpb.rde ? bpb.rde : DEFRDE,

sbin/newfs_msdos/mkfs_msdos.c

492

(bpb.spc ? bpb.spc : howmany(DEFBLK, bpb.bps)))

sbin/newfs_msdos/mkfs_msdos.c

496

howmany((RESFTE + MAXCLS16) * 2, bpb.bps) * bpb.nft +

sbin/newfs_msdos/mkfs_msdos.c

497

howmany(DEFRDE, bpb.bps / sizeof(struct de)) +

sbin/newfs_msdos/mkfs_msdos.c

499

(bpb.spc ? bpb.spc : howmany(8192, bpb.bps)))

sbin/newfs_msdos/mkfs_msdos.c

536

rds = howmany(bpb.rde, bpb.bps / sizeof(struct de));

sbin/newfs_msdos/mkfs_msdos.c

538

for (bpb.spc = howmany(o.fat_type == 16 ? DEFBLK16 : DEFBLK, bpb.bps);

sbin/newfs_msdos/mkfs_msdos.c

541

howmany((RESFTE + maxcls(o.fat_type)) * (o.fat_type / BPN),

sbin/newfs_msdos/mkfs_msdos.c

559

x2 = howmany((RESFTE + MIN(x, maxcls(o.fat_type))) * (o.fat_type / BPN),

sbin/newfs_v7fs/main.c

66

ilist_size = howmany(files, V7FS_INODE_PER_BLOCK);

sbin/nvmectl/bignum.c

5624

mp_init_size(rnd, digits = howmany(bits, DIGIT_BIT));

sbin/resize_ffs/resize_ffs.c

1133

static int32_t indirblk1[howmany(MAXBSIZE, sizeof(int32_t))];

sbin/resize_ffs/resize_ffs.c

1134

static int32_t indirblk2[howmany(MAXBSIZE, sizeof(int32_t))];

sbin/resize_ffs/resize_ffs.c

1135

static int32_t indirblk3[howmany(MAXBSIZE, sizeof(int32_t))];

sbin/resize_ffs/resize_ffs.c

1151

for (k = 0; k < howmany(MAXBSIZE, sizeof(int32_t)); k++)

sbin/resize_ffs/resize_ffs.c

1533

int32_t blk[howmany(MAXBSIZE, sizeof(int32_t))];

sbin/resize_ffs/resize_ffs.c

1536

for (i = 0; i < howmany(MAXBSIZE, sizeof(int32_t)); i++)

sbin/resize_ffs/resize_ffs.c

1540

for (i = 0; i < howmany(MAXBSIZE,

sbin/resize_ffs/resize_ffs.c

1895

howmany(newsb->fs_fpg / NSPB(newsb), NBBY));

sbin/resize_ffs/resize_ffs.c

1898

howmany((newsb->fs_old_cpg * newsb->fs_old_spc) /

sbin/resize_ffs/resize_ffs.c

1994

memset(&cg_inosused(cg, 0)[0], 0, howmany(newsb->fs_ipg, NBBY));

sbin/resize_ffs/resize_ffs.c

529

cg->cg_freeoff = cg->cg_iusedoff + howmany(newsb->fs_ipg, NBBY);

sbin/resize_ffs/resize_ffs.c

533

howmany(newsb->fs_fpg, NBBY) - sizeof(int32_t);

sbin/resize_ffs/resize_ffs.c

539

howmany(ffs_fragstoblks(newsb,newsb->fs_fpg), NBBY);

sbin/resize_ffs/resize_ffs.c

548

howmany(newsb->fs_fpg, NBBY);

sbin/resize_ffs/resize_ffs.c

832

ntot = howmany(newsb->fs_cssize, newsb->fs_fsize);

sbin/resize_ffs/resize_ffs.c

833

nold = howmany(oldsb->fs_cssize, newsb->fs_fsize);

sbin/resize_ffs/resize_ffs.c

917

newsb->fs_dsize -= howmany(newsb->fs_cssize, newsb->fs_fsize);

sbin/resize_ffs/resize_ffs.c

944

newsb->fs_ncg = howmany(newsb->fs_size, newsb->fs_fpg);

sbin/resize_ffs/resize_ffs.c

947

newsb->fs_old_ncyl = howmany(newsb->fs_size * NSPF(newsb),

sbin/resize_ffs/resize_ffs.c

949

newsb->fs_ncg = howmany(newsb->fs_old_ncyl, newsb->fs_old_cpg);

sbin/rndctl/rndctl.c

354

if (howmany(rs.entropy, NBBY) > sizeof(rs.data)) {

sbin/rndctl/rndctl.c

356

if (howmany(rs.entropy, NBBY) > sizeof(rs.data)) {

sbin/routed/main.c

504

ibitsp = (fd_set *)calloc(howmany(sock_max, NFDBITS),

sbin/routed/main.c

508

memcpy(ibitsp, fdbitsp, howmany(sock_max, NFDBITS) *

sbin/routed/main.c

585

fdbitsp = (fd_set *)calloc(howmany(sock_max, NFDBITS),

share/examples/puffs/pgfs/pgfs_puffs.c

1240

sbp->f_bfree = sbp->f_blocks - howmany(bytes + lo_bytes, sbp->f_frsize);

sys/arch/acorn32/mainbus/fd.c

586

sz = howmany(bp->b_bcount, FDC_BSIZE);

sys/arch/alpha/alpha/pmap.c

1324

lev2mapsize = roundup(howmany(lev3mapsize, NPTEPG), NPTEPG);

sys/arch/alpha/alpha/pmap.c

1340

for (i = 0; i < howmany(lev2mapsize, NPTEPG); i++) {

sys/arch/alpha/alpha/pmap.c

1359

for (i = 0; i < howmany(lev3mapsize, NPTEPG); i++) {

sys/arch/alpha/stand/mkbootimage/mkbootimage.c

134

bb->bb_secsize = howmany(insb.st_size, ALPHA_BOOT_BLOCK_BLOCKSIZE);

sys/arch/amiga/amiga/amiga_init.c

424

howmany(ptextra, NPTEPG)) << PGSHIFT;

sys/arch/amiga/amiga/amiga_init.c

471

nl1desc = howmany(nl2desc, SG4_LEV2SIZE);

sys/arch/amiga/dev/event.c

124

n = howmany(uio->uio_resid, sizeof(struct firm_event));

sys/arch/arc/jazz/fd.c

451

sz = howmany(bp->b_bcount, FDC_BSIZE);

sys/arch/arm/acpi/gicv3_acpi.c

165

*count += howmany(gicr->Length, GICR_SIZE);

sys/arch/arm/acpi/sbsawdt_acpi.c

131

sc->sc_max_period = howmany((uint64_t)UINT32_MAX, sc->sc_cntfreq);

sys/arch/arm/amlogic/meson_clk_div.c

112

ratio = howmany(parent_rate, new_rate);

sys/arch/arm/amlogic/meson_clk_mpll.c

75

return (u_int)howmany(parent_rate * SDM_DEN, div);

sys/arch/arm/amlogic/meson_clk_pll.c

80

rate += howmany(frac_rate, __SHIFTOUT_MASK(pll->frac.mask) + 1);

sys/arch/arm/amlogic/meson_clk_pll.c

83

return (u_int)howmany(rate, n);

sys/arch/arm/amlogic/meson_i2c.c

385

u_int div = howmany(rate, sc->sc_clkfreq) - FILTER_DELAY;

sys/arch/arm/amlogic/meson_i2c.c

386

div = howmany(div, 4);

sys/arch/arm/amlogic/meson_i2c.c

414

divh = howmany(rate, sc->sc_clkfreq);

sys/arch/arm/amlogic/meson_i2c.c

415

divl = howmany(divh, 4);

sys/arch/arm/amlogic/meson_i2c.c

416

divh = howmany(divh, 2) - FILTER_DELAY;

sys/arch/arm/amlogic/meson_i2c.c

418

divh = howmany(rate * 2, sc->sc_clkfreq * 5) - FILTER_DELAY;

sys/arch/arm/amlogic/meson_i2c.c

419

divl = howmany(rate * 3, sc->sc_clkfreq * 5 * 2);

sys/arch/arm/amlogic/meson_sdhc.c

412

clk_div = howmany(pll_freq, freq);

sys/arch/arm/amlogic/meson_sdio.c

326

clk_div = howmany(pll_freq, freq);

sys/arch/arm/apple/apple_dart.c

631

const u_int ntte = howmany(DART_APERTURE_START + DART_APERTURE_SIZE - 1,

sys/arch/arm/apple/apple_dart.c

633

const u_int nl2 = howmany(ntte, DART_PAGE_SIZE / sizeof(uint64_t));

sys/arch/arm/apple/apple_dart.c

634

const u_int nl1 = howmany(nl2, DART_PAGE_SIZE / sizeof(uint64_t));

sys/arch/arm/apple/apple_iic.c

230

sc->sc_clkdiv = howmany(clock_speed, bus_speed);

sys/arch/arm/arm/cpu_subr.c

70

volatile u_long arm_cpu_hatched[howmany(MAXCPUS, CPUINDEX_DIVISOR)] __cacheline_aligned = { 0 };

sys/arch/arm/arm/cpu_subr.c

71

volatile u_long arm_cpu_mbox[howmany(MAXCPUS, CPUINDEX_DIVISOR)] __cacheline_aligned = { 0 };

sys/arch/arm/arm32/arm32_kvminit.c

197

#define KERNEL_L2PT_KASAN_NUM howmany(VM_KERNEL_KASAN_SIZE, L2_S_SEGSIZE)

sys/arch/arm/arm32/arm32_kvminit.c

508

* howmany(kernel_size, L2_S_SEGSIZE);

sys/arch/arm/arm32/arm32_kvminit.c

516

howmany(kernel_size, L2_S_SEGSIZE);

sys/arch/arm/arm32/pmap.c

6507

size = howmany(virtual_end - pmap_curmaxkvaddr, L1_S_SIZE);

sys/arch/arm/arm32/pmap.c

6512

size = howmany(size, L2_BUCKET_SIZE);

sys/arch/arm/broadcom/bcm2835_bsc.c

103

u_int divider = howmany(sc->sc_frequency, sc->sc_clkrate);

sys/arch/arm/cortex/gicv3_its.c

1020

baser |= __SHIFTIN(howmany(table_size, page_size) - 1, GITS_BASER_Size);

sys/arch/arm/cortex/gicv3_its.c

980

if (howmany(table_size, page_size) > GITS_BASER_Size + 1) {

sys/arch/arm/cortex/gtmr.c

325

const unsigned int incr_per_us = howmany(freq, 1000000);

sys/arch/arm/fdt/gicv3_fdt.c

237

max_redist += howmany(size, redistributor_stride);

sys/arch/arm/fdt/gicv3_fdt.c

249

const int count = howmany(size, redistributor_stride);

sys/arch/arm/include/asan.h

83

(2 * (1 + howmany(INIT_ARM_TOTAL_STACK / KASAN_SHADOW_SCALE_SIZE, PAGE_SIZE)))

sys/arch/arm/marvell/mvsocgpp.c

170

kmem_zalloc(sizeof(struct mvsocgpp_pic) * howmany(gpp_npins, 8),

sys/arch/arm/nvidia/tegra_xusb.c

860

howmany(boot_codetag, IMEM_BLOCK_SIZE);

sys/arch/arm/nvidia/tegra_xusb.c

862

howmany(boot_codesize, IMEM_BLOCK_SIZE);

sys/arch/arm/rockchip/rk_i2c.c

143

div = howmany(rate, sc->sc_clkfreq * 8) - 2;

sys/arch/arm/rockchip/rk_i2c.c

149

divh = howmany(div, 2);

sys/arch/arm/rockchip/rk_i2c.c

259

for (int i = 0; i < howmany(len + 1, 4); i++)

sys/arch/arm/rockchip/rk_i2c.c

263

txdata.data32, howmany(len + 1, 4));

sys/arch/arm/rockchip/rk_i2c.c

317

rxdata, howmany(buflen, 4));

sys/arch/arm/rockchip/rk_i2c.c

324

for (int i = 0; i < howmany(buflen, 4); i++)

sys/arch/arm/sunxi/sun4i_spi.c

202

cctl = howmany(sc->sc_modclkrate, 2 * speed) - 1;

sys/arch/arm/sunxi/sun6i_spi.c

236

cctl = howmany(sc->sc_modclkrate, 2 * speed) - 1;

sys/arch/arm/sunxi/sunxi_ccu_div.c

163

ratio = howmany(parent_rate, new_rate);

sys/arch/arm/ti/omap3_platform.c

325

long ticks = howmany(n * 32768, 1000000);

sys/arch/arm/ti/omap3_platform.c

344

long ticks = howmany(n * 32768, 1000000);

sys/arch/atari/atari/atari_init.c

1238

nl1desc = howmany(nl2desc, SG4_LEV2SIZE);

sys/arch/atari/atari/atari_init.c

412

ptsize = (Sysptsize + howmany(ptextra, NPTEPG)) << PGSHIFT;

sys/arch/atari/dev/event.c

125

n = howmany(uio->uio_resid, sizeof(struct firm_event));

sys/arch/atari/dev/fd.c

607

sz = howmany(bp->b_bcount, SECTOR_SIZE);

sys/arch/atari/dev/hdfd.c

624

sz = howmany(bp->b_bcount, FDC_BSIZE);

sys/arch/bebox/stand/boot/sd.c

693

nsect = howmany(size, lp->d_secsize);

sys/arch/bebox/stand/boot/wd.c

302

nsect = howmany(size, wd->sc_label.d_secsize);

sys/arch/cesfic/cesfic/pmap_bootstrap.c

129

howmany(RELOC(physmem, psize_t), NPTEPG);

sys/arch/cesfic/cesfic/pmap_bootstrap.c

197

nl1desc = howmany(nl2desc, SG4_LEV2SIZE);

sys/arch/cobalt/stand/boot/wd.c

287

nsect = howmany(size, wd->sc_label.d_secsize);

sys/arch/dreamcast/dev/maple/mmemcard.c

723

cnt = howmany(bp->b_bcount, sc->sc_bsize);

sys/arch/dreamcast/dev/maple/mmemcard.c

783

sc->sc_cnt = howmany(bp->b_bcount - bp->b_resid, sc->sc_bsize);

sys/arch/evbppc/nintendo/dev/di.c

592

WR4(sc, DICMDBUF2, howmany(xs->datalen, DVDBLOCKSIZE));

sys/arch/hp300/hp300/pmap_bootstrap.c

132

howmany(RELOC(physmem, psize_t), NPTEPG) +

sys/arch/hp300/hp300/pmap_bootstrap.c

198

nl1desc = howmany(nl2desc, SG4_LEV2SIZE);

sys/arch/i386/stand/efiboot/eficons.c

1158

for (ms = howmany(timeout, 10 * 1000); ms != 0; ms--) {

sys/arch/luna68k/luna68k/pmap_bootstrap.c

124

howmany(RELOC(physmem, psize_t), NPTEPG);

sys/arch/luna68k/luna68k/pmap_bootstrap.c

186

nl1desc = howmany(nl2desc, SG4_LEV2SIZE);

sys/arch/mac68k/dev/aed.c

610

willfit = howmany(uio->uio_resid, sizeof(adb_event_t));

sys/arch/mac68k/mac68k/pmap_bootstrap.c

145

nptpages += howmany(physmem, NPTEPG);

sys/arch/mac68k/mac68k/pmap_bootstrap.c

206

nl1desc = howmany(nl2desc, SG4_LEV2SIZE);

sys/arch/macppc/dev/aed.c

482

willfit = howmany(uio->uio_resid, sizeof(adb_event_t));

sys/arch/macppc/dev/wdc_obio.c

288

#define TIME_TO_TICK(time) howmany((time), 30)

sys/arch/macppc/dev/wdc_obio.c

296

#define ATA4_TIME_TO_TICK(time) howmany((time), 15) /* 15 ns clock */

sys/arch/mmeye/stand/boot/wd.c

263

nsect = howmany(size, wd->sc_label.d_secsize);

sys/arch/mvme68k/mvme68k/pmap_bootstrap.c

137

howmany(RELOC(physmem, psize_t), NPTEPG) +

sys/arch/mvme68k/mvme68k/pmap_bootstrap.c

203

nl1desc = howmany(nl2desc, SG4_LEV2SIZE);

sys/arch/mvme68k/stand/installboot/installboot.c

300

ndb = howmany(ip->di_size, fs->fs_bsize);

sys/arch/news68k/news68k/pmap_bootstrap.c

130

howmany(RELOC(physmem, psize_t), NPTEPG);

sys/arch/news68k/news68k/pmap_bootstrap.c

200

nl1desc = howmany(nl2desc, SG4_LEV2SIZE);

sys/arch/next68k/next68k/pmap_bootstrap.c

145

howmany(RELOC(physmem, psize_t), NPTEPG) +

sys/arch/next68k/next68k/pmap_bootstrap.c

211

nl1desc = howmany(nl2desc, SG4_LEV2SIZE);

sys/arch/next68k/stand/boot/sd.c

276

nblks = howmany(tsize, ss->sc_dev_bsize);

sys/arch/powerpc/ibm4xx/dev/if_emac.c

1418

txs->txs_opackets = howmany(m0->m_pkthdr.len -

sys/arch/powerpc/mpc5200/fec.c

219

div = howmany(sc->sc_ipb_freq, 2 * FEC_MII_MAX_CLK);

sys/arch/prep/stand/boot/sd.c

693

nsect = howmany(size, lp->d_secsize);

sys/arch/riscv/riscv/cpu_subr.c

76

#define N howmany(MAXCPUS, CPUINDEX_DIVISOR)

sys/arch/riscv/starfive/jh71x0_clkc.c

257

u_int ratio = howmany(parent_rate, new_rate);

sys/arch/riscv/starfive/jh71x0_clkc.c

330

u_int ratio = howmany(parent_rate, new_rate);

sys/arch/riscv/starfive/jh71x0_clkc.c

446

u_int ratio = howmany(parent_rate, new_rate);

sys/arch/sparc/dev/fd.c

875

sz = howmany(bp->b_bcount, DEV_BSIZE);

sys/arch/sparc64/dev/fdc.c

1052

sz = howmany(bp->b_bcount, DEV_BSIZE);

sys/arch/sun3/dev/fd.c

678

sz = howmany(bp->b_bcount, FDC_BSIZE);

sys/arch/virt68k/virt68k/pmap_bootstrap.c

138

howmany(RELOC(physmem, psize_t), NPTEPG);

sys/arch/virt68k/virt68k/pmap_bootstrap.c

203

nl1desc = howmany(nl2desc, SG4_LEV2SIZE);

sys/arch/x68k/dev/event.c

128

n = howmany(uio->uio_resid, sizeof(struct firm_event));

sys/arch/x68k/dev/fd.c

714

sz = howmany(bp->b_bcount, FDC_BSIZE);

sys/arch/x68k/dev/ite_tv.c

786

for (cx = 0; cx < howmany(width, 16); cx++) {

sys/arch/x68k/stand/installboot/installboot.c

241

bootprogsize = howmany(bootprogsize+bboffset, blocksize) * blocksize;

sys/arch/x68k/stand/libsa/fd.c

105

nbytes = howmany(size, 128 << sc->fmt.minsec.N)

sys/arch/x68k/stand/libsa/sdcd.c

326

nblks = howmany(size, current_blkbytes);

sys/arch/x68k/x68k/disksubr.c

239

howmany(LABELOFFSET + sizeof(struct disklabel), lp->d_secsize)

sys/arch/x68k/x68k/disksubr.c

242

howmany(sizeof(struct cpu_disklabel), lp->d_secsize)

sys/arch/x68k/x68k/disksubr.c

96

howmany(LABELOFFSET + sizeof(struct disklabel), lp->d_secsize)

sys/arch/x68k/x68k/disksubr.c

99

howmany(sizeof(struct cpu_disklabel), lp->d_secsize)

sys/arch/x68k/x68k/pmap_bootstrap.c

130

howmany(RELOC(physmem, psize_t), NPTEPG) +

sys/arch/x68k/x68k/pmap_bootstrap.c

196

nl1desc = howmany(nl2desc, SG4_LEV2SIZE);

sys/arch/x86/x86/cpu_rng.c

271

NBYTES = howmany(NBITS, 8),

sys/arch/x86/x86/cpu_rng.c

272

NWORDS = howmany(NBITS, 64),

sys/arch/xen/x86/hypervisor_machdep.c

511

l2_p2m_page_size = howmany(max_pfn, fpp);

sys/compat/freebsd/freebsd_mod.c

54

#define ELF32_AUXSIZE (howmany(ELF_AUX_ENTRIES * sizeof(Aux32Info), \

sys/compat/linux/arch/alpha/linux_osf1.c

656

ticks = howmany((u_long)tv.tv_sec * 1000000 + tv.tv_usec, tick);

sys/compat/netbsd32/netbsd32_mod.c

83

#define ELF32_AUXSIZE (howmany(ELF_AUX_ENTRIES * sizeof(Aux32Info), \

sys/dev/acpi/acpi_cppc.c

208

return howmany(perf * sc->sc_freq_range, sc->sc_perf_range);

sys/dev/acpi/acpi_cppc.c

213

return howmany(freq * sc->sc_perf_range, sc->sc_freq_range);

sys/dev/acpi/apei_einj.c

578

if (nentries < howmany(bodysize, sizeof(ACPI_EINJ_ENTRY))) {

sys/dev/acpi/apei_einj.c

584

} else if (nentries > howmany(bodysize, sizeof(ACPI_EINJ_ENTRY))) {

sys/dev/acpi/apei_einj.c

588

nentries = howmany(bodysize, sizeof(ACPI_EINJ_ENTRY));

sys/dev/dksubr.c

854

maxblkcnt = howmany(maxxfer, lp->d_secsize);

sys/dev/fdt/cpufreq_dt.c

134

const u_int latency_us = howmany(opp->latency_ns, 1000);

sys/dev/fss.c

549

kmem_zalloc(howmany(sc->sc_clcount, NBBY), KM_SLEEP);

sys/dev/fss.c

560

kmem_zalloc(howmany(sc->sc_indir_size, NBBY), KM_SLEEP);

sys/dev/fss.c

601

kmem_free(sc->sc_copied, howmany(sc->sc_clcount, NBBY));

sys/dev/fss.c

617

kmem_free(sc->sc_indir_valid, howmany(sc->sc_indir_size, NBBY));

sys/dev/gpib/rd.c

577

sz = howmany(bp->b_bcount, DEV_BSIZE);

sys/dev/hyperv/hvs.c

183

#define HVS_MAX_SGE (howmany(MAXPHYS, PAGE_SIZE) + 1)

sys/dev/hyperv/vmbus.c

2101

ncmds = howmany(left, VMBUS_NPFNBODY);

sys/dev/i2c/cwfg.c

387

sc->sc_monitor_interval = howmany(val, 1000);

sys/dev/i2c/cwfg.c

399

sc->sc_design_capacity = howmany(val, 1000);

sys/dev/ic/amdccp.c

78

const size_t nwords = howmany(nbytes, sizeof(buf[0]));

sys/dev/ic/ath.c

2549

bs.bs_bmissthreshold = howmany(ic->ic_bmisstimeout, intval);

sys/dev/ic/bcmgenet.c

435

ticks = howmany(usecs * 125, 1024);

sys/dev/ic/bwi.c

10085

sc->sc_pwron_delay = howmany((val + 2) * 1000000, freq.clkfreq_min);

sys/dev/ic/bwi.c

2953

rf_atten_adj = -howmany(txpwr_diff, 8);

sys/dev/ic/bwi.c

7268

howmany(freq.clkfreq_max * 150, 1000000));

sys/dev/ic/bwi.c

7270

howmany(freq.clkfreq_max * 15, 1000000));

sys/dev/ic/bwi.c

9436

len = howmany(pkt_bitlen * 2, rate);

sys/dev/ic/bwi.c

9560

howmany(IEEE80211_OFDM_NBITS((frmlen)), \

sys/dev/ic/cac.c

359

ccb->ccb_req.bcount = htole16(howmany(size, DEV_BSIZE));

sys/dev/ic/cdnsiic.c

113

divb = howmany(pclk, 22 * sc->sc_bus_freq * (diva + 1)) - 1;

sys/dev/ic/dwc_mmc.c

397

clk_div = howmany(pll_freq, freq * ciu_div);

sys/dev/ic/igsfb.c

1196

howmany(dc->dc_depth, NBBY) - 1);

sys/dev/ic/igsfb.c

371

howmany(dc->dc_depth, NBBY) - 1);

sys/dev/ic/igsfb.c

637

*(int *)data = dc->dc_width * howmany(dc->dc_maxdepth, NBBY);

sys/dev/ic/igsfb_subr.c

513

bytes_per_pixel = howmany(depth, NBBY);

sys/dev/ic/igsfb_subr.c

662

dc->dc_stride = dc->dc_width * howmany(depth, NBBY);

sys/dev/ic/pl181.c

346

clk_div = (howmany(pll_freq, freq) >> 1) - 1;

sys/dev/ic/siisata.c

1120

uint32_t fis[howmany(RDH_FISLEN,sizeof(uint32_t))];

sys/dev/ieee1394/fwcrom.c

466

tl->crc_len = howmany(sizeof(struct csrtext) + len, sizeof(uint32_t));

sys/dev/ieee1394/fwcrom.c

473

for (i = 0; i < howmany(len, sizeof(uint32_t)); i++)

sys/dev/ieee1394/fwdma.c

165

nseg = howmany(n, ssize / esize);

sys/dev/ieee1394/sbp.c

247

#define SBP_IND_MAX howmany(SBP_MAXPHYS, SBP_SEG_MAX)

sys/dev/ieee1394/sbp.c

249

#define SBP_IND_MAX howmany(SBP_MAXPHYS, PAGE_SIZE)

sys/dev/isa/fd.c

718

sz = howmany(bp->b_bcount, FDC_BSIZE);

sys/dev/pad/pad.c

761

switch (howmany(bits, NBBY)) {

sys/dev/pci/if_iwm.c

931

if (idx >= howmany(IWM_NUM_UCODE_TLV_API, 32)) {

sys/dev/pci/if_iwm.c

954

if (idx >= howmany(IWM_NUM_UCODE_TLV_CAPA, 32)) {

sys/dev/pci/if_iwmvar.h

440

uint8_t sc_ucode_api[howmany(IWM_NUM_UCODE_TLV_API, NBBY)];

sys/dev/pci/if_iwmvar.h

441

uint8_t sc_enabled_capa[howmany(IWM_NUM_UCODE_TLV_CAPA, NBBY)];

sys/dev/pci/if_mcx.c

3645

nmb = howmany(len, MCX_CMDQ_MAILBOX_DATASIZE);

sys/dev/pci/if_mcx.c

3892

nmb = howmany(paslen, MCX_CMDQ_MAILBOX_DATASIZE);

sys/dev/pci/if_mcx.c

4375

npages = howmany((1 << MCX_LOG_EQ_SIZE) * sizeof(struct mcx_eq_entry),

sys/dev/pci/if_mcx.c

4400

howmany(insize, MCX_CMDQ_MAILBOX_DATASIZE),

sys/dev/pci/if_mcx.c

4416

mcx_cmdq_mboxes_sign(&mxm, howmany(insize, MCX_CMDQ_MAILBOX_DATASIZE));

sys/dev/pci/if_mcx.c

4670

npages = howmany((1 << MCX_LOG_CQ_SIZE) * sizeof(struct mcx_cq_entry),

sys/dev/pci/if_mcx.c

4695

howmany(insize, MCX_CMDQ_MAILBOX_DATASIZE),

sys/dev/pci/if_mcx.c

4824

npages = howmany((1 << MCX_LOG_RQ_SIZE) * sizeof(struct mcx_rq_entry),

sys/dev/pci/if_mcx.c

4845

howmany(insize, MCX_CMDQ_MAILBOX_DATASIZE),

sys/dev/pci/if_mcx.c

5181

npages = howmany((1 << MCX_LOG_SQ_SIZE) * sizeof(struct mcx_sq_entry),

sys/dev/pci/if_mcx.c

5203

howmany(insize, MCX_CMDQ_MAILBOX_DATASIZE),

sys/dev/pci/if_msk.c

1277

howmany(SK_JLEN + 1, NBPG),

sys/dev/pci/if_wm.c

18092

value = howmany(value, __BIT(5));

sys/dev/pci/vioscsi.c

154

VIRTIO_SCSI_MIN_SEGMENTS + howmany(MAXPHYS, NBPG),

sys/dev/pcmcia/pcmcia_cis.c

385

howmany(sizeof mfc, sizeof mfc[0]))

sys/dev/raidframe/raidframevar.h

621

#define RF_PARITYMAP_NBYTE howmany(RF_PARITYMAP_NREG, NBBY)

sys/dev/raidframe/rf_paritymap.c

447

rstripes = howmany(raid->Layout.numStripe, pm->params.regions);

sys/dev/scsipi/cd.c

660

bps = howmany(secsize, DEV_BSIZE);

sys/dev/scsipi/cd.c

661

nblks = howmany(bp->b_bcount, DEV_BSIZE);

sys/dev/scsipi/cd.c

679

blkno += howmany(count, DEV_BSIZE);

sys/dev/scsipi/cd.c

809

nblks = howmany(bp->b_bcount, cd->params.blksize);

sys/dev/scsipi/sd.c

723

nblks = howmany(bp->b_bcount, sd->params.blksize);

sys/dev/sdmmc/ld_sdmmc.c

535

nblks = howmany(bp->b_bcount, sc->sc_ld.sc_secsize);

sys/dev/sdmmc/sdhc.c

1059

div = howmany(hp->clkbase, freq);

sys/dev/sdmmc/sdhc.c

1067

div = howmany(hp->clkbase, freq);

sys/dev/sdmmc/sdhc.c

1068

div = div > 1 ? howmany(div, 2) : 0;

sys/dev/sdmmc/sdmmc_mem.c

2351

const int nblk = howmany(datalen, SDMMC_SECTOR_SIZE);

sys/dev/sun/event.c

124

n = howmany(uio->uio_resid, sizeof(struct firm_event));

sys/dev/usb/ehci.c

3051

nsqtd += howmany(alen, EHCI_PAGE_SIZE);

sys/dev/usb/ehci.c

3198

if (howmany(curlen, mps) & 1) {

sys/dev/usb/ehci.c

4706

frames = howmany(xfer->ux_nframes, ufrperframe);

sys/dev/usb/ehci.c

4836

frames = howmany(xfer->ux_nframes, ufrperframe);

sys/dev/usb/ohci.c

3496

const size_t nfsitd = howmany(xfer->ux_nframes, OHCI_ITD_NOFFSET);

sys/dev/usb/ohci.c

551

nstd += howmany(length, OHCI_PAGE_SIZE);

sys/dev/usb/ucom.c

952

ms += howmany(delta.tv_usec, 1000);

sys/dev/usb/uhci.c

1997

size_t ntd = howmany(len, maxp);

sys/dev/usb/uhci.c

2003

ntd += howmany(len, PAGE_SIZE);

sys/dev/usb/uhci.c

3336

npoll = howmany(UHCI_VFRAMELIST_COUNT, ival);

sys/dev/usb/usb_mem.c

165

b->nsegs = howmany(size, PAGE_SIZE);

sys/dev/usb/xhci.c

1476

howmany(sc->sc_maxports * sizeof(uint8_t), NBBY), KM_SLEEP);

sys/dev/usb/xhci.c

4662

const unsigned tdpc = howmany(len, mps);

sys/dev/usb/xhci.c

4663

const unsigned tbc = howmany(tdpc, maxb) - 1;

sys/dev/usb/xhci.c

677

howmany(sc->sc_maxports * sizeof(uint8_t), NBBY));

sys/dev/wscons/wsevent.c

262

n = howmany(uio->uio_resid, evsize);

sys/dev/wsfont/wsfont.c

475

newstride = alpha ? font->fontheight : howmany(font->fontheight, 8);

sys/fs/adosfs/advnops.c

174

fblks = howmany(ap->fsize, amp->dbsize);

sys/fs/adosfs/advnops.c

175

fblks += howmany(fblks, ANODENDATBLKENT(ap));

sys/fs/msdosfs/msdosfs_conv.c

662

if ((wep->weCnt & WIN_CNT) > howmany(WIN_MAXLEN, WIN_CHARS)

sys/fs/msdosfs/msdosfs_conv.c

757

return howmany(len, WIN_CHARS);

sys/fs/msdosfs/msdosfs_vfsops.c

738

fatblocksecs = howmany(fatbytes, pmp->pm_BytesPerSec);

sys/fs/nfs/server/nfs_nfsdport.c

168

nh->nh_seqcount += howmany(uio->uio_resid, 16384);

sys/fs/ptyfs/ptyfs_subr.c

205

nsize = roundup(howmany(pty + 1, NBBY), 64);

sys/fs/puffs/puffs_msgif.c

167

puffs_msgpark_release1(struct puffs_msgpark *park, int howmany)

sys/fs/puffs/puffs_msgif.c

174

refcnt = park->park_refcount -= howmany;

sys/kern/kern_entropy.c

2150

KASSERTMSG(howmany(entropybits, NBBY) <= len,

sys/kern/kern_entropy.c

2198

KASSERTMSG(howmany(entropybits, NBBY) <= len,

sys/kern/kern_entropy.c

610

if (howmany(seed->entropy, NBBY) > sizeof(seed->data)) {

sys/kern/kern_entropy.c

612

if (howmany(seed->entropy, NBBY) > sizeof(seed->data))

sys/kern/kern_entropy.c

927

KASSERTMSG(howmany(nbits, NBBY) <= len,

sys/kern/kern_entropy.c

998

KASSERTMSG(howmany(nbits, NBBY) <= len,

sys/kern/subr_disk.c

323

sz = howmany((int64_t)bp->b_bcount, secsize);

sys/kern/subr_disk.c

383

sz = howmany((int64_t)bp->b_bcount, DEV_BSIZE);

sys/kern/subr_pool.c

474

const int n = howmany(pp->pr_itemsperpage, BITMAP_SIZE);

sys/kern/subr_pool.c

720

ph_bitmap[howmany(nelem, BITMAP_SIZE)]);

sys/kern/sys_select.c

383

char smallbits[howmany(FD_SETSIZE, NFDBITS) *

sys/kern/sys_select.c

411

fb = howmany(nf, __NFDBITS); /* how many fd_masks */

sys/kern/sys_select.c

412

db = howmany(nd, __NFDBITS);

sys/kern/sys_select.c

431

off = howmany(nf, __NFDBITS) * sizeof(__fd_mask);

sys/kern/vfs_wapbl.c

2376

return MAX(1, howmany(wl->wl_inohashcnt, iph)) * blocklen;

sys/kern/vfs_wapbl.c

2393

len += howmany(wl->wl_bufcount, wl->wl_brperjblock) * blocklen;

sys/kern/vfs_wapbl.c

2394

len += howmany(wl->wl_dealloccnt, wl->wl_brperjblock) * blocklen;

sys/lib/libsa/ext2fs.c

442

howmany(fs->e2fs.e2fs_bcount - fs->e2fs.e2fs_first_dblock,

sys/lib/libsa/ext2fs.c

451

howmany(fs->e2fs_ncg, fs->e2fs_bsize / sizeof(struct ext2_gd));

sys/net/if_wg.c

434

#define SLIWIN_WORDS howmany(SLIWIN_BITS, SLIWIN_BPW)

sys/net80211/ieee80211_node.c

136

ic->ic_aid_bitmap = malloc(howmany(ic->ic_max_aid, 32) *

sys/net80211/ieee80211_node.c

140

ic->ic_tim_len = howmany(ic->ic_max_aid, 8) * sizeof(u_int8_t);

sys/netinet/ip_output.c

605

unsigned int num = howmany(datasz, segsz);

sys/netinet6/ip6_mroute.h

85

#ifndef howmany

sys/netinet6/ip6_mroute.h

90

if_mask ifs_bits[howmany(IF_SETSIZE, NIFBITS)];

sys/opencrypto/cryptosoft.c

565

uint32_t blkbuf[howmany(EALG_MAX_BLOCK_LEN, sizeof(uint32_t))];

sys/sys/param.h

430

#ifndef howmany

sys/ufs/ext2fs/ext2fs_alloc.c

391

end = howmany(fs->e2fs.e2fs_fpg, NBBY) - start;

sys/ufs/ext2fs/ext2fs_alloc.c

479

len = howmany(fs->e2fs.e2fs_ipg - ipref, NBBY);

sys/ufs/ext2fs/ext2fs_alloc.c

629

len = howmany(fs->e2fs.e2fs_fpg, NBBY) - start;

sys/ufs/ext2fs/ext2fs_vfsops.c

1394

m_fs->e2fs_ncg = howmany(u32, fs->e2fs_bpg);

sys/ufs/ext2fs/ext2fs_vfsops.c

1421

m_fs->e2fs_ngdb = howmany(m_fs->e2fs_ncg, u32);

sys/ufs/ffs/ffs_alloc.c

1353

len = howmany(maxiblk - irotor, NBBY);

sys/ufs/ffs/ffs_alloc.c

2180

len = howmany(fs->fs_fpg, NBBY) - start;

sys/ufs/ffs/ffs_snapshot.c

1120

numblks = howmany(cancelip->i_size, fs->fs_bsize);

sys/ufs/ffs/ffs_snapshot.c

1194

last = howmany(remblks, blksperindir);

sys/ufs/ffs/ffs_snapshot.c

1492

numblks = howmany(ip->i_size, fs->fs_bsize);

sys/ufs/ffs/ffs_snapshot.c

1789

ffs_lblktosize(fs, howmany(fs->fs_size, fs->fs_frag)),

sys/ufs/ffs/ffs_snapshot.c

1804

ffs_lblktosize(fs, howmany(fs->fs_size, fs->fs_frag)),

sys/ufs/ffs/ffs_snapshot.c

474

numblks = howmany(fs->fs_size, fs->fs_frag);

sys/ufs/ffs/ffs_snapshot.c

518

len = howmany(fs->fs_cssize, fs->fs_bsize);

sys/ufs/ffs/ffs_snapshot.c

589

loc = howmany(fs->fs_cssize, fs->fs_fsize);

sys/ufs/ffs/ffs_snapshot.c

682

*snaplistsize = fs->fs_ncg + howmany(fs->fs_cssize, fs->fs_bsize) +

sys/ufs/ffs/ffs_snapshot.c

697

loc = howmany(xp->i_size, fs->fs_bsize) - 1;

sys/ufs/ffs/ffs_snapshot.c

746

len = howmany(fs->fs_cssize, fs->fs_bsize);

sys/ufs/ffs/ffs_snapshot.c

819

numblks = howmany(fs->fs_size, fs->fs_frag);

sys/ufs/ffs/ffs_snapshot.c

857

len = howmany(fs->fs_cssize, fs->fs_bsize);

sys/ufs/ffs/ffs_snapshot.c

926

fs->fs_active = malloc(howmany(fs->fs_ncg, NBBY),

sys/ufs/ffs/ffs_snapshot.c

991

numblks = howmany(fs->fs_size, fs->fs_frag);

sys/ufs/ffs/ffs_snapshot.c

992

len = howmany(fs->fs_fpg, fs->fs_frag);

sys/ufs/ffs/ffs_vfsops.c

1474

blks = howmany(bsize, fs->fs_fsize);

sys/ufs/ffs/ffs_vfsops.c

2460

blks = howmany(fs->fs_cssize, fs->fs_fsize);

sys/ufs/ffs/ffs_vfsops.c

961

blks = howmany(fs->fs_cssize, fs->fs_fsize);

sys/ufs/ffs/fs.h

483

/* inode map */ howmany((ipg), NBBY) + \

sys/ufs/ffs/fs.h

484

/* block map */ howmany((fpg), NBBY) +\

sys/ufs/ffs/fs.h

487

/* cluster map */ howmany(ffs_fragstoblks(fs, (fpg)), NBBY)))

sys/ufs/lfs/lfs_bio.c

354

((howmany(lfs_sb_getuinodes(fs) + 1, LFS_INOPB(fs)) +

sys/ufs/lfs/lfs_bio.c

591

#define INOCOUNT(fs) howmany(lfs_sb_getuinodes(fs), LFS_INOPB(fs))

sys/ufs/lfs/lfs_rfw.c

770

ninos = howmany(lfs_ss_getninos(fs, ssp), LFS_INOPB(fs));

sys/ufs/lfs/lfs_segment.c

1316

blksinblk = howmany(bp->b_bcount, lfs_sb_getbsize(fs));

sys/ufs/lfs/lfs_segment.c

1698

num = howmany(sp->start_bpp[i]->b_bcount, lfs_sb_getbsize(fs));

sys/ufs/lfs/lfs_vfsops.c

2595

nlast = howmany(newnsegs, lfs_sb_getsepb(fs)) + lfs_sb_getcleansz(fs);

sys/ufs/lfs/ulfs_dirhash.c

167

narrays = howmany(nslots, DH_NBLKOFF);

sys/ufs/lfs/ulfs_dirhash.c

169

dirblocks = howmany(ip->i_size, dirblksiz);

sys/ufs/lfs/ulfs_dirhash.c

536

for (i = howmany(slotneeded, DIRALIGN); i <= DH_NFSTATS; i++)

sys/ufs/lfs/ulfs_dirhash.c

545

dh->dh_blkfree[dirblock] >= howmany(slotneeded, DIRALIGN));

sys/ufs/lfs/ulfs_dirhash.c

803

block = howmany(offset, dirblksiz);

sys/ufs/ufs/ufs_dirhash.c

166

narrays = howmany(nslots, DH_NBLKOFF);

sys/ufs/ufs/ufs_dirhash.c

168

dirblocks = howmany(ip->i_size, dirblksiz);

sys/ufs/ufs/ufs_dirhash.c

532

for (i = howmany(slotneeded, DIRALIGN); i <= DH_NFSTATS; i++)

sys/ufs/ufs/ufs_dirhash.c

541

dh->dh_blkfree[dirblock] >= howmany(slotneeded, DIRALIGN));

sys/ufs/ufs/ufs_dirhash.c

795

block = howmany(offset, dirblksiz);

sys/uvm/uvm_bio.c

1053

struct vm_page *pgs[howmany(ubc_winsize, MIN_PAGE_SIZE)];

sys/uvm/uvm_bio.c

314

struct vm_page *pgs[howmany(ubc_winsize, MIN_PAGE_SIZE)];

sys/uvm/uvm_bio.c

744

struct vm_page *pgs[howmany(ubc_winsize, MIN_PAGE_SIZE)];

sys/uvm/uvm_bio.c

809

struct vm_page *pgs[howmany(ubc_winsize, MIN_PAGE_SIZE)];

sys/uvm/uvm_bio.c

986

struct vm_page *pgs[howmany(ubc_winsize, MIN_PAGE_SIZE)];

sys/uvm/uvm_pager.c

532

struct vm_page *pgs[howmany(MAXPHYS, MIN_PAGE_SIZE)];

sys/uvm/uvm_pdaemon.c

491

struct vm_page *swc_pages[howmany(MAXPHYS, MIN_PAGE_SIZE)];

sys/uvm/uvm_pdpolicy_clockpro.c

412

sz = howmany(n, BUCKETSIZE);

tests/dev/audio/audiotest.c

3179

hiwat = howmany(8000 * 1.5, blocksize);

tests/dev/audio/audiotest.c

3180

lowat = howmany(8000 * 0.5, blocksize);

tests/dev/audio/audiotest.c

3303

hiwat = howmany(8000 * 1.5, blocksize);

tests/dev/audio/audiotest.c

3304

lowat = howmany(8000 * 0.5, blocksize);

tests/dev/audio/audiotest.c

3854

hiwat = howmany(8000 * 1.5, blocksize);

tests/dev/audio/audiotest.c

3855

lowat = howmany(8000 * 0.5, blocksize);

tests/dev/audio/audiotest.c

3980

hiwat = howmany(8000 * 1.5, blocksize);

tests/dev/audio/audiotest.c

3981

lowat = howmany(8000 * 0.5, blocksize);

usr.bin/du/du.c

276

howmany(blocks, (int64_t)blocksize),

usr.bin/fincore/fincore.c

157

const uintmax_t total = howmany(st.st_size, page_size);

usr.bin/rpcinfo/rpcinfo.c

1711

spaces(size_t howmany)

usr.bin/rpcinfo/rpcinfo.c

1716

if (howmany >= sizeof(space_array)) {

usr.bin/rpcinfo/rpcinfo.c

1719

return &space_array[sizeof(space_array) - howmany - 1];

usr.bin/systat/iostat.c

136

regions = howmany(ndrives, DRIVESPERLINE);

usr.bin/vndcompress/offtab.c

382

howmany(offtab->ot_n_offsets, offtab->ot_window_size);

usr.sbin/apmd/apmd.c

226

make_noise(int howmany)

usr.sbin/apmd/apmd.c

259

syslog(LOG_DEBUG, "sending %d tones to speaker\n", howmany);

usr.sbin/apmd/apmd.c

260

write (spkrfd, "o4cc", 2 + howmany);

usr.sbin/apmd/apmd.c

76

static void make_noise(int howmany);

usr.sbin/diskpart/diskpart.c

188

threshold = howmany(spc, badsecttable);

usr.sbin/diskpart/diskpart.c

199

dp->d_ncylinders = howmany(totsize, spc);

usr.sbin/diskpart/diskpart.c

212

curcyl += howmany(defpart[def][part], spc);

usr.sbin/diskpart/diskpart.c

231

numcyls[part] = howmany(defpart[def][part], spc);

usr.sbin/installboot/arch/alpha.c

279

startblock = howmany(filesyssb.st_size,

usr.sbin/installboot/arch/alpha.c

289

htole64(howmany(params->s1stat.st_size,

usr.sbin/installboot/arch/pmax.c

230

startblock = howmany(params->fsstat.st_size,

usr.sbin/installboot/arch/pmax.c

241

htole32(howmany(bootstrapsize, PMAX_BOOT_BLOCK_BLOCKSIZE));

usr.sbin/installboot/arch/vax.c

243

startblock = howmany(filesyssb.st_size,

usr.sbin/installboot/ext2fs.c

146

howmany(fs->e2fs.e2fs_bcount - fs->e2fs.e2fs_first_dblock,

usr.sbin/installboot/ext2fs.c

155

howmany(fs->e2fs_ncg, fs->e2fs_bsize / sizeof(struct ext2_gd));

usr.sbin/installboot/ext2fs.c

247

nblk = howmany(inode->e2di_size, fs->e2fs_bsize);

usr.sbin/installboot/ffs.c

172

nblk = howmany(inode->di_size, fs->fs_bsize);

usr.sbin/installboot/ffs.c

309

nblk = howmany(inode->di_size, fs->fs_bsize);

usr.sbin/makefs/cd9660.h

119

howmany((__bytes), (__sector_size))

usr.sbin/makefs/cd9660/cd9660_eltorito.c

156

howmany(new_image->size, diskStructure->sectorSize) *

usr.sbin/makefs/cd9660/cd9660_eltorito.c

157

howmany(diskStructure->sectorSize, 512);

usr.sbin/makefs/cd9660/cd9660_eltorito.c

409

catalog_sectors = howmany(num_entries * 0x20, diskStructure->sectorSize);

usr.sbin/makefs/ffs/ffs_alloc.c

578

len = howmany(fs->fs_fpg, NBBY) - start;

usr.sbin/makefs/ffs/mkfs.c

316

roundup(howmany(sblock.fs_sblockloc + SBLOCKSIZE, sblock.fs_fsize),

usr.sbin/makefs/ffs/mkfs.c

319

roundup(howmany(SBLOCKSIZE, sblock.fs_fsize), sblock.fs_frag));

usr.sbin/makefs/ffs/mkfs.c

352

sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode),

usr.sbin/makefs/ffs/mkfs.c

358

sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode),

usr.sbin/makefs/ffs/mkfs.c

375

sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode),

usr.sbin/makefs/ffs/mkfs.c

384

sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode),

usr.sbin/makefs/ffs/mkfs.c

396

sblock.fs_ncg = howmany(sblock.fs_size, sblock.fs_fpg);

usr.sbin/makefs/ffs/mkfs.c

408

sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode),

usr.sbin/makefs/ffs/mkfs.c

470

csfrags = howmany(sblock.fs_cssize, sblock.fs_fsize);

usr.sbin/makefs/ffs/mkfs.c

475

howmany(csfrags, sblock.fs_frag);

usr.sbin/makefs/ffs/mkfs.c

586

blks = howmany(size, fs->fs_fsize);

usr.sbin/makefs/ffs/mkfs.c

629

dupper += howmany(sblock.fs_cssize, sblock.fs_fsize);

usr.sbin/makefs/ffs/mkfs.c

666

acg.cg_old_ncyl = howmany(acg.cg_ndblk,

usr.sbin/makefs/ffs/mkfs.c

681

acg.cg_freeoff = acg.cg_iusedoff + howmany(sblock.fs_ipg, CHAR_BIT);

usr.sbin/makefs/ffs/mkfs.c

684

howmany(sblock.fs_fpg, CHAR_BIT);

usr.sbin/makefs/ffs/mkfs.c

687

howmany(sblock.fs_fpg, CHAR_BIT) - sizeof(int32_t);

usr.sbin/makefs/ffs/mkfs.c

693

howmany(ffs_fragstoblks(&sblock, sblock.fs_fpg), CHAR_BIT);

usr.sbin/quot/quot.c

165

sz = howmany(sz - UFS_NDADDR, FFS_NINDIR(super));

usr.sbin/quot/quot.c

169

sz = howmany(sz - 1, FFS_NINDIR(super));

usr.sbin/quot/quot.c

73

#define SIZE(n) howmany((long long)(n) * DEV_BSIZE, (long long)blocksize)

usr.sbin/traceroute6/traceroute6.c

767

fdsn = howmany(sock + 1, NFDBITS) * sizeof(fd_mask);

usr.sbin/wiconfig/wiconfig.c

157

struct wi_apinfo aps[howmany(WI_MAX_DATALEN,

usr.sbin/wiconfig/wiconfig.c

223

howmany(sizeof(wreq.wi_val) - sizeof(int), sizeof(*aps)));