bin/df/ext2fs_df.c

80

ncg = howmany(sblock.e2fs_bcount - sblock.e2fs_first_dblock,

bin/df/ext2fs_df.c

82

ngdb = howmany(ncg, sfsp->f_bsize / sizeof(struct ext2_gd));

bin/ls/print.c

103

howmany((long long)sp->st_blocks, blocksize));

bin/ls/print.c

201

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

bin/ls/print.c

233

howmany((long long)sp->st_blocks, blocksize));

bin/ls/print.c

281

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

bin/ls/print.c

92

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

lib/libc/rpc/svc.c

174

bytes = howmany(sock + 128, NFDBITS) * sizeof(fd_mask);

lib/libc/rpc/svc.c

179

howmany(__svc_fdsetsize, NFDBITS) * sizeof(fd_mask));

lib/libc/stdio/vfprintf.c

374

#define PAD(howmany, with) do { \

lib/libc/stdio/vfprintf.c

375

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

lib/libc/stdio/vfwprintf.c

357

#define PAD(howmany, with) do { \

lib/libc/stdio/vfwprintf.c

358

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

lib/libc/stdlib/malloc.c

1006

size = howmany(count, MALLOC_BITS);

lib/libc/stdlib/malloc.c

1132

return howmany(size, MALLOC_MINSIZE);

lib/libc/stdlib/malloc.c

985

p->offset = howmany(p->total, MALLOC_BITS);

lib/libcurses/tty/lib_twait.c

324

int n, howmany;

lib/libcurses/tty/lib_twait.c

331

howmany = ioctl(0, 'ichr', &n);

lib/libcurses/tty/lib_twait.c

332

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

lib/libcurses/tty/tty_update.c

401

int howmany = ioctl(0, 'ichr', &n);

lib/libcurses/tty/tty_update.c

402

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

lib/libevent/select.c

265

(howmany(ev->ev_fd + 1, NFDBITS) * sizeof(fd_mask)))

lib/libevent/select.c

91

select_resize(sop, howmany(32 + 1, NFDBITS)*sizeof(fd_mask));

libexec/ld.so/malloc.c

512

p->offset = howmany(p->total, MALLOC_BITS);

libexec/ld.so/malloc.c

536

size = howmany(count, MALLOC_BITS);

regress/sys/fifofs/fifotest.c

331

rfds = calloc(howmany(maxfd + 1, NFDBITS), sizeof(fd_mask));

regress/sys/fifofs/fifotest.c

339

wfds = calloc(howmany(maxfd + 1, NFDBITS), sizeof(fd_mask));

regress/sys/kern/fork-exit/fork-exit.c

335

fdlen = howmany(fdmax + 1, NFDBITS);

sbin/dump/main.c

464

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

sbin/dump/main.c

471

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

sbin/dump/main.c

526

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

sbin/dump/traverse.c

105

