crypto/openssh/scp.c

2227

allocbuf(BUF *bp, int fd, int blksize)

crypto/openssh/scp.c

2237

size = ROUNDUP(stb.st_blksize, blksize);

crypto/openssh/scp.c

2239

size = blksize;

crypto/openssh/scp.c

2241

size = blksize;

lib/libdmsg/crypto.c

352

size_t blksize;

lib/libdmsg/crypto.c

457

blksize = (size_t)RSA_size(keys[0]);

lib/libdmsg/crypto.c

458

if (blksize != (size_t)RSA_size(keys[1]) ||

lib/libdmsg/crypto.c

459

blksize != (size_t)RSA_size(keys[2]) ||

lib/libdmsg/crypto.c

460

sizeof(handtx) % blksize != 0) {

lib/libdmsg/crypto.c

468

blksize = sizeof(handtx);

lib/libdmsg/crypto.c

470

blkmask = blksize - 1;

lib/libdmsg/crypto.c

523

for (i = 0; i < sizeof(handtx); i += blksize) {

lib/libdmsg/crypto.c

537

if (RSA_private_encrypt(blksize,

lib/libdmsg/crypto.c

546

if (RSA_public_encrypt(blksize,

lib/libdmsg/crypto.c

554

if (write(iocom->sock_fd, buf2, blksize) != (ssize_t)blksize) {

lib/libdmsg/crypto.c

572

n = read(iocom->sock_fd, ptr, blksize - (i & blkmask));

lib/libdmsg/crypto.c

578

if (RSA_private_decrypt(blksize,

lib/libdmsg/crypto.c

584

if (RSA_public_decrypt(blksize,

libexec/ftpd/ftpd.c

2006

send_data(FILE *instr, FILE *outstr, size_t blksize, off_t filesize, int isreg)

libexec/ftpd/ftpd.c

2108

if ((buf = malloc(blksize)) == NULL) {

libexec/ftpd/ftpd.c

2118

cnt = read(filefd, buf, blksize);

sbin/disklabel64/disklabel64.c

1018

if (blksize == 0) {

sbin/disklabel64/disklabel64.c

1026

if (getasciipartuuid(tp, lp, part, lineno, blksize)) {

sbin/disklabel64/disklabel64.c

1033

if (getasciipartspec(tp, lp, part, lineno, blksize)) {

sbin/disklabel64/disklabel64.c

1076

int lineno, uint32_t blksize)

sbin/disklabel64/disklabel64.c

1099

mpx = blksize;

sbin/disklabel64/disklabel64.c

1150

pp->p_boffset = vv * blksize + lp->d_pbase;

sbin/disklabel64/disklabel64.c

1199

int lineno, uint32_t blksize __unused)

sbin/disklabel64/disklabel64.c

647

uint32_t blksize;

sbin/disklabel64/disklabel64.c

654

blksize = 1024;

sbin/disklabel64/disklabel64.c

656

blksize = lp->d_align;

sbin/disklabel64/disklabel64.c

665

(uintmax_t)(lp->d_pstop - lp->d_pbase) / blksize,

sbin/disklabel64/disklabel64.c

689

blksize);

sbin/disklabel64/disklabel64.c

707

fprintf(f, "%10ju ", (uintmax_t)pp->p_bsize / blksize);

sbin/disklabel64/disklabel64.c

713

(uintmax_t)(pp->p_boffset - lp->d_pbase) / blksize);

sbin/disklabel64/disklabel64.c

865

uint32_t blksize = 0;

sbin/disklabel64/disklabel64.c

990

blksize = v;

sbin/hammer2/cmd_rsa.c

124

int blksize = 0;

sbin/hammer2/cmd_rsa.c

178

blksize = RSA_size(keys[i]);

sbin/hammer2/cmd_rsa.c

180

assert(blksize == RSA_size(keys[i]));

sbin/hammer2/cmd_rsa.c

182

fprintf(stderr, "blksize %d\n", blksize);

sbin/hammer2/cmd_rsa.c

187

data_in = malloc(blksize);

sbin/hammer2/cmd_rsa.c

188

data_out = malloc(blksize);

sbin/hammer2/cmd_rsa.c

190

while ((n = read(0, data_in + off, blksize - off)) > 0) {

sbin/hammer2/cmd_rsa.c

192

if (off == blksize) {

sbin/hammer2/cmd_rsa.c

195

RSA_public_encrypt(blksize,

sbin/hammer2/cmd_rsa.c

200

RSA_private_encrypt(blksize,

sbin/hammer2/cmd_rsa.c

205

bcopy(data_out, data_in, blksize);

sbin/hammer2/cmd_rsa.c

207

if (write(1, data_out, blksize) != blksize) {

sbin/hammer2/cmd_rsa.c

216

if (off < blksize)

sbin/hammer2/cmd_rsa.c

217

bzero(data_in + off, blksize - off);

sbin/hammer2/cmd_rsa.c

220

RSA_public_encrypt(blksize,

sbin/hammer2/cmd_rsa.c

225

RSA_private_encrypt(blksize,

sbin/hammer2/cmd_rsa.c

230

bcopy(data_out, data_in, blksize);

sbin/hammer2/cmd_rsa.c

232

if (write(1, data_out, blksize) != blksize) {

sbin/hammer2/cmd_rsa.c

259

int blksize = 0;

sbin/hammer2/cmd_rsa.c

313

blksize = RSA_size(keys[i]);

sbin/hammer2/cmd_rsa.c

315

assert(blksize == RSA_size(keys[i]));

sbin/hammer2/cmd_rsa.c

321

data_in = malloc(blksize);

sbin/hammer2/cmd_rsa.c

322

data_out = malloc(blksize);

sbin/hammer2/cmd_rsa.c

324

while ((n = read(0, data_in + off, blksize - off)) > 0) {

sbin/hammer2/cmd_rsa.c

326

if (off == blksize) {

sbin/hammer2/cmd_rsa.c

329

RSA_public_decrypt(blksize,

sbin/hammer2/cmd_rsa.c

334

RSA_private_decrypt(blksize,

sbin/hammer2/cmd_rsa.c

339

bcopy(data_out, data_in, blksize);

sbin/hammer2/cmd_rsa.c

341

if (write(1, data_out, blksize) != blksize) {

sbin/hammer2/cmd_rsa.c

350

if (off < blksize)

sbin/hammer2/cmd_rsa.c

351

bzero(data_in + off, blksize - off);

sbin/hammer2/cmd_rsa.c

354

RSA_public_decrypt(blksize,

sbin/hammer2/cmd_rsa.c

359

RSA_private_decrypt(blksize,

sbin/hammer2/cmd_rsa.c

364

bcopy(data_out, data_in, blksize);

sbin/hammer2/cmd_rsa.c

366

if (write(1, data_out, blksize) != blksize) {

sys/bus/cam/scsi/scsi_cd.c

1530

KKASSERT(bio->bio_offset % softc->params.blksize == 0);

sys/bus/cam/scsi/scsi_cd.c

1540

bio->bio_offset / softc->params.blksize,

sys/bus/cam/scsi/scsi_cd.c

1541

bp->b_bcount / softc->params.blksize,

sys/bus/cam/scsi/scsi_cd.c

1704

cdp->blksize = scsi_4btoul (rdcap->length);

sys/bus/cam/scsi/scsi_cd.c

1709

cdp->disksize, (u_long)cdp->blksize);

sys/bus/cam/scsi/scsi_cd.c

1710

info.d_media_blksize = cdp->blksize;

sys/bus/cam/scsi/scsi_cd.c

2886

info.d_media_blksize = softc->params.blksize;

sys/bus/cam/scsi/scsi_cd.c

2899

softc->device_stats.block_size = softc->params.blksize;

sys/bus/cam/scsi/scsi_cd.c

3059

softc->params.blksize = scsi_4btoul(rcap_buf->length);

sys/bus/cam/scsi/scsi_cd.c

3068

if (softc->params.blksize > 2048 && softc->params.blksize <= 2352)

sys/bus/cam/scsi/scsi_cd.c

3069

softc->params.blksize = 2048;

sys/bus/cam/scsi/scsi_cd.c

87

u_int32_t blksize;

sys/dev/disk/nata/atapi-tape.c

287

g->mt_blksiz = stp->blksize;

sys/dev/disk/nata/atapi-tape.c

419

if (bbp->b_bcount % stp->blksize) {

sys/dev/disk/nata/atapi-tape.c

420

device_printf(dev, "transfers must be multiple of %d\n", stp->blksize);

sys/dev/disk/nata/atapi-tape.c

426

if (bbp->b_bcount > stp->blksize * stp->cap.ctl) {

sys/dev/disk/nata/atapi-tape.c

429

bbp->b_bcount, stp->blksize * stp->cap.ctl);

sys/dev/disk/nata/atapi-tape.c

441

blkcount = bbp->b_bcount / stp->blksize;

sys/dev/disk/nata/atapi-tape.c

458

request->bytecount = blkcount * stp->blksize;

sys/dev/disk/nata/atapi-tape.c

510

stp->blksize = 32768;

sys/dev/disk/nata/atapi-tape.c

512

stp->blksize = 1024;

sys/dev/disk/nata/atapi-tape.c

514

stp->blksize = 512;

sys/dev/disk/nata/atapi-tape.c

515

if (!stp->blksize)

sys/dev/disk/nata/atapi-tape.h

155

int blksize; /* block size (512 | 1024) */

sys/dev/disk/nvme/nvme.h

186

uint32_t blksize;

sys/dev/disk/nvme/nvme_admin.c

675

nsc->blksize = 1 << lbafmt->sect_size;

sys/dev/disk/nvme/nvme_disk.c

104

cap_gb = nsc->idns.size / (1024 * 1024 * 1024 / nsc->blksize);

sys/dev/disk/nvme/nvme_disk.c

109

nsc->blksize, nsc->idns.size, cap_gb, serial);

sys/dev/disk/nvme/nvme_disk.c

236

secno = bio->bio_offset / nsc->blksize;

sys/dev/disk/nvme/nvme_disk.c

237

nlba = bp->b_bcount / nsc->blksize;

sys/dev/disk/nvme/nvme_disk.c

257

bp->b_data, nlba * nsc->blksize);

sys/dev/disk/nvme/nvme_disk.c

276

bp->b_data, nlba * nsc->blksize);

sys/dev/disk/nvme/nvme_disk.c

459

secno = ap->a_offset / nsc->blksize;

sys/dev/disk/nvme/nvme_disk.c

460

nlba = ap->a_length / nsc->blksize;

sys/dev/disk/nvme/nvme_disk.c

471

ap->a_virtual, nlba * nsc->blksize);

sys/dev/disk/nvme/nvme_disk.c

78

devstat_add_entry(&nsc->stats, "nvme", nsc->unit, nsc->blksize,

sys/dev/disk/nvme/nvme_disk.c

88

info.d_media_blksize = nsc->blksize;

sys/dev/disk/xdisk/xdisk.c

485

msg->any.lnk_span.media.block.blksize;

sys/dev/smbus/atmel_mxt/atmel_mxt.c

363

int blksize;

sys/dev/smbus/atmel_mxt/atmel_mxt.c

383

blksize = sizeof(sc->core.info) +

sys/dev/smbus/atmel_mxt/atmel_mxt.c

385

totsize = blksize + sizeof(struct mxt_raw_crc);

sys/dev/smbus/atmel_mxt/atmel_mxt.c

393

kprintf("COREBUF %p %d\n", sc->core.buf, blksize);

sys/dev/smbus/atmel_mxt/atmel_mxt.c

394

crc = obp_convert_crc((void *)((uint8_t *)sc->core.buf + blksize));

sys/dev/smbus/atmel_mxt/atmel_mxt.c

395

if (obp_crc24(sc->core.buf, blksize) != crc) {

sys/dev/smbus/atmel_mxt/atmel_mxt.c

399

crc, obp_crc24(sc->core.buf, blksize));

sys/dev/smbus/atmel_mxt/atmel_mxt.c

409

while (i < blksize) {

sys/dev/smbus/atmel_mxt/test_atmel.c

169

size_t blksize;

sys/dev/smbus/atmel_mxt/test_atmel.c

185

blksize = sizeof(rup.info) +

sys/dev/smbus/atmel_mxt/test_atmel.c

187

totsize = blksize + sizeof(struct mxt_raw_crc);

sys/dev/smbus/atmel_mxt/test_atmel.c

195

crc = obp_convert_crc((struct mxt_raw_crc *)(rbuf + blksize));

sys/dev/smbus/atmel_mxt/test_atmel.c

196

if (obp_crc24(rbuf, blksize) != crc) {

sys/dev/smbus/atmel_mxt/test_atmel.c

199

obp_crc24(rbuf, blksize));

sys/dev/sound/pci/neomagic.c

359

ch->blksize = 0;

sys/dev/sound/pci/neomagic.c

401

ch->blksize = blocksize;

sys/dev/sound/pci/neomagic.c

423

ch->wmark = ch->blksize;

sys/dev/sound/pci/neomagic.c

439

ch->wmark = ch->blksize;

sys/dev/sound/pci/neomagic.c

498

sc->pch.wmark += sc->pch.blksize;

sys/dev/sound/pci/neomagic.c

507

sc->rch.wmark += sc->rch.blksize;

sys/dev/sound/pci/neomagic.c

55

u_int32_t blksize, wmark;

sys/kern/subr_diskiocom.c

166

dp->d_iocom.auto_lnk_span.media.block.blksize =

sys/kern/subr_disklabel64.c

391

uint32_t blksize = info->d_media_blksize;

sys/kern/subr_disklabel64.c

397

lp->d_total_size = (uint64_t)sp->ds_size * blksize;

sys/kern/subr_disklabel64.c

399

lp->d_total_size = info->d_media_blocks * blksize;

sys/kern/subr_disklabel64.c

402

lp->d_align = blksize;

sys/kern/subr_disklabel64.c

443

uint32_t blksize;

sys/kern/subr_disklabel64.c

460

if ((blksize = info->d_media_blksize) < 4096)

sys/kern/subr_disklabel64.c

461

blksize = 4096;

sys/kern/subr_disklabel64.c

462

blkmask = blksize - 1;

sys/kern/subr_disklabel64.c

470

lp->d_align = blksize;

sys/kern/vfs_bio.c

2642

getcacheblk(struct vnode *vp, off_t loffset, int blksize, int blkflags)

sys/kern/vfs_bio.c

2652

if (blksize) {

sys/kern/vfs_bio.c

2653

bp = getblk(vp, loffset, blksize, blkflags, 0);

sys/kern/vfs_cache.c

2733

int blksize;

sys/kern/vfs_cache.c

2767

if ((blksize = vat.va_blocksize) == 0)

sys/kern/vfs_cache.c

2768

blksize = DEV_BSIZE;

sys/kern/vfs_cache.c

2769

rbuf = kmalloc(blksize, M_TEMP, M_WAITOK);

sys/kern/vfs_cache.c

2776

iov.iov_len = blksize;

sys/kern/vfs_cache.c

2779

uio.uio_resid = blksize;

sys/kern/vfs_cache.c

2789

bytes = blksize - uio.uio_resid;

sys/kern/vfs_cache.c

2816

if (rncp.ncp == NULL && eofflag == 0 && uio.uio_resid != blksize)

sys/kern/vfs_cluster.c

100

struct buf *last_bp, int blksize);

sys/kern/vfs_cluster.c

103

off_t doffset, int blksize, int run,

sys/kern/vfs_cluster.c

1075

if (tbp->b_bcount != blksize)

sys/kern/vfs_cluster.c

1076

kprintf("warning: tbp->b_bcount wrong %d vs %d\n", tbp->b_bcount, blksize);

sys/kern/vfs_cluster.c

1077

if (tbp->b_bufsize != blksize)

sys/kern/vfs_cluster.c

1078

kprintf("warning: tbp->b_bufsize wrong %d vs %d\n", tbp->b_bufsize, blksize);

sys/kern/vfs_cluster.c

1079

bp->b_bcount += blksize;

sys/kern/vfs_cluster.c

108

static int cluster_wbuild(struct vnode *vp, struct buf **bpp, int blksize,

sys/kern/vfs_cluster.c

1080

bp->b_bufsize += blksize;

sys/kern/vfs_cluster.c

1208

cluster_wbuild_wb(struct vnode *vp, int blksize, off_t start_loffset, int len)

sys/kern/vfs_cluster.c

1220

r = cluster_wbuild(vp, NULL, blksize,

sys/kern/vfs_cluster.c

1244

cluster_write(struct buf *bp, off_t filesize, int blksize, int seqcount)

sys/kern/vfs_cluster.c

1299

if (bp->b_loffset + blksize < filesize ||

sys/kern/vfs_cluster.c

1303

cluster_wbuild_wb(vp, blksize,

sys/kern/vfs_cluster.c

1311

bp, blksize);

sys/kern/vfs_cluster.c

1333

blksize, cc->v_cstart,

sys/kern/vfs_cluster.c

1344

cc->v_lastw = loffset + blksize;

sys/kern/vfs_cluster.c

1346

blksize;

sys/kern/vfs_cluster.c

1359

bp->b_loffset + blksize < filesize &&

sys/kern/vfs_cluster.c

1365

cc->v_lasta = bp->b_bio2.bio_offset + blksize;

sys/kern/vfs_cluster.c

1367

cc->v_lastw = loffset + blksize;

sys/kern/vfs_cluster.c

1371

if (maxclen > blksize)

sys/kern/vfs_cluster.c

1374

cc->v_clen = blksize;

sys/kern/vfs_cluster.c

1390

cluster_wbuild_wb(vp, blksize, cc->v_cstart,

sys/kern/vfs_cluster.c

1391

cc->v_clen + blksize);

sys/kern/vfs_cluster.c

1395

bp->b_loffset + blksize < filesize) {

sys/kern/vfs_cluster.c

1408

cc->v_lastw = loffset + blksize;

sys/kern/vfs_cluster.c

1409

cc->v_lasta = bp->b_bio2.bio_offset + blksize;

sys/kern/vfs_cluster.c

1459

int blksize, off_t start_loffset, int bytes)

sys/kern/vfs_cluster.c

1488

start_loffset += blksize;

sys/kern/vfs_cluster.c

1489

bytes -= blksize;

sys/kern/vfs_cluster.c

1506

tbp->b_bcount != blksize ||

sys/kern/vfs_cluster.c

1507

bytes == blksize) {

sys/kern/vfs_cluster.c

1510

start_loffset += blksize;

sys/kern/vfs_cluster.c

1511

bytes -= blksize;

sys/kern/vfs_cluster.c

1565

for (i = 0; i < bytes; (i += blksize), (start_loffset += blksize)) {

sys/kern/vfs_cluster.c

1606

if ((tbp->b_bcount != blksize) ||

sys/kern/vfs_cluster.c

1670

bp->b_bcount += blksize;

sys/kern/vfs_cluster.c

1671

bp->b_bufsize += blksize;

sys/kern/vfs_cluster.c

1728

struct buf *last_bp, int blksize)

sys/kern/vfs_cluster.c

1737

len = (int)(cc->v_lastw - cc->v_cstart) / blksize;

sys/kern/vfs_cluster.c

1745

(loffset += blksize), i++) {

sys/kern/vfs_cluster.c

224

cluster_readx(struct vnode *vp, off_t filesize, off_t loffset, int blksize,

sys/kern/vfs_cluster.c

267

if (maxreq < blksize)

sys/kern/vfs_cluster.c

268

maxreq = blksize;

sys/kern/vfs_cluster.c

276

maxra = (int)(maxreq / blksize);

sys/kern/vfs_cluster.c

284

*bpp = reqbp = bp = getblk(vp, loffset, blksize, blkflags, 0);

sys/kern/vfs_cluster.c

291

maxrbuild = vmaxiosize(vp) / blksize;

sys/kern/vfs_cluster.c

329

rbp = findblk(vp, loffset + i * blksize, FINDBLK_TEST);

sys/kern/vfs_cluster.c

333

rbp = findblk(vp, loffset + i * blksize,

sys/kern/vfs_cluster.c

342

rbp = findblk(vp, loffset + i * blksize,

sys/kern/vfs_cluster.c

367

loffset += i * blksize;

sys/kern/vfs_cluster.c

372

if (loffset + maxra * blksize > filesize) {

sys/kern/vfs_cluster.c

374

maxra = (int)(maxreq / blksize);

sys/kern/vfs_cluster.c

415

if (nblks > burstbytes / blksize)

sys/kern/vfs_cluster.c

416

nblks = burstbytes / blksize;

sys/kern/vfs_cluster.c

423

doffset, blksize, nblks, bp, &sr);

sys/kern/vfs_cluster.c

425

maxra -= bp->b_bufsize / blksize;

sys/kern/vfs_cluster.c

432

loffset += blksize;

sys/kern/vfs_cluster.c

462

loffset, blksize, maxra, sr);

sys/kern/vfs_cluster.c

482

rbp = getblk(vp, loffset, blksize,

sys/kern/vfs_cluster.c

509

if (nblks > burstbytes / blksize)

sys/kern/vfs_cluster.c

510

nblks = burstbytes / blksize;

sys/kern/vfs_cluster.c

516

doffset, blksize,

sys/kern/vfs_cluster.c

531

maxra -= rbp->b_bufsize / blksize;

sys/kern/vfs_cluster.c

569

cluster_readcb(struct vnode *vp, off_t filesize, off_t loffset, int blksize,

sys/kern/vfs_cluster.c

611

if (maxreq < blksize)

sys/kern/vfs_cluster.c

612

maxreq = blksize;

sys/kern/vfs_cluster.c

620

maxra = (int)(maxreq / blksize);

sys/kern/vfs_cluster.c

625

reqbp = bp = getblk(vp, loffset, blksize, blkflags, 0);

sys/kern/vfs_cluster.c

632

maxrbuild = vmaxiosize(vp) / blksize;

sys/kern/vfs_cluster.c

672

if (findblk(vp, loffset + (maxra - 2) * blksize, FINDBLK_TEST))

sys/kern/vfs_cluster.c

677

if (findblk(vp, loffset + i * blksize,

sys/kern/vfs_cluster.c

701

loffset += i * blksize;

sys/kern/vfs_cluster.c

707

if (loffset + maxra * blksize > filesize) {

sys/kern/vfs_cluster.c

709

maxra = (int)(maxreq / blksize);

sys/kern/vfs_cluster.c

753

if (nblks > burstbytes / blksize)

sys/kern/vfs_cluster.c

754

nblks = burstbytes / blksize;

sys/kern/vfs_cluster.c

761

doffset, blksize, nblks, bp, &sr);

sys/kern/vfs_cluster.c

763

maxra -= bp->b_bufsize / blksize;

sys/kern/vfs_cluster.c

770

loffset += blksize;

sys/kern/vfs_cluster.c

800

loffset, blksize, maxra, sr);

sys/kern/vfs_cluster.c

817

rbp = getblk(vp, loffset, blksize,

sys/kern/vfs_cluster.c

838

if (nblks > burstbytes / blksize)

sys/kern/vfs_cluster.c

839

nblks = burstbytes / blksize;

sys/kern/vfs_cluster.c

845

doffset, blksize,

sys/kern/vfs_cluster.c

860

maxra -= rbp->b_bufsize / blksize;

sys/kern/vfs_cluster.c

894

int blksize, int run, struct buf *fbp, int *srp)

sys/kern/vfs_cluster.c

904

while (loffset + run * blksize > filesize) {

sys/kern/vfs_cluster.c

954

for (boffset = doffset, i = 0; i < run; ++i, boffset += blksize) {

sys/kern/vfs_cluster.c

957

round_page(blksize) > maxiosize) {

sys/kern/vfs_cluster.c

966

tbp = getblk(vp, loffset + i * blksize, blksize,

sys/kern/vfs_subr.c

1642

vinitvmio(struct vnode *vp, off_t filesize, int blksize, int boff)

sys/kern/vfs_subr.c

1654

object = vnode_pager_alloc(vp, filesize, 0, 0, blksize, boff);

sys/kern/vfs_subr.c

475

vtruncbuf(struct vnode *vp, off_t length, int blksize)

sys/kern/vfs_subr.c

486

if ((count = (int)(length % blksize)) != 0)

sys/kern/vfs_subr.c

487

info.truncloffset = length + (blksize - count);

sys/kern/vfs_vm.c

130

nvtruncbuf(struct vnode *vp, off_t length, int blksize, int boff, int flags)

sys/kern/vfs_vm.c

147

boff = (int)(length % blksize);

sys/kern/vfs_vm.c

149

info.truncloffset = length + (blksize - boff);

sys/kern/vfs_vm.c

165

nvnode_pager_setsize(vp, length, blksize, boff);

sys/kern/vfs_vm.c

181

error = bread_kvabio(vp, truncboffset, blksize, &bp);

sys/kern/vfs_vm.c

184

bzero(bp->b_data + boff, blksize - boff);

sys/kern/vfs_vm.c

431

nvnode_pager_setsize(struct vnode *vp, off_t length, int blksize, int boff)

sys/kern/vfs_vm.c

460

boff = (int)(length % blksize);

sys/kern/vfs_vm.c

464

nobjsize = OFF_TO_IDX(truncboffset + blksize + PAGE_MASK);

sys/sys/buf2.h

373

int blksize, size_t minreq, size_t maxreq, struct buf **bpp)

sys/sys/buf2.h

376

return(cluster_readx(vp, filesize, loffset, blksize, B_NOTMETA,

sys/sys/buf2.h

382

int blksize, size_t minreq, size_t maxreq, struct buf **bpp)

sys/sys/buf2.h

385

return(cluster_readx(vp, filesize, loffset, blksize,

sys/sys/dmsg.h

450

uint32_t blksize; /* media block size */

sys/sys/vnode.h

472

int vtruncbuf (struct vnode *vp, off_t length, int blksize);

sys/sys/vnode.h

474

int nvtruncbuf (struct vnode *vp, off_t length, int blksize, int boff,

sys/sys/vnode.h

480

int blksize, int boff);

sys/sys/vnode.h

484

int vinitvmio(struct vnode *vp, off_t filesize, int blksize, int boff);

sys/vfs/ext2fs/ext2_htree.c

423

struct componentname *cnp, uint32_t blksize)

sys/vfs/ext2fs/ext2_htree.c

431

cursize = roundup(dp->i_size, blksize);

sys/vfs/ext2fs/ext2_htree.c

432

newsize = cursize + blksize;

sys/vfs/ext2fs/ext2_htree.c

435

auio.uio_resid = blksize;

sys/vfs/ext2fs/ext2_htree.c

436

aiov.iov_len = blksize;

sys/vfs/ext2fs/ext2_htree.c

518

ext2_append_entry(char *block, uint32_t blksize,

sys/vfs/ext2fs/ext2_htree.c

527

new_entry->e2d_reclen = htole16(block + blksize - (char *)last_entry -

sys/vfs/ext2fs/ext2_htree.c

537

uint32_t blksize, uint32_t *hash_seed, uint8_t hash_version,

sys/vfs/ext2fs/ext2_htree.c

555

((char *)block2 + blksize);

sys/vfs/ext2fs/ext2_htree.c

569

while ((char *)ep < block1 + blksize - csum_size) {

sys/vfs/ext2fs/ext2_htree.c

594

if (le16toh(sort_info[i].h_size) + size > blksize / 2)

sys/vfs/ext2fs/ext2_htree.c

626

for (offset = 0; offset < blksize - csum_size; ) {

sys/vfs/ext2fs/ext2_htree.c

640

ext2_append_entry(block2, blksize,

sys/vfs/ext2fs/ext2_htree.c

644

last->e2d_reclen = htole16(block1 + blksize - (char *)last -

sys/vfs/ext2fs/ext2_htree.c

648

ext2_append_entry(block1, blksize, last, entry, csum_size);

sys/vfs/ext2fs/ext2_htree.c

652

htole16(block2 + blksize - dest - csum_size);

sys/vfs/ext2fs/ext2_htree.c

656

ext2_init_dirent_tail(EXT2_DIRENT_TAIL(block1, blksize));

sys/vfs/ext2fs/ext2_htree.c

657

ext2_init_dirent_tail(EXT2_DIRENT_TAIL(block2, blksize));

sys/vfs/ext2fs/ext2_htree.c

66

static void ext2_append_entry(char *block, uint32_t blksize,

sys/vfs/ext2fs/ext2_htree.c

677

uint32_t blksize, dirlen, split_hash;

sys/vfs/ext2fs/ext2_htree.c

687

blksize = m_fs->e2fs_bsize;

sys/vfs/ext2fs/ext2_htree.c

689

buf1 = malloc(blksize, M_TEMP, M_WAITOK | M_ZERO);

sys/vfs/ext2fs/ext2_htree.c

690

buf2 = malloc(blksize, M_TEMP, M_WAITOK | M_ZERO);

sys/vfs/ext2fs/ext2_htree.c

699

dirlen = (char *)root + blksize - (char *)ep;

sys/vfs/ext2fs/ext2_htree.c

70

struct componentname *cnp, uint32_t blksize);

sys/vfs/ext2fs/ext2_htree.c

705

ep->e2d_reclen = htole16(buf1 + blksize - (char *)ep);

sys/vfs/ext2fs/ext2_htree.c

712

dotdot->e2d_reclen = htole16(blksize - EXT2_DIR_REC_LEN(1));

sys/vfs/ext2fs/ext2_htree.c

730

ext2_htree_split_dirblock(dp, buf1, buf2, blksize, hash_seed,

sys/vfs/ext2fs/ext2_htree.c

752

error = ext2_htree_append_block(vp, buf1, cnp, blksize);

sys/vfs/ext2fs/ext2_htree.c

760

error = ext2_htree_append_block(vp, buf2, cnp, blksize);

sys/vfs/ext2fs/ext2_htree.c

789

uint32_t blksize, blknum;

sys/vfs/ext2fs/ext2_htree.c

804

blksize = m_fs->e2fs_bsize;

sys/vfs/ext2fs/ext2_htree.c

821

newidxblock = malloc(blksize, M_TEMP, M_WAITOK | M_ZERO);

sys/vfs/ext2fs/ext2_htree.c

825

dst_node->h_fake_dirent.e2d_reclen = htole16(blksize);

sys/vfs/ext2fs/ext2_htree.c

827

cursize = roundup(ip->i_size, blksize);

sys/vfs/ext2fs/ext2_htree.c

828

dirsize = cursize + blksize;

sys/vfs/ext2fs/ext2_htree.c

829

blknum = dirsize / blksize - 1;

sys/vfs/ext2fs/ext2_htree.c

832

cnp, blksize);

sys/vfs/ext2fs/ext2_htree.c

914

error = ext2_blkatoff(dvp, blknum * blksize, NULL, &bp);

sys/vfs/ext2fs/ext2_htree.c

919

newdirblock = malloc(blksize, M_TEMP, M_WAITOK | M_ZERO);

sys/vfs/ext2fs/ext2_htree.c

921

ext2_htree_split_dirblock(ip, (char *)bp->b_data, newdirblock, blksize,

sys/vfs/ext2fs/ext2_htree.c

923

cursize = roundup(ip->i_size, blksize);

sys/vfs/ext2fs/ext2_htree.c

924

dirsize = cursize + blksize;

sys/vfs/ext2fs/ext2_htree.c

925

blknum = dirsize / blksize - 1;

sys/vfs/ext2fs/ext2_htree.c

932

error = ext2_htree_append_block(dvp, newdirblock, cnp, blksize);

sys/vfs/ext2fs/ext2_htree.c

95

char *block1, char *block2, uint32_t blksize,

sys/vfs/ext2fs/ext2_inode.c

292

size = blksize(fs, oip, lbn);

sys/vfs/ext2fs/ext2_inode.c

390

bsize = blksize(fs, oip, i);

sys/vfs/ext2fs/ext2_inode.c

409

oldspace = blksize(fs, oip, lastblock);

sys/vfs/ext2fs/ext2_inode.c

411

newspace = blksize(fs, oip, lastblock);

sys/vfs/ext2fs/ext2_subr.c

89

bsize = blksize(fs, ip, lbn);

sys/vfs/ext2fs/ext2_vnops.c

1854

size = blksize(fs, ip, lbn);

sys/vfs/ext2fs/ext2_vnops.c

1870

u_int nextsize = blksize(fs, ip, nextlbn);

sys/vfs/ext2fs/ext2_vnops.c

2031

size = blksize(fs, ip, lbn) - bp->b_resid;

sys/vfs/fuse/fuse_abi.h

188

uint32_t blksize;

sys/vfs/hammer/hammer_io.c

1944

int blksize;

sys/vfs/hammer/hammer_io.c

1949

blksize = iinfo->u.leaf->data_len;

sys/vfs/hammer/hammer_io.c

1950

KKASSERT((blksize & HAMMER_BUFMASK) == 0);

sys/vfs/hammer/hammer_io.c

1960

bp = getblk(ip->vp, file_offset, blksize, 0, 0);

sys/vfs/hammer/hammer_vnops.c

2164

int blksize;

sys/vfs/hammer/hammer_vnops.c

2261

blksize = hammer_blocksize(vap->va_size);

sys/vfs/hammer/hammer_vnops.c

2270

blksize,

sys/vfs/hammer/hammer_vnops.c

2316

aligned_size = (vap->va_size + (blksize - 1)) &

sys/vfs/hammer/hammer_vnops.c

2317

~(int64_t)(blksize - 1);

sys/vfs/hammer/hammer_vnops.c

2319

aligned_size -= blksize;

sys/vfs/hammer/hammer_vnops.c

2974

int blksize;

sys/vfs/hammer/hammer_vnops.c

3121

blksize = hammer_blocksize(ap->a_loffset);

sys/vfs/hammer/hammer_vnops.c

3122

if (hammer_blocksize(base_offset) != blksize) {

sys/vfs/hammer/hammer_vnops.c

3126

hammer_blocksize(last_offset - 1) != blksize) {

sys/vfs/hammer/hammer_vnops.c

3143

(last_offset - ap->a_loffset) < blksize) {

sys/vfs/hammer/hammer_vnops.c

315

int blksize;

sys/vfs/hammer/hammer_vnops.c

3180

int blksize __debugvar;

sys/vfs/hammer/hammer_vnops.c

3189

blksize = hammer_blocksize(bio->bio_offset);

sys/vfs/hammer/hammer_vnops.c

3190

KKASSERT(bp->b_bufsize == blksize);

sys/vfs/hammer/hammer_vnops.c

345

blksize = hammer_blocksize(uio->uio_offset);

sys/vfs/hammer/hammer_vnops.c

371

blksize = hammer_blocksize(uio->uio_offset);

sys/vfs/hammer/hammer_vnops.c

372

offset = (int)uio->uio_offset & (blksize - 1);

sys/vfs/hammer/hammer_vnops.c

381

bp = getblk(ap->a_vp, base_offset, blksize, 0, 0);

sys/vfs/hammer/hammer_vnops.c

417

blksize, B_NOTMETA,

sys/vfs/hammer/hammer_vnops.c

423

blksize, B_NOTMETA,

sys/vfs/hammer/hammer_vnops.c

438

if (blksize == HAMMER_XBUFSIZE)

sys/vfs/hammer/hammer_vnops.c

441

n = blksize - offset;

sys/vfs/hammer/hammer_vnops.c

599

int blksize;

sys/vfs/hammer/hammer_vnops.c

610

blksize = hammer_blocksize(uio->uio_offset);

sys/vfs/hammer/hammer_vnops.c

648

bwillwrite(blksize);

sys/vfs/hammer/hammer_vnops.c

654

blkmask = blksize - 1;

sys/vfs/hammer/hammer_vnops.c

657

n = blksize - offset;

sys/vfs/hammer/hammer_vnops.c

691

blksize, GETBLK_BHEAVY, 0);

sys/vfs/hammer/hammer_vnops.c

695

blksize, &bp);

sys/vfs/hammer/hammer_vnops.c

697

} else if (offset == 0 && uio->uio_resid >= blksize) {

sys/vfs/hammer/hammer_vnops.c

703

bp = getblk(ap->a_vp, base_offset, blksize, GETBLK_BHEAVY, 0);

sys/vfs/hammer/hammer_vnops.c

712

blksize, GETBLK_BHEAVY, 0);

sys/vfs/hammer/hammer_vnops.c

719

error = bread(ap->a_vp, base_offset, blksize, &bp);

sys/vfs/hammer/hammer_vnops.c

773

if (blksize == HAMMER_XBUFSIZE)

sys/vfs/hammer/hammer_vnops.c

825

if (blksize == HAMMER_XBUFSIZE)

sys/vfs/hammer/hammer_vnops.c

841

cluster_write(bp, cluster_eof, blksize, seqcount);

sys/vfs/isofs/cd9660/cd9660_lookup.c

397

bsize = blksize(imp, ip, lbn);

sys/vfs/isofs/cd9660/cd9660_lookup.c

461

bsize = blksize(imp, ip, lbn);

sys/vfs/isofs/cd9660/cd9660_vnops.c

280

size = blksize(imp, ip, lbn);

sys/vfs/isofs/cd9660/cd9660_vnops.c

297

rasize = blksize(imp, ip, rablock);

sys/vfs/ufs/ffs_balloc.c

119

osize = blksize(fs, ip, nb);

sys/vfs/ufs/ffs_inode.c

289

size = blksize(fs, oip, lbn);

sys/vfs/ufs/ffs_inode.c

393

bsize = blksize(fs, oip, i);

sys/vfs/ufs/ffs_inode.c

412

oldspace = blksize(fs, oip, lastblock);

sys/vfs/ufs/ffs_inode.c

414

newspace = blksize(fs, oip, lastblock);

sys/vfs/ufs/ffs_softdep.c

2180

bsize = blksize(fs, &tip, i);

sys/vfs/ufs/ffs_softdep.c

4089

error = bread(pvp, lblktodoff(fs, lbn), blksize(fs, VTOI(pvp), lbn), &bp);

sys/vfs/ufs/ffs_subr.c

110

bsize = blksize(fs, ip, lbn);

sys/vfs/ufs/ffs_subr.c

135

nextbsize = blksize(fs, ip, nextlbn);

sys/vfs/ufs/ffs_subr.c

71

bsize = blksize(fs, ip, lbn);

sys/vfs/ufs/fs.h

558

#define blkoffsize(fs, ip, loc) blksize(fs, ip, lblkno(fs, loc))

sys/vfs/ufs/ufs_readwrite.c

33

#define BLKSIZE(a, b, c) blksize(a, b, c)

sys/vm/vnode_pager.c

103

int blksize, int boff)

sys/vm/vnode_pager.c

150

boff = (int)(length % blksize);

sys/vm/vnode_pager.c

152

loffset = length + (blksize - boff);

test/stress/fsstress/global.h

84

memalign(int blksize, int bytes)

test/stress/fsstress/global.h

92

if (blksize < pagesize)

test/stress/fsstress/global.h

93

blksize = pagesize;

test/stress/fsstress/global.h

94

blkmask = blksize - 1;

usr.sbin/makefs/ffs/ffs_balloc.c

116

osize = blksize(fs, ip, nb);

usr.sbin/makefs/ffs/ffs_balloc.c

368

osize = blksize(fs, ip, nb);

usr.sbin/makefs/hammer2/hammer2_compat.h

554

vinitvmio(struct m_vnode *vp, off_t filesize, int blksize, int boff)

usr.sbin/makefs/hammer2/hammer2_compat.h

684

nvtruncbuf(struct m_vnode *vp, off_t length, int blksize, int boff, int flags)