bin/ls/ls.c

1015

howmany(maxblock, blocksize));

bin/ls/print.c

214

(void)printf("total %lu\n", howmany(dp->btotal, blocksize));

bin/ls/print.c

232

dp->s_block, howmany(sp->st_blocks, blocksize));

bin/ls/print.c

361

(void)printf("total %lu\n", howmany(dp->btotal, blocksize));

bin/ls/print.c

411

(int)sizefield, howmany(sp->st_blocks, blocksize));

lib/libc/db/btree/bt_open.c

276

ncache = howmany(b.cachesize, t->bt_psize);

lib/libc/db/hash/hash.c

159

nsegs = howmany(hashp->MAX_BUCKET + 1, hashp->SGSIZE);

lib/libc/stdio/printfcommon.h

113

io_pad(struct io_state *iop, int howmany, const CHAR * __restrict with,

lib/libc/stdio/printfcommon.h

118

while (howmany > 0) {

lib/libc/stdio/printfcommon.h

119

n = (howmany >= PADSIZE) ? PADSIZE : howmany;

lib/libc/stdio/printfcommon.h

122

howmany -= n;

lib/libc/stdio/vfprintf.c

371

#define PAD(howmany, with) { \

lib/libc/stdio/vfprintf.c

372

if (io_pad(&io, (howmany), (with), locale)) \

lib/libc/stdio/vfwprintf.c

445

#define PAD(howmany, with) { \

lib/libc/stdio/vfwprintf.c

446

if (io_pad(&io, (howmany), (with), locale)) \

lib/libc/stdio/xprintf.c

136

__printf_pad(struct __printf_io *io, int howmany, int zero)

lib/libc/stdio/xprintf.c

147

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

lib/libc/stdlib/strfmon.c

85

#define GRPCPY(howmany) do { \

lib/libc/stdlib/strfmon.c

86

int i = howmany; \

lib/libc/tests/secure/fortify_poll_test.c

182

for (size_t i = 0; i < howmany(__bufsz, sizeof(struct pollfd)); i++) {

lib/libc/tests/secure/fortify_poll_test.c

207

for (size_t i = 0; i < howmany(__bufsz, sizeof(struct pollfd)); i++) {

lib/libc/tests/secure/fortify_poll_test.c

241

for (size_t i = 0; i < howmany(__bufsz, sizeof(struct pollfd)); i++) {

lib/libc/tests/secure/fortify_poll_test.c

289

for (size_t i = 0; i < howmany(__bufsz, sizeof(struct pollfd)); i++) {

lib/libc/tests/secure/fortify_poll_test.c

315

for (size_t i = 0; i < howmany(__bufsz, sizeof(struct pollfd)); i++) {

lib/libc/tests/secure/fortify_poll_test.c

350

for (size_t i = 0; i < howmany(__bufsz, sizeof(struct pollfd)); i++) {

lib/libc/tests/secure/fortify_poll_test.c

398

for (size_t i = 0; i < howmany(__bufsz, sizeof(struct pollfd)); i++) {

lib/libc/tests/secure/fortify_poll_test.c

424

for (size_t i = 0; i < howmany(__bufsz, sizeof(struct pollfd)); i++) {

lib/libc/tests/secure/fortify_poll_test.c

459

for (size_t i = 0; i < howmany(__bufsz, sizeof(struct pollfd)); i++) {

lib/libc/tests/secure/fortify_poll_test.c

508

for (size_t i = 0; i < howmany(__bufsz, sizeof(struct pollfd)); i++) {

lib/libc/tests/secure/fortify_poll_test.c

535

for (size_t i = 0; i < howmany(__bufsz, sizeof(struct pollfd)); i++) {

lib/libc/tests/secure/fortify_poll_test.c

571

for (size_t i = 0; i < howmany(__bufsz, sizeof(struct pollfd)); i++) {

lib/libcuse/cuse_lib.c

182

info.page_count = howmany(size, pgsize);

lib/libcuse/cuse_lib.c

185

m = howmany(size, 1 << CUSE_ALLOC_UNIT_SHIFT);

lib/libcuse/cuse_lib.c

193

n += howmany(a_cuse[n].size, 1 << CUSE_ALLOC_UNIT_SHIFT);

lib/libkvm/kvm_private.c

423

adj += howmany(dump_avail_n(kd, i + 1), page_size) -

lib/libkvm/kvm_private.c

440

sz = howmany(dump_avail_n(kd, i + 1), page_size) -

sbin/dump/main.c

464

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

sbin/dump/main.c

468

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

sbin/dump/main.c

524

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

sbin/dump/traverse.c

108

blkest = howmany(dbtob(DIP(dp, di_blocks)), TP_BSIZE);

sbin/dump/traverse.c

109

sizeest = howmany(DIP(dp, di_size), TP_BSIZE);

sbin/dump/traverse.c

114

blkest += howmany(sizeest -

sbin/dump/traverse.c

549

cnt = howmany(DIP(dp, di_size), sblock->fs_fsize);

sbin/dump/traverse.c

588

cnt = howmany(*size, sblock->fs_fsize);

sbin/dump/traverse.c

618

blks = howmany(frags * sblock->fs_fsize, TP_BSIZE);

sbin/dump/traverse.c

661

blks = howmany(frags * sblock->fs_fsize, TP_BSIZE);

sbin/dump/traverse.c

664

resid = howmany(fragoff(sblock, spcl.c_extsize),

sbin/dump/traverse.c

667

resid = howmany(fragoff(sblock, dp->dp2.di_size),

sbin/dump/traverse.c

670

blks -= howmany(sblock->fs_fsize, TP_BSIZE) - resid;

sbin/dump/traverse.c

732

blks = howmany(UFS_NXADDR * sblock->fs_bsize, TP_BSIZE);

sbin/dump/traverse.c

734

blks = howmany(spcl.c_extsize, TP_BSIZE);

sbin/dump/traverse.c

780

frags = howmany(spcl.c_extsize, sblock->fs_fsize);

sbin/dump/traverse.c

786

blks = howmany(UFS_NXADDR * sblock->fs_bsize, TP_BSIZE);

sbin/dump/traverse.c

788

blks = howmany(spcl.c_extsize, TP_BSIZE);

sbin/dump/traverse.c

826

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

sbin/dumpfs/dumpfs.c

314

howmany(afs.fs_old_size % afs.fs_fpg,

sbin/ffsinfo/ffsinfo.c

364

rb = howmany(dp.dp1->di_size, sblock.fs_bsize) - UFS_NDADDR;

sbin/ffsinfo/ffsinfo.c

379

rb -= howmany(sblock.fs_bsize, sizeof(ufs1_daddr_t));

sbin/ffsinfo/ffsinfo.c

394

howmany(rb, howmany(sblock.fs_bsize, sizeof(ufs1_daddr_t))));

sbin/ffsinfo/ffsinfo.c

395

for (ind2ctr = 0; ((ind2ctr < howmany(sblock.fs_bsize,

sbin/ffsinfo/ffsinfo.c

410

rb -= howmany(sblock.fs_bsize, sizeof(ufs1_daddr_t));

sbin/ffsinfo/ffsinfo.c

427

howmany(rb,

sbin/ffsinfo/ffsinfo.c

428

SQUARE(howmany(sblock.fs_bsize, sizeof(ufs1_daddr_t)))));

sbin/ffsinfo/ffsinfo.c

430

for (ind3ctr = 0; ((ind3ctr < howmany(sblock.fs_bsize,

sbin/ffsinfo/ffsinfo.c

444

howmany(rb,

sbin/ffsinfo/ffsinfo.c

445

howmany(sblock.fs_bsize, sizeof(ufs1_daddr_t))));

sbin/ffsinfo/ffsinfo.c

446

for (ind2ctr = 0; ((ind2ctr < howmany(sblock.fs_bsize,

sbin/ffsinfo/ffsinfo.c

462

rb -= howmany(sblock.fs_bsize,

sbin/ffsinfo/ffsinfo.c

516

rb = howmany(dp.dp2->di_size, sblock.fs_bsize) - UFS_NDADDR;

sbin/ffsinfo/ffsinfo.c

528

rb -= howmany(sblock.fs_bsize, sizeof(ufs2_daddr_t));

sbin/ffsinfo/ffsinfo.c

543

howmany(rb, howmany(sblock.fs_bsize, sizeof(ufs2_daddr_t))));

sbin/ffsinfo/ffsinfo.c

544

for (ind2ctr = 0; ((ind2ctr < howmany(sblock.fs_bsize,

sbin/ffsinfo/ffsinfo.c

556

rb -= howmany(sblock.fs_bsize, sizeof(ufs2_daddr_t));

sbin/ffsinfo/ffsinfo.c

573

howmany(rb,

sbin/ffsinfo/ffsinfo.c

574

SQUARE(howmany(sblock.fs_bsize, sizeof(ufs2_daddr_t)))));

sbin/ffsinfo/ffsinfo.c

576

for (ind3ctr = 0; ((ind3ctr < howmany(sblock.fs_bsize,

sbin/ffsinfo/ffsinfo.c

590

howmany(rb,

sbin/ffsinfo/ffsinfo.c

591

howmany(sblock.fs_bsize, sizeof(ufs2_daddr_t))));

sbin/ffsinfo/ffsinfo.c

592

for (ind2ctr = 0; ((ind2ctr < howmany(sblock.fs_bsize,

sbin/ffsinfo/ffsinfo.c

604

rb -= howmany(sblock.fs_bsize, sizeof(ufs2_daddr_t));

sbin/fsck_ffs/fsutil.c

1044

cgp->cg_iusedoff + howmany(sblock.fs_ipg, CHAR_BIT), "%jd");

sbin/fsck_ffs/fsutil.c

1047

cgp->cg_freeoff + howmany(sblock.fs_fpg, CHAR_BIT), "%jd");

sbin/fsck_ffs/fsutil.c

1052

roundup(cgp->cg_freeoff + howmany(sblock.fs_fpg, CHAR_BIT),

sbin/fsck_ffs/fsutil.c

1057

howmany(fragstoblks(&sblock, sblock.fs_fpg), CHAR_BIT),

sbin/fsck_ffs/fsutil.c

1103

cgp->cg_freeoff = cgp->cg_iusedoff + howmany(sblock.fs_ipg, CHAR_BIT);

sbin/fsck_ffs/fsutil.c

1104

cgp->cg_nextfreeoff = cgp->cg_freeoff + howmany(sblock.fs_fpg,CHAR_BIT);

sbin/fsck_ffs/fsutil.c

1113

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

sbin/fsck_ffs/fsutil.c

562

bzero(cg_clustersfree(cgp), howmany(maxbno, CHAR_BIT));

sbin/fsck_ffs/inode.c

1067

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

sbin/fsck_ffs/inode.c

1151

if (howmany(DIP(dp, di_size), sblock.fs_bsize) > UFS_NDADDR)

sbin/fsck_ffs/inode.c

1154

blks = howmany(DIP(dp, di_size), sblock.fs_bsize);

sbin/fsck_ffs/inode.c

190

if (howmany(isize, sizepb) > NINDIR(&sblock))

sbin/fsck_ffs/inode.c

193

nif = howmany(isize, sizepb);

sbin/fsck_ffs/inode.c

605

ndb = howmany(DIP(dp, di_size), sblock.fs_bsize);

sbin/fsck_ffs/inode.c

616

ndb = howmany(DIP(dp, di_size),

sbin/fsck_ffs/inode.c

89

ndb = howmany(DIP(&dino, di_size), sblock.fs_bsize);

sbin/fsck_ffs/main.c

506

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

sbin/fsck_ffs/pass1.c

314

ndb = howmany(DIP(dp, di_size), sblock.fs_bsize);

sbin/fsck_ffs/pass1.c

331

ndb = howmany(DIP(dp, di_size),

sbin/fsck_ffs/pass1.c

334

ndb = howmany(DIP(dp, di_size),

sbin/fsck_ffs/pass1.c

406

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

sbin/fsck_ffs/pass1.c

80

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

sbin/fsck_ffs/pass5.c

127

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

sbin/fsck_ffs/pass5.c

129

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

sbin/fsck_ffs/pass5.c

139

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

sbin/fsck_ffs/pass5.c

198

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

sbin/fsck_ffs/pass5.c

471

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

sbin/fsck_ffs/pass5.c

485

howmany(fs->fs_fpg, CHAR_BIT),

sbin/fsck_ffs/setup.c

150

bmapsize = roundup(howmany(maxfsblock, CHAR_BIT), sizeof(short));

sbin/fsck_ffs/setup.c

287

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

sbin/fsck_ffs/setup.c

329

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

sbin/fsck_msdosfs/fat.c

1151

blobs = howmany(fat->fatsize, fat32_cache_size);

sbin/growfs/debug.c

516

e = howmany(sb->fs_old_cpg * sb->fs_old_spc / sb->fs_old_nspf,

sbin/growfs/debug.c

562

e = howmany(sb->fs_old_cpg * sb->fs_old_spc / (sb->fs_old_nspf << sb->fs_fragshift), CHAR_BIT);

sbin/growfs/debug.c

691

remaining_blocks = howmany(ino->di_size, sb->fs_bsize); /* XXX ts - +1? */

sbin/growfs/debug.c

701

remaining_blocks -= howmany(sb->fs_bsize, sizeof(ufs1_daddr_t));

sbin/growfs/debug.c

707

remaining_blocks -= SQUARE(howmany(sb->fs_bsize, sizeof(ufs1_daddr_t)));

sbin/growfs/debug.c

768

remaining_blocks = howmany(ino->di_size, sb->fs_bsize); /* XXX ts - +1? */

sbin/growfs/debug.c

778

remaining_blocks -= howmany(sb->fs_bsize, sizeof(ufs2_daddr_t));

sbin/growfs/debug.c

784

remaining_blocks -= SQUARE(howmany(sb->fs_bsize, sizeof(ufs2_daddr_t)));

sbin/growfs/debug.c

820

for (i = 0; (size_t)i < MIN(howmany(sb->fs_bsize, size), length);

sbin/growfs/growfs.c

1544

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

sbin/growfs/growfs.c

320

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

sbin/growfs/growfs.c

347

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

sbin/growfs/growfs.c

348

acg.cg_nextfreeoff = acg.cg_freeoff + howmany(sblock.fs_fpg, CHAR_BIT);

sbin/growfs/growfs.c

356

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

sbin/growfs/growfs.c

799

if (howmany(sblock.fs_cssize, sblock.fs_fsize) ==

sbin/growfs/growfs.c

800

howmany(osblock.fs_cssize, osblock.fs_fsize)) {

sbin/growfs/growfs.c

808

sblock.fs_dsize -= howmany(sblock.fs_cssize, sblock.fs_fsize) -

sbin/growfs/growfs.c

809

howmany(osblock.fs_cssize, osblock.fs_fsize);

sbin/growfs/growfs.c

874

for (block = howmany(d % sblock.fs_fpg, sblock.fs_frag),

sbin/ifconfig/ifconfig.c

957

uint8_t afmask[howmany(AF_MAX, NBBY)];

sbin/ifconfig/ifconfig.c

974

uint8_t afmask[howmany(AF_MAX, NBBY)];

sbin/newfs/mkfs.c

1049

frag = howmany(size, sblock.fs_fsize);

sbin/newfs/mkfs.c

306

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

sbin/newfs/mkfs.c

309

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

sbin/newfs/mkfs.c

369

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

sbin/newfs/mkfs.c

375

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

sbin/newfs/mkfs.c

392

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

sbin/newfs/mkfs.c

405

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

sbin/newfs/mkfs.c

417

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

sbin/newfs/mkfs.c

429

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

sbin/newfs/mkfs.c

479

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

sbin/newfs/mkfs.c

484

howmany(csfrags, sblock.fs_frag);

sbin/newfs/mkfs.c

721

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

sbin/newfs/mkfs.c

748

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

sbin/newfs/mkfs.c

749

acg.cg_nextfreeoff = acg.cg_freeoff + howmany(sblock.fs_fpg, CHAR_BIT);

sbin/newfs/mkfs.c

757

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

sbin/newfs_msdos/mkfs_msdos.c

461

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

sbin/newfs_msdos/mkfs_msdos.c

465

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

sbin/newfs_msdos/mkfs_msdos.c

469

howmany(DEFBLK, bpb.bpbBytesPerSec)))

sbin/newfs_msdos/mkfs_msdos.c

473

howmany((RESFTE + MAXCLS16) * 2, bpb.bpbBytesPerSec) *

sbin/newfs_msdos/mkfs_msdos.c

475

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

sbin/newfs_msdos/mkfs_msdos.c

478

howmany(8192, bpb.bpbBytesPerSec)))

sbin/newfs_msdos/mkfs_msdos.c

536

rds = howmany(bpb.bpbRootDirEnts,

sbin/newfs_msdos/mkfs_msdos.c

539

for (bpb.bpbSecPerClust = howmany(fat == 16 ? DEFBLK16 :

sbin/newfs_msdos/mkfs_msdos.c

542

howmany((RESFTE + maxcls(fat)) * (fat / BPN),

sbin/newfs_msdos/mkfs_msdos.c

565

x2 = howmany((RESFTE + MIN(x, maxcls(fat))) * (fat / BPN),

sbin/restore/interactive.c

665

lines = howmany(nentry, columns);

sbin/restore/tape.c

279

map = calloc((unsigned)1, (unsigned)howmany(maxino, NBBY));

sbin/restore/tape.c

289

map = calloc((unsigned)1, (unsigned)howmany(maxino, NBBY));

stand/common/gfx_fb.c

2363

stride = howmany(vf->vf_width, 8) * vf->vf_height;

stand/common/gfx_fb.c

2520

size = howmany(fp->vf_width, 8) * fp->vf_height * glyphs;

stand/common/part.c

259

howmany(phdr->hdr_entries * phdr->hdr_entsz,

stand/common/part.c

293

howmany(phdr->hdr_entries * phdr->hdr_entsz,

stand/libsa/ext2fs.c

390

groups = howmany(fs->fs_blocks - fs->fs_firstblk, fs->fs_bpg);

stand/libsa/ext2fs.c

392

blkgrps = howmany(groups, bg_per_blk);

sys/amd64/amd64/kexec_support.c

270

pages += howmany(end - (start & ~PML4MASK), NBPML4);

sys/amd64/amd64/kexec_support.c

271

pages += howmany(end - (start & ~PDPMASK), NBPDP);

sys/amd64/amd64/kexec_support.c

272

pages += howmany(end - (start & ~PDRMASK), NBPDR);

sys/amd64/amd64/kexec_support.c

276

pages += howmany(end - (start & ~PDPMASK), NBPDP) - 1;

sys/amd64/amd64/kexec_support.c

277

pages += howmany(end - (start & ~PDRMASK), NBPDR);

sys/amd64/amd64/kexec_support.c

284

pages += howmany(source_total, NBPDR);

sys/amd64/amd64/kexec_support.c

285

pages += howmany(source_total, NBPDP);

sys/amd64/amd64/kexec_support.c

286

pages += howmany(source_total, NBPML4);

sys/amd64/amd64/kexec_support.c

292

pages += howmany(pages * PAGE_SIZE, NBPDR);

sys/amd64/amd64/kexec_support.c

293

pages += howmany(pages * PAGE_SIZE, NBPDP);

sys/amd64/amd64/kexec_support.c

294

pages += howmany(pages * PAGE_SIZE, NBPML4);

sys/amd64/amd64/kexec_support.c

297

pages += howmany(kexec_do_reboot_size, PAGE_SIZE);

sys/amd64/amd64/pmap.c

11698

(NKASANPML4E + 2 + 2 + howmany(KSTACK_PAGES, KASAN_SHADOW_SCALE))

sys/amd64/amd64/pmap.c

1649

#define NKPDPE(ptpgs) howmany(ptpgs, NPDEPG)

sys/amd64/amd64/pmap.c

1659

pt_pages = howmany(addr - kernphys, NBPDR) + 1; /* +1 for 2M hole @0 */

sys/amd64/amd64/pmap.c

1792

ndmpdp = howmany(ptoa(Maxmem), NBPDP);

sys/amd64/amd64/pmap.c

1795

ndmpdpphys = howmany(ndmpdp, NPDPEPG);

sys/amd64/amd64/pmap.c

1797

ndmpml4phys = howmany(ndmpdpphys, NPML4EPG);

sys/amd64/amd64/pmap.c

1835

nkdmpde = howmany((vm_offset_t)brwsection - KERNSTART +

sys/amd64/amd64/pmap.c

1882

nkasanpte = howmany(nkpt, KASAN_SHADOW_SCALE);

sys/amd64/amd64/pmap.c

2415

pv_npg = howmany(pmap_last_pa, NBPDR);

sys/amd64/amd64/pmap.c

2480

pv_npg = howmany(vm_phys_segs[vm_phys_nsegs - 1].end, NBPDR);

sys/amd64/amd64/pmap.c

2658

for (i = 0; i < howmany((vm_offset_t)NBPML4 *

sys/amd64/amd64/pmap.c

4911

npdpg = howmany(size, NBPDP);

sys/amd64/amd64/pmap.c

5111

nkpt = howmany(end - KERNBASE, NBPDR);

sys/arm/arm/busdma_machdep.c

721

howmany(dmat->maxsize, MIN(dmat->maxsegsz, PAGE_SIZE)) &&

sys/arm/arm/machdep_boot.c

364

i += howmany(fake_preload[i - 1], sizeof(uint32_t));

sys/arm/freescale/imx/imx_i2c.c

625

div = howmany(ipgfreq, busfreq);

sys/arm/nvidia/as3722_regulators.c

48

#define DIV_ROUND_UP(n,d) howmany(n, d)

sys/arm/nvidia/tegra_xhci.c

796

code_tags = howmany(fw_hdr->boot_codetag, XUSB_CSB_IMEM_BLOCK_SIZE);

sys/arm/nvidia/tegra_xhci.c

797

code_size = howmany(fw_hdr->boot_codesize, XUSB_CSB_IMEM_BLOCK_SIZE);

sys/arm64/arm64/busdma_bounce.c

578

howmany(dmat->alloc_size, MIN(dmat->common.maxsegsz, PAGE_SIZE)) &&

sys/arm64/arm64/gicv3_its.c

649

npages = howmany(its_tbl_size, PAGE_SIZE);

sys/arm64/arm64/gicv3_its.c

669

nitspages = howmany(its_tbl_size, page_size);

sys/arm64/nvidia/tegra210/max77620_regulators.c

49

#define DIV_ROUND_UP(n,d) howmany(n, d)

sys/arm64/vmm/io/vgic_v3.c

1049

typer |= howmany(VGIC_NIRQS + 1, 32) - 1;

sys/arm64/vmm/vmm_arm64.c

981

levels = howmany(address_bits, granule_shift - PTE_SHIFT);

sys/cam/ata/ata_da.c

2068

howmany(ranges, ATA_DSM_BLK_RANGES) * ATA_DSM_BLK_SIZE,

sys/cam/ata/ata_da.c

2071

ATA_DSM_TRIM, 0, howmany(ranges, ATA_DSM_BLK_RANGES));

sys/cam/ata/ata_da.c

2087

howmany(ranges, ATA_DSM_BLK_RANGES) * ATA_DSM_BLK_SIZE,

sys/cam/ata/ata_da.c

2092

howmany(ranges, ATA_DSM_BLK_RANGES));

sys/cam/ctl/ctl_frontend_iscsi.c

2649

PRIV_EXPDATASN(io) += howmany(response->ip_data_len,

sys/cam/ctl/ctl_frontend_iscsi.c

2686

PRIV_EXPDATASN(io) += howmany(response->ip_data_len,

sys/cam/scsi/scsi_da.c

4322

block_count = howmany(ranges, ATA_DSM_BLK_RANGES);

sys/compat/linux/linux_socket.c

612

return (howmany(linux_timeout, 1000U));

sys/compat/linuxkpi/common/include/linux/ascii85.h

19

out_len = howmany(in_len, 4);

sys/compat/linuxkpi/common/include/linux/bitmap.h

313

const unsigned int end = howmany(size, 32);

sys/compat/linuxkpi/common/include/linux/bitmap.h

338

const unsigned int end32 = howmany(size, 32);

sys/compat/linuxkpi/common/include/linux/bitops.h

45

#define BITS_TO_LONGS(n) howmany((n), BITS_PER_LONG)

sys/compat/linuxkpi/common/include/linux/bitops.h

52

#define BITS_TO_BYTES(n) howmany((n), BITS_PER_BYTE)

sys/compat/linuxkpi/common/include/linux/delay.h

63

DELAY(howmany(x, 1000));

sys/compat/linuxkpi/common/include/linux/jiffies.h

105

return (howmany(nsec * lkpi_nsec2hz_rem, lkpi_nsec2hz_div));

sys/compat/linuxkpi/common/include/linux/jiffies.h

119

return (howmany(nsec * lkpi_nsec2hz_rem, lkpi_nsec2hz_div));

sys/compat/linuxkpi/common/include/linux/jiffies.h

78

result = howmany(msec * lkpi_msec2hz_rem, lkpi_msec2hz_div);

sys/compat/linuxkpi/common/include/linux/jiffies.h

92

result = howmany(usec * lkpi_usec2hz_rem, lkpi_usec2hz_div);

sys/compat/linuxkpi/common/include/linux/kernel.h

129

#define __KERNEL_DIV_ROUND_UP(x, n) howmany(x, n)

sys/compat/linuxkpi/common/include/linux/math.h

47

#define DIV_ROUND_UP(x, n) howmany(x, n)

sys/compat/linuxkpi/common/include/linux/radix-tree.h

39

howmany(sizeof(long) * NBBY, RADIX_TREE_MAP_SHIFT)

sys/compat/linuxkpi/common/include/linux/types.h

76

unsigned long n[howmany(bits, sizeof(long) * 8)]

sys/compat/linuxkpi/common/src/linux_page.c

724

pages = alloc_pages(gfp, flsl(howmany(fragsz, PAGE_SIZE) - 1));

sys/compat/x86bios/x86bios.c

331

j < howmany(size, X86BIOS_PAGE_SIZE); i++, j++)

sys/compat/x86bios/x86bios.c

565

sizeof(*x86bios_map) * howmany(size, X86BIOS_PAGE_SIZE));

sys/dev/age/if_age.c

2459

if (nsegs != howmany(pktlen, AGE_RX_BUF_SIZE))

sys/dev/ath/ath_hal/ah.c

416

numSymbols = howmany(numBits, bitsPerSymbol);

sys/dev/ath/ath_hal/ah.c

465

numSymbols = howmany(numBits, bitsPerSymbol);

sys/dev/ath/ath_hal/ah.c

476

numSymbols = howmany(numBits, bitsPerSymbol);

sys/dev/ath/ath_hal/ah.c

487

numSymbols = howmany(numBits, bitsPerSymbol);

sys/dev/ath/ath_hal/ah.c

498

numSymbols = howmany(numBits, bitsPerSymbol);

sys/dev/ath/ath_hal/ah_internal.h

40

#ifndef howmany

sys/dev/axgbe/xgbe_osdep.h

193

#define BITS_TO_LONGS(n) howmany((n), BITS_PER_LONG)

sys/dev/bwi/bwimac.c

1889

rf_atten_adj = -howmany(txpwr_diff, 8);

sys/dev/bwi/if_bwi.c

1188

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

sys/dev/bwi/if_bwi.c

1190

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

sys/dev/bwi/if_bwi.c

2867

len = howmany(pkt_bitlen * 2, rate);

sys/dev/bwi/if_bwi.c

3449

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

sys/dev/bwn/if_bwn_phy_lp.c

899

if (howmany(tmp[3], tmp[2]) > 60) {

sys/dev/clk/xilinx/zynqmp_clk_div.c

77

*freq = howmany((unsigned long long)*freq, div + 1);

sys/dev/cxgbe/adapter.h

1698

return (howmany(len16, EQ_ESIZE / 16));

sys/dev/cxgbe/common/common.h

1096

ulpmc->len = htobe32(howmany(LEN__SET_TCB_FIELD_ULP, 16));

sys/dev/cxgbe/crypto/t4_crypto.c

316

nsegs += howmany(sg->sg_segs[i].ss_len, maxsegsize);

sys/dev/cxgbe/crypto/t6_kern_tls.c

1130

len16 = howmany(sizeof(struct fw_eth_tx_pkt_wr) + ctrl, 16);

sys/dev/cxgbe/crypto/t6_kern_tls.c

1231

len16 = howmany(sizeof(struct fw_eth_tx_pkt_wr) + ctrl, 16);

sys/dev/cxgbe/crypto/t6_kern_tls.c

1591

ndesc = howmany(wr_len, EQ_ESIZE);

sys/dev/cxgbe/crypto/t6_kern_tls.c

1609

howmany(wr_len, EQ_ESIZE));

sys/dev/cxgbe/crypto/t6_kern_tls.c

1622

MPASS(ndesc + howmany(wr_len, EQ_ESIZE) <= available);

sys/dev/cxgbe/crypto/t6_kern_tls.c

1635

txpkt->len = htobe32(howmany(twr_len - sizeof(*wr), 16));

sys/dev/cxgbe/crypto/t6_kern_tls.c

1831

ndesc += howmany(wr_len, EQ_ESIZE);

sys/dev/cxgbe/crypto/t6_kern_tls.c

1849

txsd->desc_used = howmany(wr_len, EQ_ESIZE);

sys/dev/cxgbe/crypto/t6_kern_tls.c

1876

len16 = howmany(sizeof(struct fw_eth_tx_pkt_wr) + ctrl, 16);

sys/dev/cxgbe/crypto/t6_kern_tls.c

289

txpkt->len = htobe32(howmany(LEN__SET_TCB_FIELD_ULP, 16));

sys/dev/cxgbe/crypto/t7_kern_tls.c

1169

len16 = howmany(sizeof(struct fw_eth_tx_pkt_wr) + ctrl, 16);

sys/dev/cxgbe/crypto/t7_kern_tls.c

1534

ndesc = howmany(wr_len, EQ_ESIZE);

sys/dev/cxgbe/crypto/t7_kern_tls.c

1561

txpkt->len = htobe32(howmany(txpkt_lens[0], 16));

sys/dev/cxgbe/crypto/t7_kern_tls.c

1953

txpkt->len = htobe32(howmany(txpkt_lens[1], 16));

sys/dev/cxgbe/iw_cxgbe/qp.c

1329

KASSERT(howmany(wrsize, 16) <= MAX_OFLD_TX_SDESC_CREDITS,

sys/dev/cxgbe/iw_cxgbe/qp.c

1330

("%s: tx_credits %zu too large", __func__, howmany(wrsize, 16)));

sys/dev/cxgbe/iw_cxgbe/qp.c

1331

txsd->tx_credits = howmany(wrsize, 16);

sys/dev/cxgbe/nvmf/nvmf_che.c

382

return (howmany(che_fbo(cb) + cb->io.io_len, PAGE_SIZE));

sys/dev/cxgbe/nvmf/nvmf_che.c

651

for (k = 0; k < howmany(len, PAGE_SIZE); k++) {

sys/dev/cxgbe/nvmf/nvmf_che.c

674

for (k = 0; k < howmany(len, PAGE_SIZE); k++) {

sys/dev/cxgbe/osdep.h

90

#define DIV_ROUND_UP(x, y) howmany(x, y)

sys/dev/cxgbe/t4_filter.c

1318

fwr = start_wrq_wr(&sc->sge.ctrlq[0], howmany(sizeof(*fwr), 16), &cookie);

sys/dev/cxgbe/t4_filter.c

1395

req = start_wrq_wr(&sc->sge.ctrlq[0], howmany(sizeof(*req), 16), &cookie);

sys/dev/cxgbe/t4_filter.c

1809

howmany(sizeof (struct cpl_act_open_req), 16),

sys/dev/cxgbe/t4_filter.c

1810

howmany(sizeof (struct cpl_act_open_req6), 16)

sys/dev/cxgbe/t4_filter.c

1813

howmany(sizeof (struct cpl_t5_act_open_req), 16),

sys/dev/cxgbe/t4_filter.c

1814

howmany(sizeof (struct cpl_t5_act_open_req6), 16)

sys/dev/cxgbe/t4_filter.c

1817

howmany(sizeof (struct cpl_t6_act_open_req), 16),

sys/dev/cxgbe/t4_filter.c

1818

howmany(sizeof (struct cpl_t6_act_open_req6), 16)

sys/dev/cxgbe/t4_filter.c

1821

howmany(sizeof (struct cpl_t7_act_open_req), 16),

sys/dev/cxgbe/t4_filter.c

1822

howmany(sizeof (struct cpl_t7_act_open_req6), 16)

sys/dev/cxgbe/t4_filter.c

1926

ulpmc->len = htobe32(howmany(LEN__ABORT_REQ_ULP, 16));

sys/dev/cxgbe/t4_filter.c

1958

ulpmc->len = htobe32(howmany(LEN__ABORT_RPL_ULP, 16));

sys/dev/cxgbe/t4_filter.c

2035

wr = start_wrq_wr(&sc->sge.ctrlq[0], howmany(wrlen, 16), &cookie);

sys/dev/cxgbe/t4_filter.c

807

len16 = howmany(sizeof(struct fw_filter2_wr), 16);

sys/dev/cxgbe/t4_filter.c

809

len16 = howmany(sizeof(struct fw_filter_wr), 16);

sys/dev/cxgbe/t4_l2t.c

183

req = start_wrq_wr(wrq, howmany(sizeof(*req), 16), &cookie);

sys/dev/cxgbe/t4_l2t.c

274

*ndesc = howmany(sizeof(struct cpl_l2t_write_req), EQ_ESIZE);

sys/dev/cxgbe/t4_main.c

7411

wrq->ndesc_needed -= howmany(wr->wr_len, EQ_ESIZE);

sys/dev/cxgbe/t4_sge.c

2218

n = howmany(wr->wr_len, EQ_ESIZE);

sys/dev/cxgbe/t4_sge.c

2285

wrq->ndesc_needed += howmany(wr->wr_len, EQ_ESIZE);

sys/dev/cxgbe/t4_sge.c

2418

set_mbuf_len16(m, howmany(len, 16));

sys/dev/cxgbe/t4_sge.c

5375

return (howmany(n, 16));

sys/dev/cxgbe/t4_sge.c

5394

return (howmany(n, 16));

sys/dev/cxgbe/t4_sge.c

5436

return (howmany(n, 16));

sys/dev/cxgbe/t4_sge.c

5450

return (howmany(n, 16));

sys/dev/cxgbe/t4_sge.c

5795

len16 = howmany(sizeof(struct fw_eth_tx_pkt_wr) +

sys/dev/cxgbe/t4_sge.c

5941

txp->len16 = howmany(sizeof(struct fw_eth_tx_pkts_vm_wr), 16) +

sys/dev/cxgbe/t4_sge.c

5978

howmany(sizeof(struct fw_eth_tx_pkts_wr), 16) +

sys/dev/cxgbe/t4_sge.c

5983

howmany(sizeof(struct fw_eth_tx_pkts_wr), 16) +

sys/dev/cxgbe/t4_sge.c

6046

MPASS(txp->len16 <= howmany(SGE_MAX_WR_LEN, 16));

sys/dev/cxgbe/t4_sge.c

6159

MPASS(txp->len16 <= howmany(SGE_MAX_WR_LEN, 16));

sys/dev/cxgbe/t4_sge.c

6737

return (howmany(n, 16));

sys/dev/cxgbe/t4_sge.c

6744

#define ETID_FLOWC_LEN16 (howmany(ETID_FLOWC_LEN, 16))

sys/dev/cxgbe/t4_sge.c

6793

#define ETID_FLUSH_LEN16 (howmany(sizeof (struct fw_flowc_wr), 16))

sys/dev/cxgbe/t4_smt.c

132

req = start_wrq_wr(wrq, howmany(sizeof(*req), 16), &cookie);

sys/dev/cxgbe/t4_smt.c

161

t6req = start_wrq_wr(wrq, howmany(sizeof(*t6req), 16), &cookie);

sys/dev/cxgbe/tom/t4_cpl_io.c

1118

npdu = iso ? howmany(plen - ISCSI_BHS_SIZE, iso_mss) : 1;

sys/dev/cxgbe/tom/t4_cpl_io.c

1143

credits = howmany(wr->wr_len, 16);

sys/dev/cxgbe/tom/t4_cpl_io.c

118

flowc->flowid_len16 = htonl(V_FW_WR_LEN16(howmany(flowclen, 16)) |

sys/dev/cxgbe/tom/t4_cpl_io.c

1346

npdu = howmany(plen - hdr->hlen, iso_mss);

sys/dev/cxgbe/tom/t4_cpl_io.c

1375

credits = howmany(wr->wr_len, 16);

sys/dev/cxgbe/tom/t4_cpl_io.c

1491

credits = howmany(wr->wr_len, 16);

sys/dev/cxgbe/tom/t4_cpl_io.c

153

KASSERT(howmany(flowclen, 16) <= MAX_OFLD_TX_SDESC_CREDITS,

sys/dev/cxgbe/tom/t4_cpl_io.c

154

("%s: tx_credits %u too large", __func__, howmany(flowclen, 16)));

sys/dev/cxgbe/tom/t4_cpl_io.c

155

txsd->tx_credits = howmany(flowclen, 16);

sys/dev/cxgbe/tom/t4_cpl_io.c

199

flowclen16 = howmany(flowclen, 16);

sys/dev/cxgbe/tom/t4_cpl_io.c

2330

_Static_assert(howmany(len, 16) <= MAX_OFLD_TX_SDESC_CREDITS,

sys/dev/cxgbe/tom/t4_cpl_io.c

2332

txsd->tx_credits = howmany(len, 16);

sys/dev/cxgbe/tom/t4_cpl_io.c

481

req->wr.wr_mid = htonl(V_FW_WR_LEN16(howmany(sizeof(*req), 16)) |

sys/dev/cxgbe/tom/t4_cpl_io.c

495

#define MIN_OFLD_TX_CREDITS (howmany(sizeof(struct fw_ofld_tx_data_wr) + 1, 16))

sys/dev/cxgbe/tom/t4_cpl_io.c

496

#define MIN_ISO_TX_CREDITS (howmany(sizeof(struct cpl_tx_data_iso), 16))

sys/dev/cxgbe/tom/t4_cpl_io.c

637

credits = howmany(plen, 16);

sys/dev/cxgbe/tom/t4_cpl_io.c

879

credits = howmany(wr->wr_len, 16);

sys/dev/cxgbe/tom/t4_cpl_io.c

899

credits = howmany(wr_len, 16);

sys/dev/cxgbe/tom/t4_ddp.c

1349

return (howmany(npages >> (ddp_page_shift - PAGE_SHIFT), PPOD_PAGES));

sys/dev/cxgbe/tom/t4_ddp.c

1505

nppods = howmany(npages, PPOD_PAGES);

sys/dev/cxgbe/tom/t4_ddp.c

1589

nppods = howmany(npages, PPOD_PAGES);

sys/dev/cxgbe/tom/t4_ddp.c

1662

ulpmc->len16 = htobe32(howmany(len - sizeof(ulpmc->wr), 16));

sys/dev/cxgbe/tom/t4_ddp.c

1744

ulpmc->len16 = htobe32(howmany(len - sizeof(ulpmc->wr), 16));

sys/dev/cxgbe/tom/t4_ddp.c

1852

ulpmc->len16 = htobe32(howmany(len - sizeof(ulpmc->wr), 16));

sys/dev/cxgbe/tom/t4_ddp.c

1935

ulpmc->len16 = htobe32(howmany(len - sizeof(ulpmc->wr), 16));

sys/dev/cxgbe/tom/t4_ddp.c

2029

ulpmc->len16 = htobe32(howmany(len - sizeof(ulpmc->wr), 16));

sys/dev/cxgbe/tom/t4_ddp.c

555

ulpmc->len = htobe32(howmany(LEN__RX_DATA_ACK_ULP, 16));

sys/dev/cxgbe/tom/t4_listen.c

507

flowc->flowid_len16 = htonl(V_FW_WR_LEN16(howmany(flowclen, 16)) |

sys/dev/cxgbe/tom/t4_tls.c

360

(howmany(sizeof(struct fw_tlstx_data_wr) + \

sys/dev/cxgbe/tom/t4_tls.c

629

if (howmany(wr_len, 16) > tx_credits) {

sys/dev/cxgbe/tom/t4_tls.c

638

__func__, toep->tid, m, howmany(wr_len, 16),

sys/dev/cxgbe/tom/t4_tls.c

687

credits = howmany(wr_len, 16);

sys/dev/cxgbe/tom/t4_tom.c

124

tx_credits -= howmany(sizeof(struct cpl_abort_req), 16);

sys/dev/cxgbe/tom/t4_tom.c

132

howmany(sizeof(struct fw_ofld_tx_data_wr) + 1, 16);

sys/dev/cxgbe/tom/t4_tom.c

2343

flowc->flowid_len16 = htonl(V_FW_WR_LEN16(howmany(flowclen, 16)) |

sys/dev/cxgbe/tom/t4_tom.c

2349

KASSERT(howmany(flowclen, 16) <= MAX_OFLD_TX_SDESC_CREDITS,

sys/dev/cxgbe/tom/t4_tom.c

2350

("%s: tx_credits %u too large", __func__, howmany(flowclen, 16)));

sys/dev/cxgbe/tom/t4_tom.c

2351

txsd->tx_credits = howmany(flowclen, 16);

sys/dev/cxgbe/tom/t4_tom.c

490

cpl = start_wrq_wr(&sc->sge.ctrlq[0], howmany(sizeof(*cpl), 16),

sys/dev/cxgbe/tom/t4_tom.c

871

const int flowclen16 = howmany(flowclen, 16);

sys/dev/cxgbe/tom/t4_tom.c

944

wrh = start_wrq_wr(toep->ctrlq, howmany(len, 16), &cookie);

sys/dev/drm2/drm_atomic.h

38

#define BITS_TO_LONGS(x) howmany(x, NB_BITS_PER_LONG)

sys/dev/fb/vga.c

1246

count = howmany(pixel, ppw)/2;

sys/dev/fb/vga.c

1247

bpl = (howmany(pixel, ppw)/2)*4;

sys/dev/firewire/fwcrom.c

457

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

sys/dev/firewire/fwcrom.c

464

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

sys/dev/firewire/fwdma.c

160

nseg = howmany(n, ssize / esize);

sys/dev/firewire/sbp.c

135

#define SBP_IND_MAX howmany(SBP_MAXPHYS, PAGE_SIZE)

sys/dev/gve/gve_tx_dqo.c

726

nsegs = howmany(mbuf->m_pkthdr.len, GVE_TX_BUF_SIZE_DQO);

sys/dev/hid/hidmap.c

132

hm->key_press = malloc(howmany(KEY_CNT, 8), M_DEVBUF,

sys/dev/hid/hidmap.c

142

hm->key_rel = malloc(howmany(KEY_CNT, 8), M_DEVBUF,

sys/dev/hid/hidmap.c

175

bzero(hm->key_press, howmany(KEY_CNT, 8));

sys/dev/hid/hidmap.c

176

bzero(hm->key_rel, howmany(KEY_CNT, 8));

sys/dev/hid/hidmap.c

712

bzero(hm->key_press, howmany(KEY_CNT, 8));

sys/dev/hid/hidmap.h

219

#define HIDMAP_CAPS_SZ(nitems) howmany((nitems), 8)

sys/dev/hid/hmt.c

198

uint8_t caps[howmany(HMT_N_USAGES, 8)];

sys/dev/hid/hmt.c

199

uint8_t buttons[howmany(HMT_BTN_MAX, 8)];

sys/dev/ice/ice_osdep.h

82

#define DIVIDE_AND_ROUND_UP howmany

sys/dev/ida/ida.c

461

hwqcb->req.bcount = htole16(howmany(datasize, DEV_BSIZE));

sys/dev/ida/ida.c

518

hwqcb->req.bcount = howmany(bp->bio_bcount, DEV_BSIZE);

sys/dev/intel/spi.c

401

sscr0 |= SSCR0_SCR(howmany(MAX_CLOCK_RATE, min(MAX_CLOCK_RATE, clock)));

sys/dev/iscsi/iscsi.c

1371

datasn += howmany(len,

sys/dev/iwm/if_iwm.c

516

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

sys/dev/iwm/if_iwm.c

541

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

sys/dev/iwm/if_iwmvar.h

163

uint8_t enabled_api[howmany(IWM_NUM_UCODE_TLV_API, NBBY)];

sys/dev/iwm/if_iwmvar.h

164

uint8_t enabled_capa[howmany(IWM_NUM_UCODE_TLV_CAPA, NBBY)];

sys/dev/iwx/if_iwx.c

1495

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

sys/dev/iwx/if_iwx.c

1516

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

sys/dev/iwx/if_iwx.c

5630

num_fetch_chunks = howmany(filled_tfd_size, 64) - 1;

sys/dev/iwx/if_iwx.c

5640

len = howmany(len, 4);

sys/dev/iwx/if_iwxvar.h

729

uint8_t sc_ucode_api[howmany(IWX_NUM_UCODE_TLV_API, NBBY)];

sys/dev/iwx/if_iwxvar.h

730

uint8_t sc_enabled_capa[howmany(IWX_NUM_UCODE_TLV_CAPA, NBBY)];

sys/dev/jme/if_jme.c

2631

if (nsegs != howmany(pktlen, MCLBYTES))

sys/dev/liquidio/lio_rxtx.c

191

tx_info->s.gso_segs = howmany(m_head->m_pkthdr.len,

sys/dev/mana/gdma_main.c

1467

int n = howmany(res_avail, BITS_PER_LONG);

sys/dev/mana/gdma_util.h

76

#define BITS_TO_LONGS(n) howmany((n), BITS_PER_LONG)

sys/dev/mfi/mfi.c

2158

blkcount = howmany(bio->bio_bcount, MFI_SECTOR_LEN);

sys/dev/mfi/mfi.c

2219

blkcount = howmany(bio->bio_bcount, MFI_SECTOR_LEN);

sys/dev/mfi/mfi.c

2625

io->header.data_len = howmany(len, MFI_SECTOR_LEN);

sys/dev/mfi/mfi.c

2663

blkcount = howmany(len, MFI_SECTOR_LEN);

sys/dev/mlx/mlx.c

1862

blkcount = howmany(bp->bio_bcount, MLX_BLKSIZE);

sys/dev/mlx5/mlx5_core/mlx5_alloc.c

77

buf->npages = howmany(size, PAGE_SIZE);

sys/dev/mlx5/mlx5_core/mlx5_cmd.c

1119

n = howmany(blen, MLX5_CMD_DATA_BLOCK_SIZE);

sys/dev/mlx5/mlx5_core/mlx5_cmd.c

1121

msg = mlx5_fwp_alloc(dev, flags, howmany(n, MLX5_NUM_CMDS_IN_ADAPTER_PAGE));

sys/dev/mlx5/mlx5_en/mlx5_en_ethtool.c

212

max_bw_value[i] = howmany(temp, MLX5E_100MB);

sys/dev/mlx5/mlx5_en/mlx5_en_ethtool.c

215

max_bw_value[i] = howmany(temp, MLX5E_1GB);

sys/dev/mlx5/mlx5_en/mlx5_en_main.c

2332

n = roundup_pow_of_two(1 + howmany(maxs, r)) - 1;

sys/dev/mlx5/mlx5_en/mlx5_en_rl.c

1382

mlx5_rl_is_in_range(rl->priv->mdev, howmany(value, 1000), 0) == 0)

sys/dev/mlx5/mlx5_en/mlx5_en_rl.c

417

if (distance > howmany(user_rate *

sys/dev/mlx5/mlx5_en/mlx5_en_rl.c

536

howmany(rate, 1000), burst, &index);

sys/dev/mlx5/mlx5_en/mlx5_en_rl.c

569

howmany(rate, 1000), burst);

sys/dev/mlx5/mlx5_en/mlx5_en_tx.c

600

xsegs += howmany((u32)segs[x].ds_len, msb);

sys/dev/mmc/host/dwmmc.c

93

#define DIV_ROUND_UP(n, d) howmany(n, d)

sys/dev/mpr/mpr.c

1515

BD_MAXSEGSIZE(rsize), BD_NSEGMENTS((howmany(rsize, PAGE_SIZE))),

sys/dev/mps/mps.c

1455

BD_NSEGMENTS(howmany(rsize, PAGE_SIZE)),

sys/dev/netmap/netmap_kern.h

2311

u_int *j, u_int lim, u_int *howmany);

sys/dev/netmap/netmap_offloadings.c

156

u_int *j, u_int lim, u_int *howmany)

sys/dev/netmap/netmap_offloadings.c

265

if (dst_slots >= *howmany) {

sys/dev/netmap/netmap_offloadings.c

486

if (unlikely(dst_slots > *howmany)) {

sys/dev/netmap/netmap_offloadings.c

490

*howmany -= dst_slots;

sys/dev/netmap/netmap_vale.c

1035

if (unlikely(howmany > 0)) {

sys/dev/netmap/netmap_vale.c

1040

nm_prdis("leftover %d bufs", howmany);

sys/dev/netmap/netmap_vale.c

1046

while (howmany-- > 0) {

sys/dev/netmap/netmap_vale.c

832

u_int needed, howmany;

sys/dev/netmap/netmap_vale.c

934

howmany = nm_kr_space(kring, 1);

sys/dev/netmap/netmap_vale.c

935

if (needed < howmany)

sys/dev/netmap/netmap_vale.c

936

howmany = needed;

sys/dev/netmap/netmap_vale.c

937

lease_idx = nm_kr_lease(kring, howmany, 1);

sys/dev/netmap/netmap_vale.c

941

if (retry && needed <= howmany)

sys/dev/netmap/netmap_vale.c

945

while (howmany > 0) {

sys/dev/netmap/netmap_vale.c

964

if (unlikely(cnt > howmany))

sys/dev/netmap/netmap_vale.c

970

bdg_mismatch_datapath(na, dst_na, ft_p, ring, &j, lim, &howmany);

sys/dev/netmap/netmap_vale.c

972

howmany -= cnt;

sys/dev/nvme/nvme_ctrlr.c

904

ctrlr->hmb_nchunks = howmany(pref, ctrlr->hmb_chunk);

sys/dev/nvme/nvme_qpair.c

544

howmany(ctrlr->max_xfer_size, ctrlr->page_size) + 1,

sys/dev/nvme/nvme_qpair.c

566

howmany(ctrlr->max_xfer_size, ctrlr->page_size);

sys/dev/ral/rt2560.c

1427

plcp_length = howmany(16 * len, rate);

sys/dev/ral/rt2661.c

1248

plcp_length = howmany(16 * len, rate);

sys/dev/random/fenestrasX/fx_rng.c

138

blockcount = howmany(nbytes, CHACHA_BLOCKLEN);

sys/dev/random/fortuna.c

702

blockcount = howmany(bytecount, CHACHA_BLOCKLEN);

sys/dev/random/fortuna.c

704

blockcount = howmany(bytecount, RANDOM_BLOCKSIZE);

sys/dev/random/random_harvestq.c

252

npools = howmany(p_random_alg_context->ra_poolcount, RANDOM_KTHREAD_HZ);

sys/dev/random/random_harvestq.c

273

npools = howmany(p_random_alg_context->ra_poolcount *

sys/dev/random/random_harvestq.c

563

ht->ht_rct_limit = 1 + howmany(error_rate, min_entropy);

sys/dev/regulator/regulator.c

59

#define DIV_ROUND_UP(n,d) howmany(n, d)

sys/dev/rtwn/if_rtwn.c

921

null_data = howmany(bcn_size, sc->page_size);

sys/dev/rtwn/if_rtwnvar.h

216

uint8_t keys_bmap[howmany(RTWN_CAM_ENTRY_LIMIT, NBBY)];

sys/dev/sbni/if_sbni.c

720

sc->tx_frameno = howmany(len, sc->maxframe);

sys/dev/sdhci/sdhci.c

2011

blkcnt = howmany(data->len, 512);

sys/dev/sdhci/sdhci_fsl_fdt.c

1058

*result = howmany(slot->sdma_bbufsz, 512);

sys/dev/sfxge/sfxge_tx.c

1000

howmany(TSOH_COUNT(_txq_entries), TSOH_PER_PAGE)

sys/dev/sfxge/sfxge_tx.c

1597

howmany(SFXGE_TX_MAPPING_MAX_SEG,

sys/dev/sfxge/sfxge_tx.h

55

#define SFXGE_TSO_MAX_SEGS howmany(SFXGE_TSO_MAX_SIZE, 512)

sys/dev/sfxge/sfxge_tx.h

67

(2 + howmany(SFXGE_TSO_MAX_SIZE, MCLBYTES) + 1)

sys/dev/sound/usb/uaudio.c

1337

howmany(chan_alt->sample_rate * ms, 1000);

sys/dev/sound/usb/uaudio.c

1348

howmany(chan_alt->sample_rate * UAUDIO_BUFFER_MS_MAX, 1000);

sys/dev/sound/usb/uaudio.c

1495

chan->bytes_per_frame[1] = howmany(chan_alt->sample_rate, fps) *

sys/dev/sound/usb/uaudio.c

2307

int32_t jitter_max = howmany(sample_rate, 16000);

sys/dev/sym/sym_hipd.c

2517

period = howmany(4 * div_10M[0], np->clock_khz);

sys/dev/sym/sym_hipd.c

2521

else np->minsync = howmany(period, 40);

sys/dev/syscons/scmouse.c

255

cols = 1 + howmany(10 - 1, scp->font_width); /* up to VGA cursor width 9 */

sys/dev/syscons/scmouse.c

258

rows = 1 + howmany(16 - 1, scp->font_size); /* up to VGA cursor height 16 */

sys/dev/syscons/syscons.c

3347

sc->dflt_curs_attr.height = howmany(scp->font_size, 8);

sys/dev/ufshci/ufshci_req_sdb.c

128

payload_allocsz, howmany(payload_allocsz, ctrlr->page_size) + 1,

sys/dev/ufshci/ufshci_req_sdb.c

97

howmany(ucd_allocsz, sizeof(struct ufshci_utp_cmd_desc)),

sys/dev/usb/controller/ehci.c

1643

if (howmany(average, temp->max_frame_size) & 1) {

sys/dev/usb/controller/ohci.c

2397

howmany(xfer->nframes, OHCI_ITD_NOFFSET) +

sys/dev/usb/controller/xhci.c

1901

npkt = howmany(len_old - npkt_off,

sys/dev/usb/controller/xhci.c

2251

tdpc = howmany(temp.len, xfer->max_packet_size);

sys/dev/usb/controller/xhci.c

2253

temp.tbc = howmany(tdpc, mult) - 1;

sys/dev/usb/input/ukbd.c

136

uint64_t bitmap[howmany(UKBD_NKEYCODE, 64)];

sys/dev/usb/input/ukbd.c

151

uint64_t sc_loc_key_valid[howmany(UKBD_NKEYCODE, 64)];

sys/dev/usb/input/ukbd.c

393

for (i = 0; i != howmany(UKBD_NKEYCODE, 64); i++)

sys/dev/usb/input/ukbd.c

404

for (i = 0; i != howmany(UKBD_NKEYCODE, 64); i++)

sys/dev/usb/input/wmt.c

221

uint8_t caps[howmany(WMT_N_USAGES, 8)];

sys/dev/usb/input/wmt.c

222

uint8_t buttons[howmany(WMT_BTN_MAX, 8)];

sys/dev/usb/usb_transfer.c

274

n_dma_pc = howmany(count, n_obj);

sys/dev/usb/wlan/if_rsureg.h

197

#define R92S_CAM_ENTRY_BYTES howmany(R92S_CAM_ENTRY_LIMIT, NBBY)

sys/dev/usb/wlan/if_rum.c

1388

plcp_length = howmany(16 * len, rate);

sys/dev/usb/wlan/if_ural.c

1002

plcp_length = howmany(16 * len, rate);

sys/dev/virtio/network/if_vtnet.c

2091

howmany(m->m_pkthdr.len, hdr->gso_size);

sys/dev/virtio/network/if_vtnet.c

3336

sc->vtnet_rx_nmbufs = howmany(sizeof(struct vtnet_rx_header) +

sys/dev/vmm/vmm_dev.c

736

if (error == 0 && size < howmany(CPU_FLS(cpuset), NBBY))

sys/dev/vmware/vmci/vmci_kernel_defs.h

28

#define CEILING(x, y) howmany(x, y)

sys/dev/vt/hw/vga/vt_vga.c

832

x2 = (int)howmany(col * vf->vf_width + vw->vw_draw_area.tr_begin.tp_col,

sys/dev/vt/vt_core.c

675

howmany(rect->tr_begin.tp_row, vf->vf_height);

sys/dev/vt/vt_font.c

110

stride = howmany(vf->vf_width, 8) * vf->vf_height;

sys/dev/vt/vt_font.c

181

glyphsize = howmany(f->width, 8) * f->height * f->glyph_count;

sys/dev/xen/grant_table/grant_table.c

553

extra = howmany(req_entries, GREFS_PER_GRANT_FRAME);

sys/dev/xen/netback/netback.c

1920

pkt->list_len = howmany(pkt->size, PAGE_SIZE);

sys/fs/ext2fs/ext2_alloc.c

1068

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

sys/fs/ext2fs/ext2_alloc.c

1271

used_blks = howmany(fs->e2fs_ipg -

sys/fs/ext2fs/ext2_alloc.c

1373

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

sys/fs/ext2fs/ext2_alloc.c

1532

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

sys/fs/ext2fs/ext2_balloc.c

66

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

sys/fs/ext2fs/ext2_bmap.c

351

for (bn = *offp / bsize, numblks = howmany(ip->i_size, bsize);

sys/fs/ext2fs/ext2_vfsops.c

1274

used_blocks = howmany(ip->i_size, fs->e2fs_bsize);

sys/fs/ext2fs/ext2_vfsops.c

618

fs->e2fs_gcount = howmany(fs->e2fs_bcount -

sys/fs/ext2fs/ext2_vfsops.c

638

e2fs_gdbcount_alloc = howmany(fs->e2fs_gcount, e2fs_descpb);

sys/fs/ext2fs/ext2_vfsops.c

641

e2fs_gdbcount_alloc = howmany(fs->e2fs_gcount,

sys/fs/ext2fs/ext2_vfsops.c

644

fs->e2fs_gdbcount = howmany(fs->e2fs_gcount, e2fs_descpb);

sys/fs/fuse/fuse_node.c

464

end_lbn = howmany(newsize, iosize);

sys/fs/fuse/fuse_vnops.c

339

end_lbn = howmany(end, iosize);

sys/fs/msdosfs/msdosfs_conv.c

638

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

sys/fs/msdosfs/msdosfs_conv.c

753

return howmany(WIN_MAXLEN - wlen/2, WIN_CHARS);

sys/fs/msdosfs/msdosfs_conv.c

758

return howmany(unlen, WIN_CHARS);

sys/fs/msdosfs/msdosfs_vfsops.c

1061

sbp->f_files = howmany(pmp->pm_rootdirsize * DEV_BSIZE,

sys/fs/msdosfs/msdosfs_vfsops.c

438

dirleft = howmany(pmp->pm_rootdirsize * DEV_BSIZE,

sys/fs/msdosfs/msdosfs_vfsops.c

690

pmp->pm_rootdirsize = howmany(pmp->pm_RootDirEnts *

sys/fs/msdosfs/msdosfs_vfsops.c

806

pmp->pm_inusemap = malloc(howmany(pmp->pm_maxcluster + 1,

sys/fs/nfsserver/nfs_nfsdport.c

385

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

sys/fs/tarfs/tarfs_vnops.c

161

0 : howmany(bs - (off + iosize), iosize);

sys/fs/tarfs/tarfs_vnops.c

162

rb = howmany(off - (i == 0 ?

sys/fs/tarfs/tarfs_vnops.c

169

0 : howmany(be - (off + iosize), iosize);

sys/fs/tarfs/tarfs_vnops.c

170

rb = howmany(off - bs, iosize);

sys/fs/tmpfs/tmpfs_subr.c

474

meta_pages = howmany((uintmax_t)tmp->tm_nodes_inuse * node_size,

sys/fs/tmpfs/tmpfs_vfsops.c

324

const size_t nodes_per_page = howmany(PAGE_SIZE,

sys/fs/tmpfs/tmpfs_vfsops.c

428

pages = howmany(size_max, PAGE_SIZE);

sys/fs/tmpfs/tmpfs_vnops.c

1473

maxcookies = howmany(node->tn_size,

sys/fs/tmpfs/tmpfs_vnops.c

1902

!tmpfs_pages_check_avail(tmp, howmany(size, PAGE_SIZE))) {

sys/geom/geom_disk.c

423

howmany(bp->bio_ma_offset + bp->bio_length, PAGE_SIZE);

sys/geom/part/g_part_gpt.c

1226

tblsz = howmany(table->hdr->hdr_entries * table->hdr->hdr_entsz,

sys/geom/part/g_part_gpt.c

1332

tblsz = howmany(basetable->gpt_entries * sizeof(struct gpt_ent),

sys/geom/part/g_part_gpt.c

519

howmany((uint64_t)hdr->hdr_entries * hdr->hdr_entsz,

sys/geom/part/g_part_gpt.c

566

sectors = howmany(tblsz, pp->sectorsize);

sys/geom/part/g_part_gpt.c

704

tblsz = howmany(basetable->gpt_entries * sizeof(struct gpt_ent),

sys/geom/part/g_part_ldm.c

1018

size = howmany(db->dh.last_seq * db->dh.size, pp->sectorsize);

sys/geom/raid/md_ddf.c

598

howmany(GET32(sample, hdr->WorkSpace_Length) *

sys/geom/raid/md_ddf.c

601

howmany(GET16(sample,

sys/geom/raid/md_ddf.c

605

howmany(GET32(sample, hdr->cd_length) *

sys/geom/raid/md_ddf.c

608

howmany(GET32(sample, hdr->pdr_length) *

sys/geom/raid/md_ddf.c

611

howmany(GET32(sample, hdr->vdr_length) *

sys/geom/raid/md_ddf.c

614

howmany(GET32(sample, hdr->cr_length) *

sys/geom/raid/md_ddf.c

617

howmany(GET32(sample, hdr->pdd_length) *

sys/geom/raid/md_ddf.c

620

howmany(GET32(sample, hdr->bbmlog_length) *

sys/geom/raid/md_ddf.c

623

howmany(GET32(sample, hdr->bbmlog_length) *

sys/geom/raid/md_ddf.c

626

howmany(GET32(sample, hdr->bbmlog_length) *

sys/geom/raid/md_ddf.c

641

howmany(sizeof(struct ddf_vdc_record) + (4 + 8) *

sys/geom/raid/md_ddf.c

644

howmany(sizeof(struct ddf_cd_record), ss));

sys/geom/raid/md_ddf.c

646

howmany(sizeof(struct ddf_pd_record) +

sys/geom/raid/md_ddf.c

650

howmany(sizeof(struct ddf_vd_record) +

sys/geom/raid/md_ddf.c

657

howmany(sizeof(struct ddf_pdd_record), ss));

sys/geom/raid/md_intel.c

777

sectors = howmany(meta->config_size, pp->sectorsize);

sys/geom/uzip/g_uzip.c

241

end_blk = howmany(ofs + bp->bio_resid, sc->blksz);

sys/i386/i386/copyout.c

100

plen = howmany(uva - trunc_page(uva) + len, PAGE_SIZE);

sys/kern/kern_cpuset.c

2066

if (cpusetsize < howmany(CPU_FLS(mask), NBBY))

sys/kern/kern_descrip.c

5341

#define XPTRWIDTH ((int)howmany(sizeof(void *) * NBBY, 4))

sys/kern/kern_fail.c

430

timo = howmany((int64_t)msecs * hz, 1000L);

sys/kern/kern_malloc.c

1581

howmany(size, 1024), allocs);

sys/kern/kern_mbuf.c

1730

npgs = howmany(len, PAGE_SIZE);

sys/kern/kern_sendfile.c

864

npages = howmany(space + (off & PAGE_MASK), PAGE_SIZE);

sys/kern/kern_sendfile.c

878

rhpages = howmany(rem + (off & PAGE_MASK), PAGE_SIZE) -

sys/kern/kern_sendfile.c

882

rhpages = min(howmany(maxphys, PAGE_SIZE), rhpages);

sys/kern/kern_sendfile.c

883

rhpages = min(howmany(obj_size - trunc_page(off), PAGE_SIZE) -

sys/kern/kern_synch.c

328

sbt = howmany(sbt, SBT_1US);

sys/kern/kern_time.c

1731

overruns = howmany(now - value + 1, interval);

sys/kern/kern_time.c

482

ts->tv_nsec = howmany(NS_PER_SEC, hz);

sys/kern/subr_smp.c

181

cpusetsizemin = howmany(mp_maxid + 1, NBBY);

sys/kern/subr_uio.c

91

#define PHYS_PAGE_COUNT(len) (howmany(len, PAGE_SIZE) + 1)

sys/kern/sys_generic.c

1199

fd_mask s_selbits[howmany(2048, NFDBITS)];

sys/kern/sys_pipe.c

1607

ub->st_blocks = howmany(ub->st_size, ub->st_blksize);

sys/kern/sysv_msg.c

841

segs_needed = howmany(msgsz, msginfo.msgssz);

sys/kern/tty_inq.c

119

ti->ti_quota = howmany(size, TTYINQ_DATASIZE);

sys/kern/tty_outq.c

96

to->to_quota = howmany(size, TTYOUTQ_DATASIZE);

sys/kern/vfs_bio.c

1330

buf_domains = MIN(howmany(maxbufspace, 256*1024*1024), BUF_DOMAINS);

sys/kern/vfs_cluster.c

199

nblks = howmany(totread, size);

sys/kern/vfs_subr.c

2581

startlbn = howmany(length, blksize);

sys/kern/vfs_vnops.c

640

fp->f_seqcount[rw] += howmany(uio->uio_resid, 16384);

sys/net80211/_ieee80211.h

161

#define IEEE80211_CHAN_BYTES howmany(IEEE80211_CHAN_MAX, NBBY)

sys/net80211/_ieee80211.h

76

#define IEEE80211_MODE_BYTES howmany(IEEE80211_MODE_MAX, NBBY)

sys/net80211/ieee80211_node.c

187

howmany(vap->iv_max_aid, 32) * sizeof(uint32_t),

sys/net80211/ieee80211_output.c

2868

*(uint16_t *)frm = htole16(howmany(ic->ic_lintval,

sys/net80211/ieee80211_phy.c

528

numSymbols = howmany(numBits, bitsPerSymbol);

sys/net80211/ieee80211_phy.c

538

numSymbols = howmany(numBits, bitsPerSymbol);

sys/net80211/ieee80211_phy.c

548

numSymbols = howmany(numBits, bitsPerSymbol);

sys/net80211/ieee80211_phy.c

559

numSymbols = howmany(numBits, bitsPerSymbol);

sys/net80211/ieee80211_phy.c

608

numSymbols = howmany(numBits, bitsPerSymbol);

sys/net80211/ieee80211_power.c

86

vap->iv_tim_len = howmany(vap->iv_max_aid,8) * sizeof(uint8_t);

sys/netgraph/ng_pptpgre.c

1082

ticks = howmany(remain * hz, PPTP_TIME_SCALE) + 1;

sys/netgraph/ng_pptpgre.c

1130

ticks = howmany(ackTimeout * hz, PPTP_TIME_SCALE);

sys/netinet/tcp_input.c

4032

snd_cnt = howmany((long)tp->sackhint.prr_delivered *

sys/netinet/tcp_lro.h

70

howmany(12 + 2 * sizeof(struct in6_addr), sizeof(u_long))

sys/netinet/tcp_output.c

2063

if ((frags + howmany(mlen, fragsize)) >= seglimit) {

sys/netinet/tcp_output.c

2070

frags += howmany(mlen, fragsize);

sys/netinet/tcp_stacks/rack.c

18092

if ((frags + howmany(mlen, fragsize)) >= seglimit) {

sys/netinet/tcp_stacks/rack.c

18097

frags += howmany(mlen, fragsize);

sys/netinet6/ip6_mroute.h

89

#ifndef howmany

sys/netinet6/ip6_mroute.h

94

if_mask ifs_bits[howmany(IF_SETSIZE, NIFBITS)];

sys/opencrypto/cryptosoft.c

324

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

sys/opencrypto/cryptosoft.c

402

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

sys/opencrypto/cryptosoft.c

736

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

sys/opencrypto/cryptosoft.c

961

uint64_t blkbuf[howmany(CHACHA20_NATIVE_BLOCK_LEN, sizeof(uint64_t))];

sys/powerpc/aim/mmu_radix.c

3731

pv_npg = howmany(vm_phys_segs[vm_phys_nsegs - 1].end, L3_PAGE_SIZE);

sys/powerpc/booke/pmap_32.c

673

kernel_ptbls = howmany(VM_MAX_KERNEL_ADDRESS - VM_MIN_KERNEL_ADDRESS,

sys/powerpc/booke/pmap_64.c

527

pdir_l1s = howmany(kva_size, PG_ROOT_SIZE);

sys/powerpc/booke/pmap_64.c

528

kernel_pdirs = howmany(kva_size, PDIR_L1_SIZE);

sys/powerpc/booke/pmap_64.c

529

kernel_pgtbls = howmany(kva_size, PDIR_SIZE);

sys/powerpc/booke/pmap_64.c

578

data_end += howmany(kva_size, PG_ROOT_SIZE) * PAGE_SIZE;

sys/powerpc/booke/pmap_64.c

579

data_end += howmany(kva_size, PDIR_L1_SIZE) * PAGE_SIZE;

sys/powerpc/booke/pmap_64.c

580

data_end += howmany(kva_size, PDIR_SIZE) * PAGE_SIZE;

sys/powerpc/include/pmap.h

216

#define _NPCM howmany(_NPCPV, 64)

sys/powerpc/mpc85xx/fsl_espi.c

357

pm = howmany(plat_clk, spi_clk * 2) - 1;

sys/powerpc/powermac/ata_macio.c

75

#define ATA_TIME_TO_TICK(rev,time) howmany(time, (rev == 4) ? 15 : 30)

sys/powerpc/powerpc/clock.c

337

ttb = tb + howmany((uint64_t)n * 1000000, ps_per_tick);

sys/powerpc/powerpc/machdep.c

655

i += howmany(fake_preload[i - 1], sizeof(uint32_t));

sys/riscv/riscv/busdma_bounce.c

434

howmany(dmat->common.maxsize, MIN(dmat->common.maxsegsz, PAGE_SIZE)) &&

sys/riscv/riscv/pmap.c

1050

pv_npg = howmany(vm_phys_segs[vm_phys_nsegs - 1].end, L2_SIZE);

sys/riscv/riscv/pmap.c

814

nkernl2 = howmany(howmany(kernlen, L2_SIZE), Ln_ENTRIES);

sys/riscv/riscv/pmap.c

825

ndevmapl3 = howmany(howmany(PMAP_MAPDEV_EARLY_SIZE, L3_SIZE),

sys/riscv/riscv/pmap.c

983

for (i = 0; i < howmany(DPCPU_SIZE, PAGE_SIZE); i++)

sys/riscv/riscv/pmap.c

997

for (i = 0; i < howmany(msgbufsize, PAGE_SIZE); i++)

sys/riscv/sifive/sifive_spi.c

215

sckdiv = (howmany(sc->freq >> 1, freq) - 1) & SFSPI_SCKDIV_MASK;

sys/sys/_param.h

19

#ifndef howmany

sys/sys/_pv_entry.h

87

#define _NPCM howmany(_NPCPV, __LONG_WIDTH__)

sys/sys/bus_dma.h

253

bus_dma_template_fill(t, pm, howmany(sizeof(pm), sizeof(pm[0]))); \

sys/sys/runq.h

58

#define RQ_NQS (howmany(RQ_MAX_PRIO + 1, RQ_PPQ)) /* Number of run queues. */

sys/sys/runq.h

66

#define RQSW_NB (howmany(RQ_NQS, RQSW_BPW))

sys/ufs/ffs/ffs_alloc.c

2155

len = howmany(fs->fs_ipg - cgp->cg_irotor, NBBY);

sys/ufs/ffs/ffs_alloc.c

2976

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

sys/ufs/ffs/ffs_snapshot.c

1101

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

sys/ufs/ffs/ffs_snapshot.c

1173

last = howmany(remblks, blksperindir);

sys/ufs/ffs/ffs_snapshot.c

1385

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

sys/ufs/ffs/ffs_snapshot.c

1457

last = howmany(remblks, blksperindir);

sys/ufs/ffs/ffs_snapshot.c

1694

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

sys/ufs/ffs/ffs_snapshot.c

2036

lblktosize(fs, howmany(fs->fs_size, fs->fs_frag))) {

sys/ufs/ffs/ffs_snapshot.c

2098

lblktosize(fs, howmany(fs->fs_size, fs->fs_frag));

sys/ufs/ffs/ffs_snapshot.c

315

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

sys/ufs/ffs/ffs_snapshot.c

352

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

sys/ufs/ffs/ffs_snapshot.c

393

len = roundup2(howmany(fs->fs_ncg, NBBY), sizeof(uint64_t));

sys/ufs/ffs/ffs_snapshot.c

495

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

sys/ufs/ffs/ffs_snapshot.c

543

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

sys/ufs/ffs/ffs_snapshot.c

600

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

sys/ufs/ffs/ffs_snapshot.c

695

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

sys/ufs/ffs/ffs_snapshot.c

819

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

sys/ufs/ffs/ffs_snapshot.c

951

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

sys/ufs/ffs/ffs_snapshot.c

952

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

sys/ufs/ffs/ffs_softdep.c

3721

size = howmany(cnt, jrecmin) * devbsize;

sys/ufs/ffs/ffs_softdep.c

6677

numblks = howmany(length, fs->fs_bsize);

sys/ufs/ffs/ffs_softdep.c

6679

totblks = howmany(length, fs->fs_fsize);

sys/ufs/ffs/ffs_softdep.c

6690

totblks += blkstofrags(fs, howmany(numblks, NINDIR(fs)));

sys/ufs/ffs/ffs_softdep.c

6694

numblks = howmany(numblks, NINDIR(fs));

sys/ufs/ffs/ffs_subr.c

198

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

sys/ufs/ffs/ffs_subr.c

582

howmany(fs->fs_sblockloc + SBLOCKSIZE, fs->fs_fsize),

sys/ufs/ffs/ffs_subr.c

603

FCHK(fs->fs_csaddr + howmany(fs->fs_cssize, fs->fs_fsize), >,

sys/ufs/ffs/ffs_subr.c

607

FCHK(dtog(fs, fs->fs_csaddr + howmany(fs->fs_cssize,

sys/ufs/ffs/ffs_subr.c

700

howmany(fs->fs_sblockloc + SBLOCKSIZE, fs->fs_fsize),

sys/ufs/ffs/ffs_subr.c

703

roundup(howmany(SBLOCKSIZE, fs->fs_fsize), fs->fs_frag), %jd);

sys/ufs/ffs/ffs_subr.c

717

howmany(fs->fs_cssize, fs->fs_fsize), %jd);

sys/ufs/ffs/ffs_subr.c

752

FCHK(fs->fs_csaddr + howmany(fs->fs_cssize, fs->fs_fsize), >,

sys/ufs/ffs/ffs_subr.c

755

FCHK(dtog(fs, fs->fs_csaddr + howmany(fs->fs_cssize, fs->fs_fsize)), >,

sys/ufs/ffs/ffs_subr.c

966

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

sys/ufs/ffs/fs.h

578

/* inode map */ howmany((fs)->fs_ipg, NBBY) + \

sys/ufs/ffs/fs.h

579

/* block map */ howmany((fs)->fs_fpg, NBBY) + sizeof(int32_t) + \

sys/ufs/ffs/fs.h

582

/* cluster map */ howmany(fragstoblks(fs, (fs)->fs_fpg), NBBY)))

sys/ufs/ufs/ufs_bmap.c

376

for (bn = *offp / bsize, numblks = howmany(ip->i_size, bsize);

sys/ufs/ufs/ufs_dirhash.c

378

narrays = howmany(nslots, DH_NBLKOFF);

sys/ufs/ufs/ufs_dirhash.c

380

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

sys/ufs/ufs/ufs_dirhash.c

718

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

sys/ufs/ufs/ufs_dirhash.c

725

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

sys/ufs/ufs/ufs_dirhash.c

934

block = howmany(offset, DIRBLKSIZ);

sys/vm/swap_pager.c

2750

blist_free(sp->sw_blist, howmany(BBSIZE, PAGE_SIZE),

sys/vm/swap_pager.c

2751

nblks - howmany(BBSIZE, PAGE_SIZE));

sys/vm/swap_pager.c

2769

swap_pager_avail += nblks - howmany(BBSIZE, PAGE_SIZE);

sys/vm/swap_pager.c

2943

nswapdev * howmany(BBSIZE, PAGE_SIZE);

sys/vm/uma_core.c

1655

howmany(keg->uk_reserve - partial, keg->uk_ipers));

sys/vm/uma_core.c

1883

pages = howmany(bytes, PAGE_SIZE);

sys/vm/uma_core.c

2035

npages = howmany(bytes, PAGE_SIZE);

sys/vm/uma_core.c

4114

stripe = howmany(max, vm_ndomains);

sys/vm/uma_core.c

5195

pages = howmany(count, keg->uk_ipers) * keg->uk_ppera;

sys/vm/uma_core.c

5235

slabs = howmany(items, keg->uk_ipers);

sys/vm/vm_dumpset.h

56

adj += howmany(dump_avail[i + 1], PAGE_SIZE) -

sys/vm/vm_dumpset.h

75

adj += howmany(dump_avail[i + 1], PAGE_SIZE) -

sys/vm/vm_dumpset.h

86

tot = howmany(dump_avail[i + 1], PAGE_SIZE) -

sys/vm/vm_page.c

632

vm_page_dump_pages += howmany(dump_avail[i + 1], PAGE_SIZE) -

sys/vm/vm_pageout.c

1065

if (target == 0 && ndirty * isqrt(howmany(nfreed + 1,

sys/vm/vm_pageout.c

2256

total_pageout_threads = howmany(mp_ncpus, pageout_cpus_per_thread);

sys/vm/vm_pageout.c

2271

return (howmany(total_pageout_threads * domain_cpus, eligible_cpus));

sys/vm/vm_reserv.c

1052

used += howmany(seg->end, VM_LEVEL_0_SIZE) -

sys/vm/vm_reserv.c

1442

count += howmany(vm_phys_segs[i].end, VM_LEVEL_0_SIZE) -

sys/vm/vm_reserv.c

1446

howmany(vm_phys_segs[i].end, VM_LEVEL_0_SIZE));

sys/vm/vm_reserv.c

1452

count += howmany(phys_avail[i + 1], VM_LEVEL_0_SIZE) -

sys/vm/vm_reserv.c

1456

howmany(phys_avail[i + 1], VM_LEVEL_0_SIZE));

sys/x86/isa/atrtc.c

322

UINT32 bytewidth = howmany(bitwidth, 8);

sys/x86/x86/busdma_bounce.c

448

howmany(dmat->common.maxsize, MIN(dmat->common.maxsegsz,

tools/diag/prtblknos/prtblknos.c

115

lastlbn = howmany(size, fs->fs_bsize);

tools/diag/prtblknos/prtblknos.c

121

frags = howmany(size - (lastlbn - 1) * fs->fs_bsize,

tools/diag/prtblknos/prtblknos.c

176

last = howmany(lastlbn - lbn, blksperindir) < NINDIR(fs) ?

tools/diag/prtblknos/prtblknos.c

177

howmany(lastlbn - lbn, blksperindir) : NINDIR(fs);

tools/diag/prtblknos/prtblknos.c

233

seq = howmany(numfrags, fs->fs_frag);

tools/diag/prtblknos/prtblknos.c

239

seq = howmany(numfrags, fs->fs_frag);

tools/diag/prtblknos/prtblknos.c

250

seq += howmany(numfrags, fs->fs_frag);

tools/tools/net80211/wlantxtime/wlantxtime.c

353

numSymbols = howmany(numBits, bitsPerSymbol);

tools/tools/net80211/wlantxtime/wlantxtime.c

363

numSymbols = howmany(numBits, bitsPerSymbol);

tools/tools/net80211/wlantxtime/wlantxtime.c

373

numSymbols = howmany(numBits, bitsPerSymbol);

tools/tools/net80211/wlantxtime/wlantxtime.c

384

numSymbols = howmany(numBits, bitsPerSymbol);

tools/tools/net80211/wlantxtime/wlantxtime.c

419

numSymbols = howmany(numBits, bitsPerSymbol);

tools/tools/vt/mkkfont/mkkfont.c

45

gbytes = howmany(fh->fh_width, 8) * fh->fh_height;

usr.bin/du/du.c

235

cblocksize = howmany(cblocksize, DEV_BSIZE) * DEV_BSIZE;

usr.bin/du/du.c

257

threshold = howmany(threshold / DEV_BSIZE * cblocksize,

usr.bin/du/du.c

325

(intmax_t)howmany(

usr.bin/du/du.c

551

howmany(p->fts_statp->st_size, cblocksize) :

usr.bin/du/du.c

552

howmany(p->fts_statp->st_blocks, cblocksize);

usr.bin/du/du.c

561

howmany(p->fts_number * cblocksize, blocksize));

usr.bin/du/du.c

573

(intmax_t)howmany(p->fts_number * cblocksize, blocksize),

usr.bin/mkimg/gpt.c

143

return (MAX(howmany(GPT_MIN_RESERVED, secsz), howmany(nparts, eps)));

usr.bin/rpcinfo/rpcinfo.c

1658

spaces(int howmany)

usr.bin/rpcinfo/rpcinfo.c

1663

if (howmany <= 0 || howmany > sizeof (space_array)) {

usr.bin/rpcinfo/rpcinfo.c

1666

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

usr.bin/systat/iolat.c

391

regions = howmany(ndrives, DRIVESPERLINE);

usr.bin/systat/iolat.c

480

regions = howmany(ndrives, DRIVESPERLINE);

usr.bin/systat/iostat.c

190

regions = howmany(ndrives, DRIVESPERLINE);

usr.bin/vtfontcvt/vtfontcvt.c

396

wbytes = howmany(width, 8);

usr.bin/vtfontcvt/vtfontcvt.c

487

bbwbytes = howmany(bbw, 8);

usr.bin/vtfontcvt/vtfontcvt.c

581

gwbytes = howmany(gwidth, 8);

usr.sbin/bhyve/pci_virtio_input.c

307

const int count = howmany(INPUT_PROP_CNT, sizeof(long) * 8) *

usr.sbin/bhyve/pci_virtio_input.c

354

count = howmany(count, sizeof(long) * 8) * sizeof(long);

usr.sbin/bhyve/rfb.c

1358

cnt = howmany(RFB_MAX_WIDTH, PIX_PER_CELL) *

usr.sbin/bhyve/rfb.c

1359

howmany(RFB_MAX_HEIGHT, PIX_PER_CELL);

usr.sbin/bhyve/rfb.c

728

howmany(RFB_MAX_WIDTH, PIX_PER_CELL) *

usr.sbin/bhyve/rfb.c

729

howmany(RFB_MAX_HEIGHT, PIX_PER_CELL));

usr.sbin/bhyve/rfb.c

761

xcells = howmany(rc->crc_width, PIX_PER_CELL);

usr.sbin/bhyve/rfb.c

762

ycells = howmany(rc->crc_height, PIX_PER_CELL);

usr.sbin/binmiscctl/binmiscctl.c

514

for(i = 0; i < howmany(xbe_out_sz, sizeof(xbe_out)); i++)

usr.sbin/btxld/btxld.c

238

cwr = howmany(ihdr.text, BTX_PGSIZE);

usr.sbin/makefs/cd9660.h

93

howmany((__bytes), (__sector_size))

usr.sbin/makefs/cd9660/cd9660_eltorito.c

160

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

usr.sbin/makefs/cd9660/cd9660_eltorito.c

161

howmany(diskStructure->sectorSize, 512);

usr.sbin/makefs/cd9660/cd9660_eltorito.c

416

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

usr.sbin/makefs/ffs.c

601

blocks = howmany(file_len, ffs_opts->bsize);

usr.sbin/makefs/ffs.c

607

overhead = howmany(file_len -

usr.sbin/makefs/ffs.c

635

blocks = howmany(file_len - UFS_NDADDR * (size_t)ffs_opts->bsize,

usr.sbin/makefs/ffs.c

643

blocks = howmany(blocks, fs_nindir) - 1;

usr.sbin/makefs/ffs/ffs_alloc.c

543

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

usr.sbin/makefs/ffs/mkfs.c

307

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

usr.sbin/makefs/ffs/mkfs.c

310

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

usr.sbin/makefs/ffs/mkfs.c

356

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

usr.sbin/makefs/ffs/mkfs.c

362

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

usr.sbin/makefs/ffs/mkfs.c

380

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

usr.sbin/makefs/ffs/mkfs.c

391

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

usr.sbin/makefs/ffs/mkfs.c

403

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

usr.sbin/makefs/ffs/mkfs.c

415

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

usr.sbin/makefs/ffs/mkfs.c

478

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

usr.sbin/makefs/ffs/mkfs.c

483

howmany(csfrags, sblock.fs_frag);

usr.sbin/makefs/ffs/mkfs.c

608

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

usr.sbin/makefs/ffs/mkfs.c

652

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

usr.sbin/makefs/ffs/mkfs.c

667

acg.cg_old_ncyl = howmany(acg.cg_ndblk,

usr.sbin/makefs/ffs/mkfs.c

682

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

usr.sbin/makefs/ffs/mkfs.c

685

howmany(sblock.fs_fpg, CHAR_BIT);

usr.sbin/makefs/ffs/mkfs.c

688

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

usr.sbin/makefs/ffs/mkfs.c

694

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

usr.sbin/makefs/msdos/msdosfs_conv.c

153

return howmany(unlen, WIN_CHARS);

usr.sbin/makefs/zfs.c

668

ndatablks = size == 0 ? 0 : howmany(size, blksz);

usr.sbin/makefs/zfs.c

672

nindblks += howmany(ndatablks, indlevel * nbppindir);

usr.sbin/makefs/zfs/zap.c

439

nnamechunks = howmany(namelen, ZAP_LEAF_ARRAY_BYTES);

usr.sbin/makefs/zfs/zap.c

440

nvalchunks = howmany(ent->intcnt,

usr.sbin/makefs/zfs/zap.c

74

return (1 + howmany(strlen(ent->name) + 1, ZAP_LEAF_ARRAY_BYTES) +

usr.sbin/makefs/zfs/zap.c

75

howmany(ent->intsz * ent->intcnt, ZAP_LEAF_ARRAY_BYTES));

usr.sbin/pmcstat/pmcpl_gprof.c

473

pgf->pgf_nbuckets = howmany(image->pi_end - image->pi_start,

usr.sbin/ppp/defs.c

387

return (fd_set *)malloc(howmany(getdtablesize(), NFDBITS) * sizeof (fd_mask));

usr.sbin/ppp/defs.c

393

memset(s, '\0', howmany(getdtablesize(), NFDBITS) * sizeof (fd_mask));

usr.sbin/route6d/route6d.c

730

fdmasks = howmany(maxfd + 1, NFDBITS) * sizeof(fd_mask);

usr.sbin/traceroute/traceroute.c

1224

nfds = howmany(sock + 1, NFDBITS);

usr.sbin/traceroute6/traceroute6.c

1072

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

usr.sbin/vidcontrol/vidcontrol.c

438

glyphsize = howmany(vfnt.width, 8) * vfnt.height * vfnt.glyph_count;