howmany(sizeest - NDADDR * sblock->fs_bsize / TP_BSIZE,

sbin/dump/traverse.c

563

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

sbin/dump/traverse.c

592

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

sbin/dump/traverse.c

624

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

sbin/dump/traverse.c

659

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

sbin/dump/traverse.c

695

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

sbin/dump/traverse.c

98

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

sbin/dump/traverse.c

99

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

sbin/dumpfs/dumpfs.c

319

howmany(afs.fs_ffs1_size % afs.fs_fpg,

sbin/fsck_ext2fs/inode.c

133

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

sbin/fsck_ext2fs/inode.c

226

nif = howmany(isize, sizepb);

sbin/fsck_ext2fs/inode.c

436

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

sbin/fsck_ext2fs/pass1.c

196

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

sbin/fsck_ext2fs/pass1.c

212

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

sbin/fsck_ext2fs/setup.c

225

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

sbin/fsck_ext2fs/setup.c

302

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

sbin/fsck_ext2fs/setup.c

310

sblock.e2fs_ngdb = howmany(sblock.e2fs_ncg,

sbin/fsck_ext2fs/setup.c

490

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

sbin/fsck_ext2fs/setup.c

493

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

sbin/fsck_ffs/inode.c

172

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

sbin/fsck_ffs/inode.c

175

nif = howmany(isize, sizepb);

sbin/fsck_ffs/inode.c

400

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

sbin/fsck_ffs/inode.c

80

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

sbin/fsck_ffs/main.c

313

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

sbin/fsck_ffs/pass1.c

228

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

sbin/fsck_ffs/pass1.c

245

ndb = howmany(DIP(dp, di_size),

sbin/fsck_ffs/pass1.c

248

ndb = howmany(DIP(dp, di_size),

sbin/fsck_ffs/pass1.c

88

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

sbin/fsck_ffs/pass5.c

127

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

sbin/fsck_ffs/pass5.c

129

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

sbin/fsck_ffs/pass5.c

146

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

sbin/fsck_ffs/pass5.c

148

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

sbin/fsck_ffs/pass5.c

158

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

sbin/fsck_ffs/setup.c

424

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

sbin/fsck_ffs/setup.c

650

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

sbin/fsck_ffs/setup.c

652

howmany(sblockloc + SBSIZE, fs->fs_fsize),

sbin/growfs/growfs.c

1107

howmany(sblock.fs_cssize, sblock.fs_fsize);

sbin/growfs/growfs.c

1109

howmany(osblock.fs_cssize, osblock.fs_fsize);

sbin/growfs/growfs.c

1448

csmax = csmin + howmany(sblock.fs_cssize, sblock.fs_fsize);

sbin/growfs/growfs.c

1901

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

sbin/growfs/growfs.c

2074

numblks = howmany(DIP(ino, di_size), sblock.fs_bsize);

sbin/growfs/growfs.c

2131

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

sbin/growfs/growfs.c

2132

howmany(lastlbn - lbn, blksperindir) : NINDIR(&sblock);

sbin/growfs/growfs.c

353

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

sbin/growfs/growfs.c

383

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

sbin/growfs/growfs.c

384

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

sbin/growfs/growfs.c

392

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

sbin/growfs/growfs.c

666

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

sbin/growfs/growfs.c

854

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

sbin/growfs/growfs.c

855

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

sbin/growfs/growfs.c

863

blocks = 1+howmany(sblock.fs_cssize, sblock.fs_bsize)-

sbin/growfs/growfs.c

864

howmany(osblock.fs_cssize, osblock.fs_bsize);

sbin/growfs/growfs.c

924

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

sbin/isakmpd/isakmpd.c

440

mask_size = howmany(n, NFDBITS) * sizeof(fd_mask);

sbin/newfs/mkfs.c

1200

allocate += roundup(howmany(maxfsblock, NBBY), sizeof(int16_t));

sbin/newfs/mkfs.c

300

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

sbin/newfs/mkfs.c

303

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

sbin/newfs/mkfs.c

345

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

sbin/newfs/mkfs.c

352

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

sbin/newfs/mkfs.c

383

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_ncg = howmany(sblock.fs_size, sblock.fs_fpg);

sbin/newfs/mkfs.c

417

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

sbin/newfs/mkfs.c

467

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

sbin/newfs/mkfs.c

472

howmany(csfrags, sblock.fs_frag);

sbin/newfs/mkfs.c

645

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

sbin/newfs/mkfs.c

675

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

sbin/newfs/mkfs.c

676

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

sbin/newfs/mkfs.c

955

frag = howmany(size, sblock.fs_fsize);

sbin/newfs_ext2fs/mke2fs.c

289

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

sbin/newfs_ext2fs/mke2fs.c

290

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

sbin/newfs_ext2fs/mke2fs.c

299

iblocks_per_cg = howmany(inodesize * inodes_per_cg, bsize);

sbin/newfs_ext2fs/mke2fs.c

324

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

sbin/newfs_ext2fs/mke2fs.c

435

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

sbin/newfs_ext2fs/mke2fs.c

436

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

sbin/newfs_msdos/newfs_msdos.c

450

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

sbin/newfs_msdos/newfs_msdos.c

453

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

sbin/newfs_msdos/newfs_msdos.c

456

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

sbin/newfs_msdos/newfs_msdos.c

460

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

sbin/newfs_msdos/newfs_msdos.c

461

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

sbin/newfs_msdos/newfs_msdos.c

463

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

sbin/newfs_msdos/newfs_msdos.c

492

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

sbin/newfs_msdos/newfs_msdos.c

494

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

sbin/newfs_msdos/newfs_msdos.c

497

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

sbin/newfs_msdos/newfs_msdos.c

511

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

sbin/restore/tape.c

258

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

sbin/restore/tape.c

266

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

sys/arch/alpha/alpha/pmap.c

746

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

sys/arch/alpha/alpha/pmap.c

762

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

sys/arch/alpha/alpha/pmap.c

781

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

sys/arch/alpha/stand/installboot.c

390

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

sys/arch/alpha/stand/installboot.c

394

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

sys/arch/amd64/amd64/pmap.c

3277

u_int8_t mask[howmany(MAXCPUS, 8)] = { 0 };

sys/arch/amd64/amd64/pmap.c

3327

u_int8_t mask[howmany(MAXCPUS, 8)] = { 0 };

sys/arch/amd64/amd64/pmap.c

3386

u_int8_t mask[howmany(MAXCPUS, 8)] = { 0 };

sys/arch/amd64/amd64/pmap.c

3436

u_int8_t mask[howmany(MAXCPUS, 8)] = { 0 };

sys/arch/arm/arm/cpu.c

847

level = howmany(100 * (level_hz - min), (max - min));

sys/arch/arm64/arm64/cpu.c

2341

level = howmany(100 * (level_hz - min), (max - min));

sys/arch/arm64/arm64/pmap.c

1986

npages = howmany(npteds, PAGE_SIZE / (sizeof(struct pte_desc)));

sys/arch/arm64/arm64/pmap.c

1987

npages += 2 * howmany(npteds, VP_IDX3_CNT);

sys/arch/arm64/arm64/pmap.c

1988

npages += 2 * howmany(npteds, VP_IDX3_CNT * VP_IDX2_CNT);

sys/arch/arm64/arm64/pmap.c

1989

npages += 2 * howmany(npteds, VP_IDX3_CNT * VP_IDX2_CNT * VP_IDX1_CNT);

sys/arch/arm64/dev/apldart.c

465

ntte = howmany((sc->sc_dvaend & sc->sc_dvamask), DART_PAGE_SIZE);

sys/arch/arm64/dev/apldart.c

466

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

sys/arch/arm64/dev/apldart.c

467

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

sys/arch/arm64/dev/apldart.c

561

ntte = howmany((sc->sc_dvaend & sc->sc_dvamask), DART_PAGE_SIZE);

sys/arch/arm64/dev/apldart.c

562

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

sys/arch/arm64/dev/apldart.c

563

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

sys/arch/arm64/dev/apldart.c

649

ntte = howmany((sc->sc_dvaend & sc->sc_dvamask), DART_PAGE_SIZE);

sys/arch/arm64/dev/apldart.c

650

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

sys/arch/arm64/dev/apldart.c

651

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

sys/arch/macppc/dev/wdc_obio.c

307

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

sys/arch/macppc/dev/wdc_obio.c

315

#define ATA4_TIME_TO_TICK(time) howmany((time) * 1000, 7500)

sys/arch/octeon/dev/octcf.c

366

nsecs = howmany(bp->b_bcount, lp->d_secsize);

sys/arch/powerpc64/dev/phb.c

454

nentries = howmany(PHB_DMA_OFFSET + physmax, tce_page_size);

sys/arch/riscv64/riscv64/cpu.c

801

level = howmany(100 * (level_hz - min), (max - min));

sys/arch/riscv64/riscv64/pmap.c

1803

npages = howmany(npteds, PAGE_SIZE / (sizeof(struct pte_desc)));

sys/arch/riscv64/riscv64/pmap.c

1804

npages += 2 * howmany(npteds, VP_IDX3_CNT);

sys/arch/riscv64/riscv64/pmap.c

1805

npages += 2 * howmany(npteds, VP_IDX3_CNT * VP_IDX2_CNT);

sys/arch/riscv64/riscv64/pmap.c

1806

npages += 2 * howmany(npteds, VP_IDX3_CNT * VP_IDX2_CNT * VP_IDX1_CNT);

sys/arch/sparc64/dev/fd.c

707

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

sys/crypto/cryptosoft.c

482

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

sys/dev/ata/wd.c

477

nsecs = howmany(bp->b_bcount, lp->d_secsize);

sys/dev/dt/dt_dev.c

256

max = howmany(uio->uio_resid, sizeof(struct dt_evt));

sys/dev/ic/ar5xxx.h

204

howmany(AR5K_OFDM_NUM_BITS(_frmlen), AR5K_OFDM_NUM_BITS_PER_SYM(_kbps))

sys/dev/ic/ar5xxx.h

218

howmany(AR5K_TURBO_NUM_BITS(_frmlen), \

sys/dev/ic/ar5xxx.h

232

howmany(AR5K_XR_NUM_BITS(_frmlen), AR5K_XR_NUM_BITS_PER_SYM(_kbps))

sys/dev/ic/bwi.c

2719

rf_atten_adj = -howmany(txpwr_diff, 8);

sys/dev/ic/bwi.c

6994

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

sys/dev/ic/bwi.c

6996

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

sys/dev/ic/bwi.c

8638

len = howmany(pkt_bitlen * 2, rate);

sys/dev/ic/bwi.c

8773

howmany(IEEE80211_OFDM_NBITS((frmlen)), \

sys/dev/ic/bwi.c

9185

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

sys/dev/ic/cac.c

373

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

sys/dev/ic/nvme.c

1824

for (i = 1; i < howmany(size, my->sc->sc_mps); i++) {

sys/dev/ic/qwx.c

10028

num_scatter_buf = howmany(size, HAL_WBM_IDLE_SCATTER_BUF_SIZE);

sys/dev/ic/qwx.c

14282

credits = howmany(m->m_pkthdr.len, htc->target_credit_size);

sys/dev/ic/qwxvar.h

1222

uint8_t svc_map[howmany(WMI_MAX_EXT2_SERVICE, 8)];

sys/dev/ic/qwxvar.h

1439

uint8_t freemap[howmany(DP_RXDMA_BUF_RING_SIZE, 8)];

sys/dev/ic/qwz.c

11954

credits = howmany(m->m_pkthdr.len, htc->target_credit_size);

sys/dev/ic/qwz.c

7366

num_scatter_buf = howmany(size, HAL_WBM_IDLE_SCATTER_BUF_SIZE);

sys/dev/ic/qwzvar.h

1224

uint8_t freemap[howmany(DP_RXDMA_BUF_RING_SIZE, 8)];

sys/dev/ic/qwzvar.h

1381

uint8_t svc_map[howmany(WMI_MAX_EXT2_SERVICE, 8)];

sys/dev/isa/fd.c

404

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

sys/dev/ofw/ofw_regulator.c

268

delay(howmany(delta, rd->rd_ramp_delay));

sys/dev/ofw/ofw_regulator.c

347

delay(howmany(delta, rd->rd_ramp_delay));

sys/dev/pci/auvia.c

805

segs = howmany(l, blksize);

sys/dev/pci/drm/include/linux/bitops.h

37

#define BITS_TO_LONGS(x) howmany((x), 8 * sizeof(long))

sys/dev/pci/drm/include/linux/radix-tree.h

41

howmany(sizeof(long) * NBBY, RADIX_TREE_MAP_SHIFT)

sys/dev/pci/if_aq_pci.c

3623

if_rxr_init(&aq->q_rx.rx_rxr, howmany(ifp->if_hardmtu, MCLBYTES),

sys/dev/pci/if_ice.c

22161

num = howmany(num, hw->max_children[i]);

sys/dev/pci/if_ice.c

24988

cnt = howmany(flds[fld].xtrct.disp + ice_flds_info[fld].size, ese_bits);

sys/dev/pci/if_icereg.h

10452

uint8_t vsi_list[howmany(ICE_MAX_VSI, 8)];

sys/dev/pci/if_igc.c

2229

2 * howmany(ifp->if_hardmtu, sc->rx_mbuf_sz) + 1,

sys/dev/pci/if_iwm.c

868

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

sys/dev/pci/if_iwm.c

889

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

sys/dev/pci/if_iwmvar.h

555

uint8_t sc_ucode_api[howmany(IWM_NUM_UCODE_TLV_API, NBBY)];

sys/dev/pci/if_iwmvar.h

556

uint8_t sc_enabled_capa[howmany(IWM_NUM_UCODE_TLV_CAPA, NBBY)];

sys/dev/pci/if_iwx.c

1374

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

sys/dev/pci/if_iwx.c

1395

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

sys/dev/pci/if_iwx.c

6196

num_fetch_chunks = howmany(filled_tfd_size, 64) - 1;

sys/dev/pci/if_iwx.c

6206

len = howmany(len, 4);

sys/dev/pci/if_iwxvar.h

742

uint8_t sc_ucode_api[howmany(IWX_NUM_UCODE_TLV_API, NBBY)];

sys/dev/pci/if_iwxvar.h

743

uint8_t sc_enabled_capa[howmany(IWX_NUM_UCODE_TLV_CAPA, NBBY)];

sys/dev/pci/if_jme.c

1737

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

sys/dev/pci/if_mcx.c

3632

nmb = howmany(len, MCX_CMDQ_MAILBOX_DATASIZE);

sys/dev/pci/if_mcx.c

3878

nmb = howmany(paslen, MCX_CMDQ_MAILBOX_DATASIZE);

sys/dev/pci/if_mcx.c

4363

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

sys/dev/pci/if_mcx.c

4388

howmany(insize, MCX_CMDQ_MAILBOX_DATASIZE),

sys/dev/pci/if_mcx.c

4404

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

sys/dev/pci/if_mcx.c

4658

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

sys/dev/pci/if_mcx.c

4683

howmany(insize, MCX_CMDQ_MAILBOX_DATASIZE),

sys/dev/pci/if_mcx.c

4812

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

sys/dev/pci/if_mcx.c

4833

howmany(insize, MCX_CMDQ_MAILBOX_DATASIZE),

sys/dev/pci/if_mcx.c

5172

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

sys/dev/pci/if_mcx.c

5194

howmany(insize, MCX_CMDQ_MAILBOX_DATASIZE),

sys/dev/pci/if_qwx_pci.c

3327

nseg = howmany(len, chunk_size);

sys/dev/pci/if_qwx_pci.c

3431

nseg = howmany(len, chunk_size);

sys/dev/pci/if_qwz_pci.c

3194

nseg = howmany(len, chunk_size);

sys/dev/pci/if_qwz_pci.c

3295

nseg = howmany(len, chunk_size);

sys/dev/pcmcia/pcmcia_cis.c

341

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

sys/dev/pv/if_vio.c

799

sc->sc_rxr_lwm = 2 * howmany(rxsize, sc->sc_rx_mbuf_size);

sys/dev/softraid.c

3724

bbs = howmany(bb->bb_bootblk_size, secsize) * secsize;

sys/dev/softraid.c

3730

bls = howmany(bb->bb_bootldr_size, secsize) * secsize;

sys/dev/softraid.c

462

blkno += howmany(bufsize, DEV_BSIZE);

sys/dev/usb/xhci.c

2870

npkt = howmany(remain - len, UE_GET_SIZE(mps));

sys/dev/usb/xhci.c

2889

tdpc = howmany(len, UE_GET_SIZE(mps));

sys/dev/usb/xhci.c

2895

tbc = howmany(tdpc, maxb + 1) - 1;

sys/dev/usb/xhci.c

3055

ntrb = howmany(xfer->length, XHCI_TRB_MAXSIZE);

sys/dev/usb/xhci.c

3060

ntrb = howmany(xfer->length - len, XHCI_TRB_MAXSIZE) + 1;

sys/dev/usb/xhci.c

3219

ntrb += howmany(xfer->frlengths[i], XHCI_TRB_MAXSIZE);

sys/dev/usb/xhci.c

3240

ntrb = howmany(xfer->frlengths[i], XHCI_TRB_MAXSIZE);

sys/dev/wscons/wsevent.c

166

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

sys/kern/sys_generic.c

615

ni = howmany(nd, NFDBITS) * sizeof(fd_mask);

sys/kern/vfs_bio.c

1539

bufcache_recover_dmapages(int discard, int64_t howmany)

sys/kern/vfs_bio.c

1548

while ((recovered < howmany) &&

sys/kern/vfs_bio.c

578

int howmany, maxra, i, inc;

sys/kern/vfs_bio.c

599

howmany = MAXPHYS / size;

sys/kern/vfs_bio.c

600

if (howmany > maxra)

sys/kern/vfs_bio.c

601

howmany = maxra;

sys/kern/vfs_bio.c

603

xbpp = mallocarray(howmany + 1, sizeof(*xbpp), M_TEMP, M_NOWAIT);

sys/kern/vfs_bio.c

607

for (i = howmany - 1; i >= 0; i--) {

sys/kern/vfs_bio.c

614

sz = i == 0 ? howmany * size : 0;

sys/kern/vfs_bio.c

618

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

sys/kern/vfs_bio.c

622

free(xbpp, M_TEMP, (howmany + 1) * sizeof(*xbpp));

sys/kern/vfs_bio.c

629

xbpp[howmany] = NULL;

sys/kern/vfs_bio.c

633

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

sys/kern/vfs_bio.c

81

int64_t bufcache_recover_dmapages(int discard, int64_t howmany);

sys/msdosfs/msdosfs_conv.c

692

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

sys/msdosfs/msdosfs_conv.c

810

return howmany(unlen, WIN_CHARS);

sys/msdosfs/msdosfs_fat.c

883

for (cn = 0; cn < howmany(pmp->pm_maxcluster + 1, N_INUSEBITS); cn++)

sys/msdosfs/msdosfs_vfsops.c

479

bmapsiz = howmany(pmp->pm_maxcluster + 1, N_INUSEBITS);

sys/net/hfsc.c

354

hfsc_grow_class_tbl(struct hfsc_if *hif, u_int howmany)

sys/net/hfsc.c

359

newtbl = mallocarray(howmany, sizeof(void *), M_DEVBUF,

sys/net/hfsc.c

365

hif->hif_allocated = howmany;

sys/net/if.c

319

return (max(howmany(limit, NBBY), sizeof(struct if_idxmap_dtor)));

sys/net/if.c

390

memcpy(nusedidx, if_idxmap.usedidx, howmany(olimit, NBBY));

sys/net80211/ieee80211_ioctl.h

349

uint8_t nr_rxmcs[howmany(80,NBBY)];

sys/net80211/ieee80211_node.c

1508

u_char occupied[howmany(IEEE80211_CHAN_MAX, NBBY)];

sys/net80211/ieee80211_node.c

735

size = howmany(ic->ic_max_aid, 32) * sizeof(u_int32_t);

sys/net80211/ieee80211_node.c

743

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

sys/net80211/ieee80211_node.c

804

howmany(ic->ic_max_aid, 32) * sizeof(u_int32_t));

sys/net80211/ieee80211_node.h

346

uint8_t ni_rxmcs[howmany(80,NBBY)];

sys/net80211/ieee80211_node.h

358

uint8_t ni_basic_mcs[howmany(128,NBBY)];

sys/net80211/ieee80211_var.h

280

u_char ic_chan_avail[howmany(IEEE80211_CHAN_MAX,NBBY)];

sys/net80211/ieee80211_var.h

281

u_char ic_chan_active[howmany(IEEE80211_CHAN_MAX, NBBY)];

sys/net80211/ieee80211_var.h

282

u_char ic_chan_scan[howmany(IEEE80211_CHAN_MAX,NBBY)];

sys/net80211/ieee80211_var.h

378

u_int8_t ic_sup_mcs[howmany(80, NBBY)];

sys/netinet/in_pcb.h

265

#define DP_MAPSIZE (howmany(65536, DP_MAPBITS))

sys/netinet/ip_esp.c

972

#define SEEN_SIZE howmany(TDB_REPLAYMAX, 32)

sys/netinet/ip_ipsp.h

429

u_int32_t tdb_seen[howmany(TDB_REPLAYMAX, 32)]; /* Anti-replay window */

sys/netinet/tcp_output.c

193

u_int32_t optbuf[howmany(MAX_TCPOPTLEN, sizeof(u_int32_t))];

sys/netinet6/ip6_mroute.h

69

uint32_t ifs_bits[howmany(256, __NIFBITS)];

sys/nfs/nfs_aiod.c

162

nfs_set_naiod(int howmany)

sys/nfs/nfs_aiod.c

167

KASSERT(howmany >= 0);

sys/nfs/nfs_aiod.c

174

want = howmany - nfs_numaiods;

sys/scsi/cd.c

584

nsecs = howmany(bp->b_bcount, sc->sc_dk.dk_label->d_secsize);

sys/scsi/sd.c

686

nsecs = howmany(bp->b_bcount, sc->sc_dk.dk_label->d_secsize);

sys/sys/param.h

185

#ifndef howmany

sys/sys/select.h

114

#ifndef howmany

sys/ufs/ext2fs/ext2fs_alloc.c

353

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

sys/ufs/ext2fs/ext2fs_alloc.c

417

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

sys/ufs/ext2fs/ext2fs_alloc.c

559

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

sys/ufs/ext2fs/ext2fs_vfsops.c

357

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

sys/ufs/ext2fs/ext2fs_vfsops.c

371

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

sys/ufs/ffs/ffs_alloc.c

1137

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

sys/ufs/ffs/ffs_alloc.c

1430

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

sys/ufs/ffs/ffs_vfsops.c

1370

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

sys/ufs/ffs/ffs_vfsops.c

536

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

sys/ufs/ffs/ffs_vfsops.c

735

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

sys/ufs/ffs/fs.h

360

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

sys/ufs/ffs/fs.h

361

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

sys/ufs/ffs/fs.h

364

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

sys/ufs/ufs/ufs_dirhash.c

139

narrays = howmany(nslots, DH_NBLKOFF);

sys/ufs/ufs/ufs_dirhash.c

141

dirblocks = howmany(DIP(ip, size), DIRBLKSIZ);

sys/ufs/ufs/ufs_dirhash.c

498

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

sys/ufs/ufs/ufs_dirhash.c

507

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

sys/ufs/ufs/ufs_dirhash.c

752

block = howmany(offset, DIRBLKSIZ);

sys/uvm/uvm_amap.c

352

buckets = howmany(chunks, chunkperbucket);

usr.bin/du/du.c

179

prtout(howmany(p->fts_number,

usr.bin/du/du.c

200

prtout(howmany(p->fts_statp->st_blocks,

usr.bin/du/du.c

209

prtout(howmany(totalblocks, blocksize), "total", hflag);

usr.bin/rdist/child.c

357

rchildfdsp = xcalloc(howmany(rchildfdsn+1, NFDBITS), sizeof(fd_mask));

usr.sbin/amd/amd/nfs_start.c

161

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

usr.sbin/amd/amd/nfs_start.c

215

bytes = howmany(fdsn, NFDBITS) * sizeof(fd_mask);

usr.sbin/amd/amd/nfs_start.c

224

bytes = howmany(fdsn, NFDBITS) * sizeof(fd_mask);

usr.sbin/installboot/bootstrap.c

67

bootsec = howmany((ssize_t)sb.st_size, dl.d_secsize);

usr.sbin/installboot/i386_installboot.c

876

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

usr.sbin/installboot/i386_installboot.c

882

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

usr.sbin/installboot/i386_softraid.c

115

nblocks = howmany(SR_BOOT_LOADER_SIZE, SR_FS_BLOCKSIZE / DEV_BSIZE);

usr.sbin/installboot/i386_softraid.c

130

nblocks = howmany(sb.st_blocks, SR_FS_BLOCKSIZE / DEV_BSIZE);

usr.sbin/installboot/landisk_installboot.c

114

bootsec = howmany((ssize_t)sb.st_size, dl.d_secsize);

usr.sbin/installboot/sparc64_installboot.c

62

blocks = howmany((size_t)sb.st_size, DEV_BSIZE);

usr.sbin/makefs/cd9660.h

91

howmany((__bytes), (__sector_size))

usr.sbin/makefs/cd9660/cd9660_eltorito.c

149

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

usr.sbin/makefs/cd9660/cd9660_eltorito.c

150

howmany(diskStructure->sectorSize, 512);

usr.sbin/makefs/cd9660/cd9660_eltorito.c

378

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

usr.sbin/makefs/ffs/ffs_alloc.c

437

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

usr.sbin/makefs/ffs/mkfs.c

274

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

usr.sbin/makefs/ffs/mkfs.c

277

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

usr.sbin/makefs/ffs/mkfs.c

310

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

usr.sbin/makefs/ffs/mkfs.c

316

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

usr.sbin/makefs/ffs/mkfs.c

333

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

usr.sbin/makefs/ffs/mkfs.c

342

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

usr.sbin/makefs/ffs/mkfs.c

354

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

usr.sbin/makefs/ffs/mkfs.c

366

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

usr.sbin/makefs/ffs/mkfs.c

428

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

usr.sbin/makefs/ffs/mkfs.c

433

howmany(csfrags, sblock.fs_frag);

usr.sbin/makefs/ffs/mkfs.c

544

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

usr.sbin/makefs/ffs/mkfs.c

582

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

usr.sbin/makefs/ffs/mkfs.c

598

acg.cg_ncyl = howmany(acg.cg_ndblk,

usr.sbin/makefs/ffs/mkfs.c

612

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

usr.sbin/makefs/ffs/mkfs.c

615

howmany(sblock.fs_fpg, CHAR_BIT);

usr.sbin/makefs/ffs/mkfs.c

618

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

usr.sbin/makefs/ffs/mkfs.c

624

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

usr.sbin/makefs/msdos/mkfs_msdos.c

323

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

usr.sbin/makefs/msdos/mkfs_msdos.c

453

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

usr.sbin/makefs/msdos/mkfs_msdos.c

456

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

usr.sbin/makefs/msdos/mkfs_msdos.c

459

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

usr.sbin/makefs/msdos/mkfs_msdos.c

463

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

usr.sbin/makefs/msdos/mkfs_msdos.c

464

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

usr.sbin/makefs/msdos/mkfs_msdos.c

466

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

usr.sbin/makefs/msdos/mkfs_msdos.c

503

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

usr.sbin/makefs/msdos/mkfs_msdos.c

505

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

usr.sbin/makefs/msdos/mkfs_msdos.c

508

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

usr.sbin/makefs/msdos/mkfs_msdos.c

526

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

usr.sbin/makefs/msdos/msdosfs_conv.c

546

return howmany(unlen, WIN_CHARS);

usr.sbin/pppd/sys-bsd.c

594

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

usr.sbin/pppd/sys-bsd.c

622

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

usr.sbin/quot/quot.c

144

sz = howmany(sz - NDADDR, NINDIR(super));

usr.sbin/quot/quot.c

148

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

usr.sbin/quot/quot.c

61

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

usr.sbin/sasyncd/sasyncd.c

65

fdsetsize = howmany(n, NFDBITS) * sizeof(fd_mask);