bin/df/df.c

256

totals.f_frsize = DEV_BSIZE;

lib/libc/gen/disklabel.c

140

getnumdflt(dp->d_secsize, "se", DEV_BSIZE);

lib/libkvm/kvm.c

381

kd->fdalign = DEV_BSIZE;

lib/libperfuse/ops.c

332

vap->va_blocksize = DEV_BSIZE;

lib/libpuffs/subr.c

105

sbp->f_bsize = sbp->f_frsize = sbp->f_iosize = DEV_BSIZE;

lib/libquota/quota_nfs.c

49

return ((uint64_t)rqblocks * rqsize) / DEV_BSIZE;

lib/librefuse/refuse.c

324

st.st_blksize = DEV_BSIZE;

libexec/rpc.rquotad/rquotad.c

196

rq->rq_bsize = DEV_BSIZE;

sbin/apmlabel/apmlabel.c

104

unsigned char buf[DEV_BSIZE];

sbin/apmlabel/apmlabel.c

118

if ((i=read(sd, buf, sizeof(buf))) != DEV_BSIZE) {

sbin/apmlabel/apmlabel.c

135

if (read(sd, buf, sizeof(buf)) != DEV_BSIZE) {

sbin/atactl/atactl.c

1166

unsigned char inbuf[DEV_BSIZE];

sbin/atactl/atactl.c

1665

unsigned char inbuf[DEV_BSIZE];

sbin/atactl/atactl.c

1666

unsigned char inbuf2[DEV_BSIZE];

sbin/atactl/atactl.c

1829

unsigned char data[DEV_BSIZE];

sbin/blkdiscard/blkdiscard.c

181

size = dkw.dkw_size * DEV_BSIZE;

sbin/ccdconfig/ccdconfig.c

536

sector_size = DEV_BSIZE;

sbin/ccdconfig/ccdconfig.c

608

sector_size = DEV_BSIZE;

sbin/ccdconfig/ccdconfig.c

619

sector_size = DEV_BSIZE;

sbin/cgdconfig/cgdconfig.c

1176

for (blksize = DEV_BSIZE;

sbin/disklabel/main.c

1107

static u_char bb[DEV_BSIZE];

sbin/disklabel/main.c

1112

if (pread(f, bb, sizeof(bb), (off_t)FILECORE_BOOT_SECTOR * DEV_BSIZE) != sizeof(bb))

sbin/disklabel/main.c

1140

if (pread(f, bb, sizeof(bb), (off_t)offset * DEV_BSIZE) != sizeof(bb))

sbin/disklabel/main.c

1225

sector * (off_t)DEV_BSIZE);

sbin/disklabel/main.c

1317

wlen = pwrite(f, bootarea, bootarea_len, sector * (off_t)DEV_BSIZE);

sbin/disklabel/main.c

1373

written = update_label(f, label_sector, DEV_BSIZE);

sbin/disklabel/main.c

350

#define LABEL_OFFSET (dklabel_getlabelsector() * DEV_BSIZE + dklabel_getlabeloffset())

sbin/disklabel/main.c

356

#define LABEL_OFFSET (LABELSECTOR * DEV_BSIZE + LABELOFFSET)

sbin/disklabel/main.c

939

if (pread(f, &mbr, sizeof mbr, this_ext * (off_t)DEV_BSIZE)

sbin/dkctl/dkctl.c

501

if ((block = calloc(1, DEV_BSIZE)) == NULL)

sbin/dkctl/dkctl.c

534

if (lseek(fd, (off_t)blk * DEV_BSIZE,

sbin/dkctl/dkctl.c

541

if (read(fd, block, DEV_BSIZE) != DEV_BSIZE)

sbin/dkctl/dkctl.c

646

secsize = DEV_BSIZE;

sbin/dump/main.c

163

if (TP_BSIZE / DEV_BSIZE == 0 || TP_BSIZE % DEV_BSIZE != 0)

sbin/dump/tape.c

527

prev->count * (TP_BSIZE / DEV_BSIZE);

sbin/fsck_ext2fs/setup.c

155

dev_bsize = secsize = DEV_BSIZE;

sbin/fsck_ext2fs/setup.c

525

fs->e2fs.e2fs_bcount = (fs->e2fs_bsize * DEV_BSIZE) / fs->e2fs_bsize;

sbin/fsck_ffs/inode.c

466

(inodebuf = aligned_alloc(DEV_BSIZE, (unsigned)inobufsize)) == NULL)

sbin/fsck_ffs/setup.c

131

sblk.b_un.b_buf = aligned_alloc(DEV_BSIZE, SBLOCKSIZE);

sbin/fsck_ffs/setup.c

132

sblock = aligned_alloc(DEV_BSIZE, SBLOCKSIZE);

sbin/fsck_ffs/setup.c

133

asblk.b_un.b_buf = aligned_alloc(DEV_BSIZE, SBLOCKSIZE);

sbin/fsck_ffs/setup.c

134

altsblock = aligned_alloc(DEV_BSIZE, SBLOCKSIZE);

sbin/fsck_ffs/setup.c

154

dev_bsize = secsize = DEV_BSIZE;

sbin/fsck_ffs/setup.c

463

sblock->fs_csp = (struct csum *)aligned_alloc(DEV_BSIZE,

sbin/fsck_ffs/setup.c

499

blockmap = aligned_alloc(DEV_BSIZE, bmapsize);

sbin/fsck_ffs/setup.c

533

cgrp = aligned_alloc(DEV_BSIZE, sblock->fs_cgsize);

sbin/fsck_ffs/utilities.c

138

bufp = aligned_alloc(DEV_BSIZE, (unsigned int)sblock->fs_bsize);

sbin/fsck_ffs/utilities.c

144

bufp = aligned_alloc(DEV_BSIZE, (unsigned int)APPLEUFS_LABEL_SIZE);

sbin/fsck_ffs/utilities.c

156

bufp = aligned_alloc(DEV_BSIZE, (unsigned int)sblock->fs_bsize);

sbin/fsck_lfs/lfs.c

505

dev_bsize = DEV_BSIZE;

sbin/fsck_lfs/lfs.c

98

long dev_bsize = DEV_BSIZE;

sbin/fsdb/fsdb.c

881

rsize = roundup(size, DEV_BSIZE);

sbin/fsirand/fsirand.c

279

lab.d_secsize = DEV_BSIZE; /* XXX */

sbin/mbrlabel/mbrlabel.c

126

if (bsize < DEV_BSIZE) {

sbin/mount_portal/puffs_portal.c

563

va->va_blocksize = DEV_BSIZE;

sbin/newfs/mkfs.c

1042

union Buffer buf __aligned(DEV_BSIZE);

sbin/newfs/mkfs.c

1592

uint32_t oldfs[SBLOCKSIZE / 4] __aligned(DEV_BSIZE);

sbin/newfs/mkfs.c

204

if ((fsun = aligned_alloc(DEV_BSIZE, sizeof(*fsun))) == NULL)

sbin/newfs/mkfs.c

207

if ((cgun = aligned_alloc(DEV_BSIZE, sizeof(*cgun))) == NULL)

sbin/newfs/mkfs.c

639

struct appleufslabel appleufs __aligned(DEV_BSIZE);

sbin/newfs/newfs.c

619

if ((buf = aligned_alloc(DEV_BSIZE, bufsize)) == NULL)

sbin/newfs_sysvbfs/newfs_sysvbfs.c

180

uint8_t buf[DEV_BSIZE];

sbin/newfs_sysvbfs/newfs_sysvbfs.c

188

memset(buf, 0, DEV_BSIZE);

sbin/newfs_sysvbfs/newfs_sysvbfs.c

190

bfs->header.data_start_byte = DEV_BSIZE * 2; /* super block + inode */

sbin/raidctl/raidctl.c

571

if (0 > humanize_number(srs, 7, st.region_size * DEV_BSIZE,

sbin/resize_ffs/resize_ffs.c

200

if (lseek(fd, blkno * DEV_BSIZE, L_SET) < 0)

sbin/resize_ffs/resize_ffs.c

2080

writeat(where / DEV_BSIZE, newsb, SBLOCKSIZE);

sbin/resize_ffs/resize_ffs.c

2134

return st.st_size / DEV_BSIZE;

sbin/resize_ffs/resize_ffs.c

2228

readat(where / DEV_BSIZE, oldsb, SBLOCKSIZE);

sbin/resize_ffs/resize_ffs.c

2312

ftruncate(fd,newsize * DEV_BSIZE);

sbin/resize_ffs/resize_ffs.c

240

if (lseek(fd, blkno * DEV_BSIZE, L_SET) < 0)

sbin/savecore/savecore.c

341

dumplo = DEV_BSIZE * (off_t) l_dumplo;

sbin/savecore/savecore.c

345

(long long)dumplo, (long)(dumplo / DEV_BSIZE), (long)DEV_BSIZE);

sbin/scsictl/scsictl.c

514

if (j != DEV_BSIZE)

sbin/svhlabel/svhlabel.c

109

unsigned char buf[DEV_BSIZE];

sbin/svhlabel/svhlabel.c

120

if ((i = read(sd, buf, sizeof(buf))) != DEV_BSIZE) {

sbin/tunefs/tunefs.c

298

warnx("sector size must be at least %d", DEV_BSIZE);

sys/arch/acorn32/dev/md_hooks.c

86

printf("md%d: allocated %ldK (%ld blocks)\n", unit, (long)md->md_size / 1024, (long)md->md_size / DEV_BSIZE);

sys/arch/acorn32/mainbus/fd.c

1382

form_parms->nbps / DEV_BSIZE;

sys/arch/acorn32/mainbus/fd.c

1466

+ finfo->head * type->sectrac) * FDC_BSIZE / DEV_BSIZE;

sys/arch/acorn32/mainbus/fd.c

1533

bp = geteblk(fd_types[type].sectrac * DEV_BSIZE);

sys/arch/acorn32/mainbus/fd.c

1548

loop < (floppysize / DEV_BSIZE / fd_types[type].sectrac);

sys/arch/acorn32/mainbus/fd.c

1551

loop * fd_types[type].sectrac * DEV_BSIZE / 1024);

sys/arch/acorn32/mainbus/fd.c

1553

bp->b_bcount = fd_types[type].sectrac * DEV_BSIZE;

sys/arch/acorn32/mainbus/fd.c

1563

* DEV_BSIZE, (void *)bp->b_data,

sys/arch/acorn32/mainbus/fd.c

1564

fd_types[type].sectrac * DEV_BSIZE);

sys/arch/acorn32/mainbus/fd.c

1567

loop * fd_types[type].sectrac * DEV_BSIZE / 1024);

sys/arch/acorn32/mainbus/fd.c

604

bp->b_cylinder = bp->b_blkno / (FDC_BSIZE / DEV_BSIZE) / fd->sc_type->seccyl;

sys/arch/acorn32/mainbus/fd.c

950

fd->sc_blkno = bp->b_blkno / (FDC_BSIZE / DEV_BSIZE);

sys/arch/acorn32/stand/lib/riscosdisk.c

132

daddr = (dblk * DEV_BSIZE) | (rd->drive << 29);

sys/arch/acorn32/stand/lib/riscosdisk.c

144

daddr64.daddr = dblk * DEV_BSIZE;

sys/arch/acorn32/stand/lib/riscospart.c

156

buf = alloc(DEV_BSIZE);

sys/arch/acorn32/stand/lib/riscospart.c

158

FILECORE_BOOT_SECTOR, DEV_BSIZE, buf, &rsize);

sys/arch/acorn32/stand/lib/riscospart.c

173

labelsect, DEV_BSIZE, buf, &rsize);

sys/arch/acorn32/stand/lib/riscospart.c

182

dealloc(buf, DEV_BSIZE);

sys/arch/acorn32/stand/nbfs/nbfs.c

204

r->r2 = DEV_BSIZE;

sys/arch/alpha/alpha/disksubr.c

64

lp->d_secsize = DEV_BSIZE;

sys/arch/alpha/stand/common/blkdev.c

117

char *msg, buf[DEV_BSIZE];

sys/arch/alpha/stand/common/blkdev.c

134

(daddr_t)LABELSECTOR, DEV_BSIZE, buf, &cnt);

sys/arch/alpha/stand/common/blkdev.c

135

if (i || cnt != DEV_BSIZE) {

sys/arch/alpha/stand/common/blkdev.c

180

if (reqcnt & (DEV_BSIZE - 1)) {

sys/arch/amiga/amiga/disksubr.c

191

bp->b_blkno *= (lp->d_secsize / DEV_BSIZE);

sys/arch/amiga/amiga/disksubr.c

312

bp->b_blkno *= (lp->d_secsize / DEV_BSIZE);

sys/arch/arc/jazz/fd.c

470

bp->b_blkno / (FDC_BSIZE / DEV_BSIZE) / fd->sc_type->seccyl;

sys/arch/arc/jazz/fd.c

813

fd->sc_blkno = bp->b_blkno / (FDC_BSIZE / DEV_BSIZE);

sys/arch/arc/stand/boot/disk.c

105

char *msg, buf[DEV_BSIZE];

sys/arch/arc/stand/boot/disk.c

148

lp->d_secsize = DEV_BSIZE;

sys/arch/arc/stand/boot/disk.c

155

error = diskstrategy(sc, F_READ, (daddr_t)LABELSECTOR, DEV_BSIZE,

sys/arch/arc/stand/boot/disk.c

157

if (error || cnt != DEV_BSIZE) {

sys/arch/arc/stand/boot/disk.c

71

if (reqcnt & (DEV_BSIZE - 1)) {

sys/arch/arc/stand/boot/disk.c

84

offset *= DEV_BSIZE;

sys/arch/arm/arm/disksubr.c

138

lp->d_secsize = DEV_BSIZE;

sys/arch/arm/arm/disksubr.c

268

netbsdpartoff * DEV_BSIZE);

sys/arch/atari/atari/disksubr.c

86

lp->d_secsize = DEV_BSIZE;

sys/arch/atari/dev/hdfd.c

1411

form_parms->nbps / DEV_BSIZE;

sys/arch/atari/dev/hdfd.c

1497

+ finfo->head * type->sectrac) * FDC_BSIZE / DEV_BSIZE;

sys/arch/atari/dev/hdfd.c

642

bp->b_cylinder = bp->b_blkno / (FDC_BSIZE/DEV_BSIZE) / fd->sc_type->seccyl;

sys/arch/atari/dev/hdfd.c

986

fd->sc_blkno = bp->b_blkno / (FDC_BSIZE / DEV_BSIZE);

sys/arch/atari/dev/md_root.c

289

nbyte &= ~(DEV_BSIZE - 1);

sys/arch/atari/stand/ahdilabel/ahdilabel.c

43

#define BLPM ((1024 * 1024) / DEV_BSIZE)

sys/arch/atari/stand/ahdilabel/magic.c

45

nsec = (BBMINSIZE + (DEV_BSIZE - 1)) / DEV_BSIZE;

sys/arch/atari/stand/ahdilabel/read.c

202

size = count * DEV_BSIZE;

sys/arch/atari/stand/ahdilabel/read.c

203

offset = start * DEV_BSIZE;

sys/arch/atari/stand/ahdilabel/write.c

292

if ((bsl = malloc (sizeof (u_int8_t) * BSL_SIZE * DEV_BSIZE)) == NULL)

sys/arch/atari/stand/ahdilabel/write.c

294

bzero ((void *) bsl, sizeof (u_int8_t) * DEV_BSIZE);

sys/arch/atari/stand/ahdilabel/write.c

318

nsec = (BBMINSIZE + (DEV_BSIZE - 1)) / DEV_BSIZE;

sys/arch/atari/stand/ahdilabel/write.c

352

size = count * DEV_BSIZE;

sys/arch/atari/stand/ahdilabel/write.c

353

offset = start * DEV_BSIZE;

sys/arch/atari/stand/edahdi/edahdi.c

340

nsec = (BBMINSIZE + (DEV_BSIZE - 1)) / DEV_BSIZE;

sys/arch/atari/stand/edahdi/edahdi.c

462

size = count * DEV_BSIZE;

sys/arch/atari/stand/edahdi/edahdi.c

463

offset = start * DEV_BSIZE;

sys/arch/atari/stand/edahdi/edahdi.c

524

size = count * DEV_BSIZE;

sys/arch/atari/stand/edahdi/edahdi.c

525

offset = start * DEV_BSIZE;

sys/arch/atari/stand/edahdi/edahdi.c

79

#define BLPM ((1024 * 1024) / DEV_BSIZE)

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

313

blknum = (u_long)blk * DEV_BSIZE/FDBLK + fd_skip/FDBLK;

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

86

memcpy(buf, (char *)KERNENTRY + blk * DEV_BSIZE, size);

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

196

dp->disksize512 = (dp->disksize * dp->blksize) / DEV_BSIZE;

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

271

dp->disksize512 = (blocks * dp->blksize) / DEV_BSIZE;

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

505

uint8_t buf[DEV_BSIZE];

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

518

if (sdstrategy(sd, F_READ, MBR_BBSECTOR, DEV_BSIZE, buf, &rsize))

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

536

if (sdstrategy(sd, F_READ, sector + LABELSECTOR, DEV_BSIZE,

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

128

lp->d_secsize = DEV_BSIZE;

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

151

lp->d_secperunit * (lp->d_secsize / DEV_BSIZE);

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

172

uint8_t buf[DEV_BSIZE];

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

180

if (wdstrategy(wd, F_READ, MBR_BBSECTOR, DEV_BSIZE, buf, &rsize))

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

198

if (wdstrategy(wd, F_READ, sector + LABELSECTOR, DEV_BSIZE,

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

65

uint8_t buf[DEV_BSIZE];

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

153

uint8_t ident[DEV_BSIZE];

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

361

wd_c.bcount = DEV_BSIZE;

sys/arch/cesfic/include/disklabel.h

37

#define LABELSECTOR (1024 / DEV_BSIZE) /* sector containing label */

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

116

lp->d_secsize = DEV_BSIZE;

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

139

lp->d_secperunit * (lp->d_secsize / DEV_BSIZE);

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

158

uint8_t buf[DEV_BSIZE];

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

167

if (wdstrategy(wd, F_READ, MBR_BBSECTOR, DEV_BSIZE, buf, &rsize))

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

188

if (wdstrategy(wd, F_READ, sector + LABELSECTOR, DEV_BSIZE,

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

55

uint8_t buf[DEV_BSIZE];

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

311

wd_c.bcount = DEV_BSIZE;

sys/arch/dreamcast/dev/g1/gdrom.c

446

bp->b_rawblkno = bp->b_blkno / (2048 / DEV_BSIZE) + sc->openpart_start;

sys/arch/dreamcast/dev/gdrom.c

512

bp->b_rawblkno = bp->b_blkno / (2048 / DEV_BSIZE) + sc->openpart_start;

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

727

off = bp->b_blkno * DEV_BSIZE / sc->sc_bsize;

sys/arch/emips/ebus/ace_ebus.c

1624

format_bytes(pbuf, sizeof(pbuf), ace->sc_capacity * DEV_BSIZE);

sys/arch/emips/ebus/ace_ebus.c

1633

DEV_BSIZE, (unsigned long long)ace->sc_capacity);

sys/arch/emips/ebus/ace_ebus.c

1754

if (bounds_check_with_mediasize(bp, DEV_BSIZE,

sys/arch/emips/ebus/ace_ebus.c

1767

if (lp->d_secsize >= DEV_BSIZE)

sys/arch/emips/ebus/ace_ebus.c

1768

blkno = bp->b_blkno / (lp->d_secsize / DEV_BSIZE);

sys/arch/emips/ebus/ace_ebus.c

1770

blkno = bp->b_blkno * (DEV_BSIZE / lp->d_secsize);

sys/arch/emips/ebus/ace_ebus.c

2054

lp->d_secsize = DEV_BSIZE;

sys/arch/emips/ebus/ace_ebus.c

2076

lp->d_secperunit * (lp->d_secsize / DEV_BSIZE);

sys/arch/emips/ebus/ace_ebus.c

2298

(ace->sc_dk.dk_label->d_secsize / DEV_BSIZE);

sys/arch/emips/ebus/ace_ebus.c

2335

blkno = blkno / (lp->d_secsize / DEV_BSIZE);

sys/arch/emips/ebus/ace_ebus.c

2389

dg->dg_secsize = DEV_BSIZE /* XXX 512? */;

sys/arch/emips/ebus/flash_ebus.c

1443

format_bytes(pbuf, sizeof(pbuf), sc->sc_capacity * DEV_BSIZE);

sys/arch/emips/ebus/flash_ebus.c

1446

DEV_BSIZE, (unsigned long long)sc->sc_capacity);

sys/arch/emips/ebus/flash_ebus.c

1596

size_t sz = DEV_BSIZE, bnow;

sys/arch/emips/ebus/flash_ebus.c

1679

if (bounds_check_with_mediasize(bp, DEV_BSIZE,

sys/arch/emips/ebus/flash_ebus.c

1692

if (lp->d_secsize >= DEV_BSIZE)

sys/arch/emips/ebus/flash_ebus.c

1693

blkno = bp->b_blkno / (lp->d_secsize / DEV_BSIZE);

sys/arch/emips/ebus/flash_ebus.c

1695

blkno = bp->b_blkno * (DEV_BSIZE / lp->d_secsize);

sys/arch/emips/ebus/flash_ebus.c

1972

lp->d_secsize = DEV_BSIZE;

sys/arch/emips/ebus/flash_ebus.c

1992

lp->d_secperunit * (lp->d_secsize / DEV_BSIZE);

sys/arch/emips/ebus/flash_ebus.c

2193

(sc->sc_dk.dk_label->d_secsize / DEV_BSIZE);

sys/arch/emips/ebus/flash_ebus.c

2217

dg->dg_secsize = DEV_BSIZE /* XXX 512? */;

sys/arch/emips/ebus/flash_ebus.c

277

sc->sc_capacity = sc->sc_size / DEV_BSIZE;

sys/arch/emips/stand/common/ace.c

626

char buf[DEV_BSIZE];

sys/arch/emips/stand/common/ace.c

665

lp->d_secsize = DEV_BSIZE;

sys/arch/emips/stand/common/ace.c

671

i = acestrategy(sc, F_READ, (daddr_t)LABELSECTOR, DEV_BSIZE, buf, &cnt);

sys/arch/emips/stand/common/ace.c

672

if (i || cnt != DEV_BSIZE) {

sys/arch/emips/stand/common/ace.c

724

if (reqcnt & (DEV_BSIZE - 1)) {

sys/arch/emips/stand/common/raw.c

118

er = acestrategy(f->f_devdata, F_READ, start_sector, DEV_BSIZE * sector_count,

sys/arch/evbarm/smdk2xx0/smdk2410_machdep.c

411

#define MD_ROOT_SIZE (MEMORY_DISK_ROOT_SIZE * DEV_BSIZE)

sys/arch/evbarm/smdk2xx0/smdk2800_machdep.c

352

#define MD_ROOT_SIZE (MEMORY_DISK_ROOT_SIZE * DEV_BSIZE)

sys/arch/evbarm/stand/boot2440/dev_sdmmc.c

254

uint8_t buf[DEV_BSIZE];

sys/arch/evbarm/stand/boot2440/dev_sdmmc.c

260

if (sdmmc_strategy(&sc->partitions[0], F_READ, MBR_BBSECTOR, DEV_BSIZE,

sys/arch/evbarm/stand/boot2440/dev_sdmmc.c

274

lp->d_secsize = DEV_BSIZE;

sys/arch/evbarm/stand/boot2440/dev_sdmmc.c

291

lp->d_secperunit * (lp->d_secsize / DEV_BSIZE);

sys/arch/evbarm/stand/boot2440/dev_sdmmc.c

327

sector + LABELSECTOR, DEV_BSIZE,

sys/arch/evbmips/evbmips/disksubr.c

60

lp->d_secsize = DEV_BSIZE;

sys/arch/evbmips/sbmips/disksubr.c

107

lp->d_secsize = DEV_BSIZE;

sys/arch/evbmips/stand/sbmips/common/blkdev.c

107

char *msg, buf[DEV_BSIZE];

sys/arch/evbmips/stand/sbmips/common/blkdev.c

126

(daddr_t)LABELSECTOR, DEV_BSIZE, buf, &cnt);

sys/arch/evbmips/stand/sbmips/common/blkdev.c

127

if (i || cnt != DEV_BSIZE) {

sys/arch/evbmips/stand/sbmips/common/blkdev.c

164

if (reqcnt & (DEV_BSIZE - 1)) {

sys/arch/evbmips/stand/sbmips/common/blkdev.c

168

res = cfe_readblk(booted_dev_fd,(bn+blkdev_part_offset)*DEV_BSIZE,addr,reqcnt);

sys/arch/evbppc/evbppc/disksubr.c

69

lp->d_secsize = DEV_BSIZE;

sys/arch/ews4800mips/ews4800mips/disklabel_conv.c

112

pdinfo->ux.errorlog_size_byte = DEV_BSIZE;

sys/arch/ews4800mips/ews4800mips/disklabel_conv.c

126

pdinfo->geometory.bytes_per_sector = DEV_BSIZE;

sys/arch/ews4800mips/ews4800mips/disklabel_conv.c

137

vtoc->sector_size_byte = DEV_BSIZE;

sys/arch/ews4800mips/ews4800mips/disklabel_conv.c

84

d->d_secsize = DEV_BSIZE;

sys/arch/ews4800mips/ews4800mips/disksubr.c

121

uint8_t buf[DEV_BSIZE];

sys/arch/ews4800mips/ews4800mips/disksubr.c

55

uint8_t buf[DEV_BSIZE];

sys/arch/ews4800mips/ews4800mips/sector.c

101

memcpy(buf, b->b_data, DEV_BSIZE);

sys/arch/ews4800mips/ews4800mips/sector.c

114

buf += DEV_BSIZE;

sys/arch/ews4800mips/ews4800mips/sector.c

129

b->b_bcount = DEV_BSIZE;

sys/arch/ews4800mips/ews4800mips/sector.c

133

memcpy(b->b_data, buf, DEV_BSIZE);

sys/arch/ews4800mips/ews4800mips/sector.c

55

rw->buf = geteblk(DEV_BSIZE);

sys/arch/ews4800mips/ews4800mips/sector.c

78

buf += DEV_BSIZE;

sys/arch/ews4800mips/ews4800mips/sector.c

93

b->b_bcount = DEV_BSIZE;

sys/arch/ews4800mips/stand/common/bfs_subr.c

71

static uint8_t buf[DEV_BSIZE];

sys/arch/ews4800mips/stand/common/bootfs.c

114

n = TRUNC_SECTOR(cur) + DEV_BSIZE - cur;

sys/arch/ews4800mips/stand/common/bootfs.c

116

memcpy(p, file->buf + DEV_BSIZE - n, size);

sys/arch/ews4800mips/stand/common/bootfs.c

119

memcpy(p, file->buf + DEV_BSIZE - n, n);

sys/arch/ews4800mips/stand/common/bootfs.c

125

p += (end - start - 1) * DEV_BSIZE;

sys/arch/ews4800mips/stand/common/bootfs.c

54

uint8_t buf[DEV_BSIZE];

sys/arch/ews4800mips/stand/common/bootxx.c

124

sector_init("/dev/rsd1p", DEV_BSIZE);

sys/arch/ews4800mips/stand/common/disk.c

250

buf += DEV_BSIZE * cnt;

sys/arch/ews4800mips/stand/common/disk.c

277

buf += DEV_BSIZE * cnt;

sys/arch/ews4800mips/stand/common/ustarfs.c

149

buf += cnt * DEV_BSIZE;

sys/arch/hp300/dev/rd.c

1382

lp->d_secsize = DEV_BSIZE;

sys/arch/hp300/dev/rd.c

1398

lp->d_secperunit * (lp->d_secsize / DEV_BSIZE);

sys/arch/hp300/dev/rd.c

1431

(sc->sc_dkdev.dk_label->d_secsize / DEV_BSIZE);

sys/arch/hp300/dev/rd.c

521

rdidentinfo[id].ri_nblocks * DEV_BSIZE);

sys/arch/hp300/dev/rd.c

526

DEV_BSIZE, rdidentinfo[id].ri_nblocks);

sys/arch/hp300/dev/rd.c

755

dg->dg_secsize = DEV_BSIZE;

sys/arch/hp300/dev/rd.c

914

if (bounds_check_with_mediasize(bp, DEV_BSIZE,

sys/arch/hp300/dev/spc.c

220

if ((len & (DEV_BSIZE - 1)) != 0) /* XXX ??? */ {

sys/arch/hp300/stand/common/rawfs.c

198

fs->fs_nextblk += (RAWFS_BSIZE / DEV_BSIZE);

sys/arch/hp300/stand/common/rd.c

225

lp->d_secsize = DEV_BSIZE;

sys/arch/hp300/stand/common/rd.c

231

lp->d_secsize ? lp->d_secsize : DEV_BSIZE, io_buf, &i);

sys/arch/hp300/stand/common/sd.c

128

if (capbuf[1] > DEV_BSIZE)

sys/arch/hp300/stand/common/sd.c

129

for (; capbuf[1] > DEV_BSIZE; capbuf[1] >>= 1)

sys/arch/hp300/stand/common/sd.c

148

lp->d_secsize = (DEV_BSIZE << ss->sc_blkshift);

sys/arch/hp300/stand/common/sd.c

154

lp->d_secsize ? lp->d_secsize : DEV_BSIZE, io_buf, &i);

sys/arch/hp300/stand/inst/inst.c

167

char block[DEV_BSIZE], diskname[64];

sys/arch/hp300/stand/inst/inst.c

205

char zap[DEV_BSIZE];

sys/arch/hp300/stand/inst/inst.c

550

char block[DEV_BSIZE];

sys/arch/hp300/stand/inst/inst.c

639

printf("Copy how many %d byte blocks? ", DEV_BSIZE);

sys/arch/hpc/hpc/disksubr.c

137

lp->d_secsize = DEV_BSIZE;

sys/arch/hppa/hppa/disksubr.c

166

lp->d_secsize = DEV_BSIZE;

sys/arch/hppa/stand/common/dk.c

44

char buf[DEV_BSIZE];

sys/arch/hppa/stand/common/dk.c

47

if (iodcstrategy(dp, F_READ, LABELSECTOR, DEV_BSIZE, buf, &ret) ||

sys/arch/hppa/stand/common/dk.c

48

ret != DEV_BSIZE)

sys/arch/hppa/stand/common/lif.c

163

char bbuf[DEV_BSIZE];

sys/arch/i386/stand/lib/biosdisk.c

195

#define devb2cdb(bno) (((bno) * DEV_BSIZE) / ISO_DEFAULT_BLOCK_SIZE)

sys/arch/luna68k/stand/boot/disklabel.c

202

bp->d_secsize = DEV_BSIZE;

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

115

if (sc->sc_blksize != DEV_BSIZE) {

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

116

if (sc->sc_blksize < DEV_BSIZE) {

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

119

for (i = sc->sc_blksize; i > DEV_BSIZE; i >>= 1)

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

155

lp->d_secsize = DEV_BSIZE;

sys/arch/luna68k/stand/boot/ufs_disksubr.c

112

if (scsi_immed_command(ctlr, id, 0, &cdb, bp, DEV_BSIZE) != 0) {

sys/arch/luna68k/stand/boot/ufs_disksubr.c

116

dlp <= (struct disklabel *)(bp + DEV_BSIZE - sizeof(*dlp));

sys/arch/mac68k/mac68k/disksubr.c

266

part = (struct part_map_entry *)(dlbuf + DEV_BSIZE);

sys/arch/macppc/macppc/disksubr.c

583

bp->b_cylinder = bp->b_blkno / (lp->d_secsize / DEV_BSIZE) / lp->d_secpercyl;

sys/arch/macppc/macppc/disksubr.c

690

|| (nlp->d_secsize % DEV_BSIZE) != 0)

sys/arch/macppc/macppc/disksubr.c

732

bp->b_cylinder = bp->b_blkno / (lp->d_secsize / DEV_BSIZE) / lp->d_secpercyl;

sys/arch/macppc/stand/ofwboot/ofdev.c

197

if (strategy(devp, F_READ, blkno, DEV_BSIZE, pme, &nread)

sys/arch/macppc/stand/ofwboot/ofdev.c

198

|| nread != DEV_BSIZE)

sys/arch/macppc/stand/ofwboot/ofdev.c

244

if (strategy(devp, F_READ, off, DEV_BSIZE, buf, &nread)

sys/arch/macppc/stand/ofwboot/ofdev.c

245

|| nread != DEV_BSIZE)

sys/arch/macppc/stand/ofwboot/ofdev.c

264

DEV_BSIZE, buf, &nread) == 0

sys/arch/macppc/stand/ofwboot/ofdev.c

265

&& nread == DEV_BSIZE) {

sys/arch/macppc/stand/ofwboot/ofdev.c

271

if (strategy(devp, F_READ, off, DEV_BSIZE, buf, &nread)

sys/arch/macppc/stand/ofwboot/ofdev.c

272

|| nread != DEV_BSIZE) {

sys/arch/macppc/stand/ofwboot/ofdev.c

282

if (strategy(devp, F_READ, off, DEV_BSIZE, buf, &nread)

sys/arch/macppc/stand/ofwboot/ofdev.c

283

|| nread != DEV_BSIZE) {

sys/arch/macppc/stand/ofwboot/ofdev.c

387

char buf[DEV_BSIZE];

sys/arch/macppc/stand/ofwboot/ofdev.c

445

ofdev.bsize = DEV_BSIZE;

sys/arch/macppc/stand/ofwboot/ofdev.c

449

LABELSECTOR, DEV_BSIZE, buf, &nread) != 0

sys/arch/macppc/stand/ofwboot/ofdev.c

450

|| nread != DEV_BSIZE

sys/arch/mipsco/stand/common/saio.c

111

offset = bn * DEV_BSIZE;

sys/arch/mipsco/stand/common/saio.c

117

if (reqcnt & (DEV_BSIZE - 1)) {

sys/arch/mipsco/stand/common/saio.c

120

offset += pp->p_offset * DEV_BSIZE;

sys/arch/mipsco/stand/common/saio.c

152

char buf[DEV_BSIZE];

sys/arch/mipsco/stand/common/saio.c

186

lp->d_secsize = DEV_BSIZE;

sys/arch/mipsco/stand/common/saio.c

192

i = saiostrategy(sc, F_READ, (daddr_t)LABELSECTOR, DEV_BSIZE, buf, &cnt);

sys/arch/mipsco/stand/common/saio.c

193

if (i || cnt != DEV_BSIZE) {

sys/arch/mipsco/stand/installboot/installboot.c

180

boot_size = roundup(bootstrapsb.st_size, DEV_BSIZE);

sys/arch/mipsco/stand/installboot/installboot.c

243

len = pread(vfd, vhp, sizeof(*vhp), MIPS_VHSECTOR*DEV_BSIZE);

sys/arch/mipsco/stand/installboot/installboot.c

51

#define BOOTBLOCK_OFFSET BOOTBLOCK_NUMBER*DEV_BSIZE

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

113

lp->d_secsize = DEV_BSIZE;

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

136

lp->d_secperunit * (lp->d_secsize / DEV_BSIZE);

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

161

uint8_t buf[DEV_BSIZE];

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

165

if (wdstrategy(wd, F_READ, LABELSECTOR, DEV_BSIZE, buf, &rsize))

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

53

uint8_t buf[DEV_BSIZE];

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

348

wd_c.bcount = DEV_BSIZE;

sys/arch/mvme68k/stand/bootst/rawfs.c

226

fs->fs_nextblk * (RAWFS_BSIZE / DEV_BSIZE),

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

140

if (protosize & (DEV_BSIZE - 1))

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

157

if (protosize > SBLOCKSIZE - DEV_BSIZE)

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

166

if (lseek(devfd, DEV_BSIZE, SEEK_SET) != DEV_BSIZE)

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

197

*size = roundup(marks[MARK_END] - marks[MARK_START], DEV_BSIZE);

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

279

devread(devfd, sblock, (daddr_t)(BBSIZE / DEV_BSIZE),

sys/arch/mvme68k/stand/libsa/bugdev.c

58

static int iobuf[DEV_BSIZE / sizeof(int)];

sys/arch/mvme68k/stand/libsa/bugdev.c

96

error = bugscstrategy(pp, F_READ, LABELSECTOR, DEV_BSIZE, iobuf, &nrd);

sys/arch/mvme68k/stand/libsa/bugdev.c

99

if (nrd != DEV_BSIZE)

sys/arch/newsmips/dev/scsi_1185.c

1518

i = (cs->act_trcnt + DEV_BSIZE -1) / DEV_BSIZE;

sys/arch/newsmips/dev/scsi_1185.c

1519

i *= DEV_BSIZE;

sys/arch/newsmips/newsmips/disksubr.c

64

lp->d_secsize = DEV_BSIZE;

sys/arch/newsmips/newsmips/disksubr.c

90

dlp <= (struct disklabel *)((char *)bp->b_data + DEV_BSIZE -

sys/arch/next68k/next68k/disksubr.c

323

lp->d_secsize = DEV_BSIZE;

sys/arch/next68k/next68k/disksubr.c

381

DEV_BSIZE - sizeof(*dlp));

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

138

blklen = DEV_BSIZE;

sys/arch/ofppc/ofppc/disksubr.c

281

bp->b_blkno *= (lp->d_secsize / DEV_BSIZE);

sys/arch/ofppc/ofppc/disksubr.c

387

bp->b_blkno *= (lp->d_secsize / DEV_BSIZE);

sys/arch/ofppc/ofppc/disksubr.c

689

bp->b_cylinder = bp->b_blkno / (lp->d_secsize / DEV_BSIZE) / lp->d_secpercyl;

sys/arch/ofppc/ofppc/disksubr.c

815

bp->b_cylinder = bp->b_blkno / (lp->d_secsize / DEV_BSIZE) /

sys/arch/ofppc/stand/ofwboot/mbr.c

103

if (strategy(devp, F_READ, off, DEV_BSIZE, buf, &read)

sys/arch/ofppc/stand/ofwboot/mbr.c

104

|| read != DEV_BSIZE)

sys/arch/ofppc/stand/ofwboot/mbr.c

126

if (strategy(devp, F_READ, off, DEV_BSIZE, buf, &read)

sys/arch/ofppc/stand/ofwboot/mbr.c

127

|| read != DEV_BSIZE) {

sys/arch/ofppc/stand/ofwboot/mbr.c

73

if (strategy(devp, F_READ, poff + LABELSECTOR, DEV_BSIZE,

sys/arch/ofppc/stand/ofwboot/mbr.c

74

buf, &read) == 0 && read == DEV_BSIZE)

sys/arch/ofppc/stand/ofwboot/ofdev.c

201

char buf[DEV_BSIZE<<7];

sys/arch/ofppc/stand/ofwboot/ofdev.c

262

ofdev.bsize = DEV_BSIZE;

sys/arch/ofppc/stand/ofwboot/ofdev.c

274

DEV_BSIZE, buf, &read);

sys/arch/ofppc/stand/ofwboot/ofdev.c

275

if (error == 0 && read != DEV_BSIZE)

sys/arch/ofppc/stand/ofwboot/rdb.c

135

if (strategy(devp, F_READ, blk, DEV_BSIZE, buf, &read)

sys/arch/ofppc/stand/ofwboot/rdb.c

136

|| read != DEV_BSIZE)

sys/arch/ofppc/stand/ofwboot/rdb.c

193

if (strategy(devp, F_READ, blk * (lp->d_secsize / DEV_BSIZE),

sys/arch/playstation2/playstation2/disksubr.c

107

lp->d_secsize = DEV_BSIZE;

sys/arch/pmax/pmax/disksubr.c

143

((char *)bp->b_data + DEV_BSIZE - sizeof(*dlp));

sys/arch/pmax/pmax/disksubr.c

86

((char *)bp->b_data + DEV_BSIZE - sizeof(*dlp));

sys/arch/pmax/stand/common/rz.c

111

char buf[DEV_BSIZE];

sys/arch/pmax/stand/common/rz.c

152

lp->d_secsize = DEV_BSIZE;

sys/arch/pmax/stand/common/rz.c

158

i = rzstrategy(sc, F_READ, (daddr_t)LABELSECTOR, DEV_BSIZE, buf, &cnt);

sys/arch/pmax/stand/common/rz.c

159

if (i || cnt != DEV_BSIZE) {

sys/arch/pmax/stand/common/rz.c

73

if (reqcnt & (DEV_BSIZE - 1)) {

sys/arch/pmax/stand/common/rz.c

86

offset *= DEV_BSIZE;

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

79

memcpy(buf, (char *)KERNENTRY + ((long)blk * DEV_BSIZE), size);

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

196

dp->disksize512 = (dp->disksize * dp->blksize) / DEV_BSIZE;

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

271

dp->disksize512 = (blocks * dp->blksize) / DEV_BSIZE;

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

505

uint8_t buf[DEV_BSIZE];

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

518

if (sdstrategy(sd, F_READ, MBR_BBSECTOR, DEV_BSIZE, buf, &rsize))

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

536

if (sdstrategy(sd, F_READ, sector + LABELSECTOR, DEV_BSIZE,

sys/arch/prep/stand/installboot/installboot.c

133

char buf[DEV_BSIZE];

sys/arch/prep/stand/installboot/installboot.c

145

if (read(fd, buf, DEV_BSIZE) != DEV_BSIZE) {

sys/arch/prep/stand/installboot/installboot.c

155

if ((bp = (char *)calloc(roundup(imgsz, DEV_BSIZE), 1)) == NULL) {

sys/arch/prep/stand/installboot/installboot.c

169

*bootsize = roundup(imgsz, DEV_BSIZE);

sys/arch/prep/stand/installboot/installboot.c

189

if (devread(devfd, mbr, MBR_BBSECTOR, DEV_BSIZE, "MBR") != 0)

sys/arch/prep/stand/installboot/installboot.c

302

if (devread(devfd, boot00, 1, DEV_BSIZE, "start/size") != 0)

sys/arch/rs6000/stand/boot/inkernel.c

85

memcpy(buf, (char *)KERNENTRY + ((long)blk * DEV_BSIZE), size);

sys/arch/sbmips/sbmips/disksubr.c

107

lp->d_secsize = DEV_BSIZE;

sys/arch/sbmips/stand/common/blkdev.c

107

char *msg, buf[DEV_BSIZE];

sys/arch/sbmips/stand/common/blkdev.c

126

(daddr_t)LABELSECTOR, DEV_BSIZE, buf, &cnt);

sys/arch/sbmips/stand/common/blkdev.c

127

if (i || cnt != DEV_BSIZE) {

sys/arch/sbmips/stand/common/blkdev.c

164

if (reqcnt & (DEV_BSIZE - 1)) {

sys/arch/sbmips/stand/common/blkdev.c

168

res = cfe_readblk(booted_dev_fd,(bn+blkdev_part_offset)*DEV_BSIZE,addr,reqcnt);

sys/arch/sgimips/sgimips/disksubr.c

254

if (lp->d_secsize > DEV_BSIZE)

sys/arch/sgimips/sgimips/disksubr.c

255

lpp->p_offset /= lp->d_secsize / DEV_BSIZE;

sys/arch/sgimips/sgimips/disksubr.c

83

lp->d_secsize = DEV_BSIZE;

sys/arch/sgimips/stand/common/disk.c

105

char *msg, buf[DEV_BSIZE];

sys/arch/sgimips/stand/common/disk.c

148

lp->d_secsize = DEV_BSIZE;

sys/arch/sgimips/stand/common/disk.c

155

error = diskstrategy(sc, F_READ, (daddr_t)LABELSECTOR, DEV_BSIZE,

sys/arch/sgimips/stand/common/disk.c

157

if (error || cnt != DEV_BSIZE) {

sys/arch/sgimips/stand/common/disk.c

71

if (reqcnt & (DEV_BSIZE - 1)) {

sys/arch/sgimips/stand/common/disk.c

84

offset *= DEV_BSIZE;

sys/arch/sgimips/stand/common/iris_disk.c

166

if (capbuf[1] > DEV_BSIZE)

sys/arch/sgimips/stand/common/iris_disk.c

167

for (; capbuf[1] > DEV_BSIZE; capbuf[1] >>= 1)

sys/arch/sgimips/stand/common/iris_disk.c

181

char *msg, buf[DEV_BSIZE];

sys/arch/sgimips/stand/common/iris_disk.c

199

lp->d_secsize = DEV_BSIZE;

sys/arch/sgimips/stand/common/iris_disk.c

205

error = diskstrategy(sc, F_READ, (daddr_t)LABELSECTOR, DEV_BSIZE, buf,

sys/arch/sgimips/stand/common/iris_disk.c

208

if (error || cnt != DEV_BSIZE) {

sys/arch/sh3/sh3/disksubr.c

317

lp->d_secsize = DEV_BSIZE;

sys/arch/shark/stand/ofwboot/ofdev.c

194

if (strategy(devp, F_READ, off, DEV_BSIZE, buf, &nread)

sys/arch/shark/stand/ofwboot/ofdev.c

195

|| nread != DEV_BSIZE)

sys/arch/shark/stand/ofwboot/ofdev.c

214

DEV_BSIZE, buf, &nread) == 0

sys/arch/shark/stand/ofwboot/ofdev.c

215

&& nread == DEV_BSIZE) {

sys/arch/shark/stand/ofwboot/ofdev.c

221

if (strategy(devp, F_READ, off, DEV_BSIZE, buf, &nread)

sys/arch/shark/stand/ofwboot/ofdev.c

222

|| nread != DEV_BSIZE) {

sys/arch/shark/stand/ofwboot/ofdev.c

232

if (strategy(devp, F_READ, off, DEV_BSIZE, buf, &nread)

sys/arch/shark/stand/ofwboot/ofdev.c

233

|| nread != DEV_BSIZE) {

sys/arch/shark/stand/ofwboot/ofdev.c

249

char buf[DEV_BSIZE];

sys/arch/shark/stand/ofwboot/ofdev.c

300

ofdev.bsize = DEV_BSIZE;

sys/arch/shark/stand/ofwboot/ofdev.c

303

LABELSECTOR, DEV_BSIZE, buf, &nread) != 0

sys/arch/shark/stand/ofwboot/ofdev.c

304

|| nread != DEV_BSIZE

sys/arch/sparc/dev/fd.c

1482

fd->sc_blkno = (bp->b_blkno * DEV_BSIZE) / FD_BSIZE(fd);

sys/arch/sparc/dev/fd.c

2088

form_parms->nbps / DEV_BSIZE;

sys/arch/sparc/dev/fd.c

2202

/ DEV_BSIZE;

sys/arch/sparc/dev/fd.c

2373

bp->b_bcount = DEV_BSIZE;

sys/arch/sparc/dev/fd.c

2383

addr = (char *)addr + DEV_BSIZE;

sys/arch/sparc/dev/fd.c

2384

offset += DEV_BSIZE;

sys/arch/sparc/dev/fd.c

2385

if (offset + DEV_BSIZE > FDMICROROOTSIZE)

sys/arch/sparc/dev/fd.c

865

(bp->b_blkno * DEV_BSIZE) % FD_BSIZE(fd) != 0) &&

sys/arch/sparc/dev/fd.c

875

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

sys/arch/sparc/dev/fd.c

877

if (bp->b_blkno + sz > (fd->sc_type->size * DEV_BSIZE) / FD_BSIZE(fd)) {

sys/arch/sparc/dev/fd.c

878

sz = (fd->sc_type->size * DEV_BSIZE) / FD_BSIZE(fd)

sys/arch/sparc/dev/fd.c

895

bp->b_cylinder = (bp->b_blkno * DEV_BSIZE) /

sys/arch/sparc/sparc/pmap.c

7675

return btodb(sz + DEV_BSIZE - 1);

sys/arch/sparc/stand/common/promdev.c

143

while (x < DEV_BSIZE) {

sys/arch/sparc/stand/common/promdev.c

296

char labelbuf[DEV_BSIZE];

sys/arch/sparc/stand/common/promdev.c

316

prom_bread(fd, btodb(DEV_BSIZE), LABELSECTOR, &labelbuf[0]);

sys/arch/sparc/stand/common/promdev.c

344

char labelbuf[DEV_BSIZE];

sys/arch/sparc/stand/common/promdev.c

355

prom_read(fd, &labelbuf[0], DEV_BSIZE);

sys/arch/sparc/stand/common/promdev.c

391

char labelbuf[DEV_BSIZE];

sys/arch/sparc/stand/common/promdev.c

407

dmabuf = dvma_mapin(&labelbuf[0], DEV_BSIZE);

sys/arch/sparc/stand/common/promdev.c

409

si->si_cc = DEV_BSIZE;

sys/arch/sparc/stand/common/promdev.c

412

dvma_mapout(dmabuf, DEV_BSIZE);

sys/arch/sparc/stand/ofwboot/ofdev.c

341

if (strategy(devp, F_READ, LABELSECTOR, DEV_BSIZE, buf, &readsize)

sys/arch/sparc/stand/ofwboot/ofdev.c

342

|| readsize != DEV_BSIZE)

sys/arch/sparc/stand/ofwboot/ofdev.c

360

memset(buf, 0, DEV_BSIZE);

sys/arch/sparc/stand/ofwboot/ofdev.c

434

char buf[DEV_BSIZE];

sys/arch/sparc/stand/ofwboot/ofdev.c

539

ofdev.bsize = DEV_BSIZE;

sys/arch/sparc/stand/ofwboot/ofdev.c

543

LABELSECTOR, DEV_BSIZE, b.buf, &readsize) != 0

sys/arch/sparc/stand/ofwboot/ofdev.c

544

|| readsize != DEV_BSIZE

sys/arch/sparc64/dev/fdc.c

1042

(bp->b_blkno * DEV_BSIZE) % FD_BSIZE(fd) != 0) &&

sys/arch/sparc64/dev/fdc.c

1052

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

sys/arch/sparc64/dev/fdc.c

1054

if (bp->b_blkno + sz > (fd->sc_type->size * DEV_BSIZE) / FD_BSIZE(fd)) {

sys/arch/sparc64/dev/fdc.c

1055

sz = (fd->sc_type->size * DEV_BSIZE) / FD_BSIZE(fd)

sys/arch/sparc64/dev/fdc.c

1072

bp->b_cylinder = (bp->b_blkno * DEV_BSIZE) /

sys/arch/sparc64/dev/fdc.c

1665

fd->sc_blkno = (bp->b_blkno * DEV_BSIZE) / FD_BSIZE(fd);

sys/arch/sparc64/dev/fdc.c

2271

form_parms->nbps / DEV_BSIZE;

sys/arch/sparc64/dev/fdc.c

2385

/ DEV_BSIZE;

sys/arch/sparc64/dev/fdc.c

2561

bp->b_bcount = DEV_BSIZE;

sys/arch/sparc64/dev/fdc.c

2571

addr += DEV_BSIZE;

sys/arch/sparc64/dev/fdc.c

2572

offset += DEV_BSIZE;

sys/arch/sparc64/dev/fdc.c

2573

if (offset + DEV_BSIZE > FDMICROROOTSIZE)

sys/arch/sparc64/dev/vdsk.c

857

ai.vdisk_block_size = DEV_BSIZE;

sys/arch/sparc64/dev/vdsk.c

858

ai.max_xfer_sz = MAXPHYS / DEV_BSIZE;

sys/arch/sparc64/sparc64/pmap.c

2366

return btodb(sz + DEV_BSIZE - 1);

sys/arch/sun3/dev/fd.c

1208

fd->sc_blkno = bp->b_blkno / (FDC_BSIZE / DEV_BSIZE);

sys/arch/sun3/dev/fd.c

1716

form_parms->nbps / DEV_BSIZE;

sys/arch/sun3/dev/fd.c

1847

+ finfo->head * type->sectrac) * FDC_BSIZE / DEV_BSIZE;

sys/arch/sun3/dev/fd.c

2003

bp->b_bcount = DEV_BSIZE;

sys/arch/sun3/dev/fd.c

2013

addr += DEV_BSIZE;

sys/arch/sun3/dev/fd.c

2014

offset += DEV_BSIZE;

sys/arch/sun3/dev/fd.c

2015

if (offset + DEV_BSIZE > FDMICROROOTSIZE)

sys/arch/sun3/dev/fd.c

698

bp->b_blkno / (FDC_BSIZE / DEV_BSIZE) / fd->sc_type->seccyl;

sys/arch/sun3/dev/xd.c

1029

(xdsc->sc_dk.dk_label->d_secsize / DEV_BSIZE);

sys/arch/sun3/dev/xy.c

1042

blkno = bp->b_blkno / (lp->d_secsize / DEV_BSIZE);

sys/arch/sun3/dev/xy.c

983

(xysc->sc_dk.dk_label->d_secsize / DEV_BSIZE);

sys/arch/sun68k/stand/tapeboot/rawfs.c

214

fs->fs_nextblk += (RAWFS_BSIZE / DEV_BSIZE);

sys/arch/vax/boot/boot/hp.c

56

static char io_buf[DEV_BSIZE];

sys/arch/vax/boot/boot/hp.c

95

err = hpstrategy(0, F_READ, LABELSECTOR, DEV_BSIZE, io_buf, &i);

sys/arch/vax/boot/boot/mfm.c

374

err = mfmstrategy(msc, F_READ, LABELSECTOR, DEV_BSIZE, io_buf, &i);

sys/arch/vax/boot/boot/mfm.c

69

static char io_buf[DEV_BSIZE];

sys/arch/vax/boot/boot/ra.c

201

err = rastrategy(0, F_READ, LABELSECTOR, DEV_BSIZE, io_buf, &i);

sys/arch/vax/boot/boot/ra.c

67

static char io_buf[DEV_BSIZE];

sys/arch/vax/boot/boot/rom.c

51

static char io_buf[DEV_BSIZE];

sys/arch/vax/boot/boot/rom.c

69

err = romstrategy(0, F_READ, LABELSECTOR, DEV_BSIZE, io_buf, &i);

sys/arch/vax/mba/hp.c

181

dl->d_secsize = DEV_BSIZE;

sys/arch/vax/mba/hp.c

432

(sc->sc_disk.dk_label->d_secsize / DEV_BSIZE);

sys/arch/vax/vax/disksubr.c

153

dlp <= (dec_disklabel *)(dp+DEV_BSIZE-sizeof(*dlp));

sys/arch/vax/vsa/hdc9224.c

428

sc->sc_diskblk += (sc->sc_xfer/DEV_BSIZE);

sys/arch/vax/vsa/hdc9224.c

540

blks = sc->sc_bytecnt/DEV_BSIZE;

sys/arch/vax/vsa/hdc9224.c

555

sc->sc_xfer = blks * DEV_BSIZE;

sys/arch/vax/vsa/hdc9224.c

625

(rd->sc_disk.dk_label->d_secsize / DEV_BSIZE);

sys/arch/vax/vsa/hdc9224.c

829

dl->d_secsize = DEV_BSIZE;

sys/arch/x68k/dev/fd.c

1146

fd->sc_blkno = bp->b_blkno / (FDC_BSIZE / DEV_BSIZE);

sys/arch/x68k/dev/fd.c

1719

form_parms->nbps / DEV_BSIZE;

sys/arch/x68k/dev/fd.c

1833

+ finfo->head * type->sectrac) * (128 << type->secsize) / DEV_BSIZE;

sys/arch/x68k/dev/fd.c

735

bp->b_cylinder = (bp->b_blkno / (FDC_BSIZE / DEV_BSIZE)) /

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

81

return n * (1024 / DEV_BSIZE);

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

92

return ((DEV_BSIZE / 256) * n) >> current_blkshift;

sys/arch/x68k/x68k/disksubr.c

47

#define DEF_BSIZE DEV_BSIZE /* default sector size = 512 */

sys/arch/x86/x86/x86_autoconf.c

121

char mbr[DEV_BSIZE];

sys/arch/x86/x86/x86_autoconf.c

180

error = vn_rdwr(UIO_READ, tv, mbr, DEV_BSIZE, 0, UIO_SYSSPACE,

sys/arch/x86/x86/x86_autoconf.c

189

for (ck = i = 0; i < DEV_BSIZE; i++)

sys/arch/x86/x86/x86_autoconf.c

221

uint8_t bf[DEV_BSIZE];

sys/arch/x86/x86/x86_autoconf.c

245

sizeof(bf), blk * DEV_BSIZE, UIO_SYSSPACE,

sys/arch/xen/xen/xbd_xenbus.c

105

CTASSERT(XEN_BSIZE == DEV_BSIZE);

sys/arch/xen/xen/xbd_xenbus.c

679

sc->sc_sectors * (uint64_t)sc->sc_secsize / DEV_BSIZE;

sys/arch/xen/xen/xbdback_xenbus.c

842

(u_long)DEV_BSIZE);

sys/arch/zaurus/stand/zboot/diskprobe.c

372

char buf[DEV_BSIZE];

sys/arch/zaurus/stand/zboot/diskprobe.c

397

if (unixstrategy((void *)fd, F_READ, MBR_BBSECTOR, DEV_BSIZE, buf,

sys/arch/zaurus/stand/zboot/diskprobe.c

398

&rsize) != 0 || rsize != DEV_BSIZE) {

sys/arch/zaurus/stand/zboot/diskprobe.c

424

char buf[DEV_BSIZE];

sys/arch/zaurus/stand/zboot/diskprobe.c

440

DEV_BSIZE, buf, &rsize) == 0 && rsize == DEV_BSIZE)

sys/arch/zaurus/stand/zboot/unixdev.c

55

off = (off_t)blk * DEV_BSIZE;

sys/dev/ata/wd.c

1567

if (atareq->datalen < DEV_BSIZE

sys/dev/ata/wd.c

1569

tbuf = kmem_zalloc(DEV_BSIZE, KM_SLEEP);

sys/dev/ata/wd.c

1571

wi->wi_iov.iov_len = DEV_BSIZE;

sys/dev/ata/wd.c

1591

kmem_free(tbuf, DEV_BSIZE);

sys/dev/ata/wd.c

463

wd->sc_capacity512 = (wd->sc_capacity * wd->sc_blksize) / DEV_BSIZE;

sys/dev/ata/wd.c

489

wd->sc_blksize < DEV_BSIZE || wd->sc_blksize > MAXPHYS) {

sys/dev/ata/wd.c

657

if (lp->d_secsize >= DEV_BSIZE)

sys/dev/ata/wd.c

658

blkno = bp->b_blkno / (lp->d_secsize / DEV_BSIZE);

sys/dev/ata/wd.c

660

blkno = bp->b_blkno * (DEV_BSIZE / lp->d_secsize);

sys/dev/bad144.c

285

if (ctx->bc_secsize > DEV_BSIZE) {

sys/dev/bad144.c

286

bp->b_blkno *= ctx->bc_secsize / DEV_BSIZE;

sys/dev/bad144.c

288

bp->b_blkno /= DEV_BSIZE / ctx->bc_secsize;

sys/dev/ccd.c

1535

(lp->d_secsize / DEV_BSIZE);

sys/dev/ccd.c

410

(cs->sc_ileave < (maxsecsize / DEV_BSIZE))) {

sys/dev/ccd.c

414

cs->sc_xname, (maxsecsize / DEV_BSIZE));

sys/dev/ccd.c

441

ccg->ccg_secsize = DEV_BSIZE;

sys/dev/dksubr.c

271

if (bounds_check_with_mediasize(bp, DEV_BSIZE, numblocks) <= 0)

sys/dev/dksubr.c

282

if (secsize >= DEV_BSIZE)

sys/dev/dksubr.c

283

blkno = bp->b_blkno / (secsize / DEV_BSIZE);

sys/dev/dksubr.c

285

blkno = bp->b_blkno * (DEV_BSIZE / secsize);

sys/dev/dksubr.c

571

(lp->d_secsize / DEV_BSIZE);

sys/dev/dksubr.c

944

if (lp->d_secsize > DEV_BSIZE)

sys/dev/dksubr.c

945

lpratio = lp->d_secsize / DEV_BSIZE;

sys/dev/dksubr.c

946

if (dg->dg_secsize > DEV_BSIZE)

sys/dev/dksubr.c

947

dgratio = dg->dg_secsize / DEV_BSIZE;

sys/dev/dkwedge/dk.c

1569

if (bounds_check_with_mediasize(bp, DEV_BSIZE, p_size) <= 0)

sys/dev/dkwedge/dk.c

1959

if (size % DEV_BSIZE != 0)

sys/dev/dkwedge/dk.c

1965

if (blkno < 0 || blkno + size/DEV_BSIZE > p_size) {

sys/dev/dkwedge/dk.c

1968

size/DEV_BSIZE, p_size);

sys/dev/dkwedge/dk.c

406

dg->dg_secsize = DEV_BSIZE << pdk->dk_blkshift;

sys/dev/dkwedge/dkwedge_apple.c

185

if ((error = dkwedge_read(pdk, vp, offset / DEV_BSIZE,

sys/dev/dkwedge/dkwedge_bsdlabel.c

448

a.secsize = DEV_BSIZE << pdk->dk_blkshift;

sys/dev/dkwedge/dkwedge_gpt.c

130

secsize = DEV_BSIZE << pdk->dk_blkshift;

sys/dev/dkwedge/dkwedge_mbr.c

180

a.secsize = DEV_BSIZE << pdk->dk_blkshift;

sys/dev/dkwedge/dkwedge_rdb.c

114

secsize = DEV_BSIZE << pdk->dk_blkshift;

sys/dev/dkwedge/dkwedge_rdb.c

92

#define ADJUST_NR(x) ((x) * (secsize / DEV_BSIZE))

sys/dev/dm/device-mapper.c

605

buf_start = bp->b_blkno * DEV_BSIZE;

sys/dev/dm/device-mapper.c

618

if (bounds_check_with_mediasize(bp, DEV_BSIZE,

sys/dev/dm/device-mapper.c

646

table_start = table_en->start * DEV_BSIZE;

sys/dev/dm/device-mapper.c

651

table_end = table_start + table_en->length * DEV_BSIZE;

sys/dev/dm/device-mapper.c

673

nestbuf->b_blkno = (start - table_start) / DEV_BSIZE;

sys/dev/dm/dm_target_stripe.c

266

KASSERT(bp->b_resid % DEV_BSIZE == 0);

sys/dev/dm/dm_target_stripe.c

270

num_blks = bp->b_resid / DEV_BSIZE;

sys/dev/dm/dm_target_stripe.c

287

nestiobuf_setup(bp, nestbuf, blkoff, issue_blks * DEV_BSIZE);

sys/dev/dm/dm_target_stripe.c

302

blkoff += issue_blks * DEV_BSIZE;

sys/dev/fdt/fdt_boot.c

411

uint8_t buf[DEV_BSIZE];

sys/dev/flash/flash.c

358

device_blks = sc->sc_partinfo.part_size / DEV_BSIZE;

sys/dev/flash/flash.c

359

KASSERT(part->part_offset % DEV_BSIZE == 0);

sys/dev/flash/flash.c

360

bp->b_rawblkno = bp->b_blkno + (part->part_offset / DEV_BSIZE);

sys/dev/flash/flash.c

362

if (bounds_check_with_mediasize(bp, DEV_BSIZE, device_blks) <= 0) {

sys/dev/flash/flash_io.c

195

offset = bp->b_rawblkno * DEV_BSIZE - base;

sys/dev/flash/flash_io.c

318

offset = bp->b_rawblkno * DEV_BSIZE;

sys/dev/flash/flash_io.c

80

block = bp->b_rawblkno * DEV_BSIZE / fio->fio_if->erasesize;

sys/dev/flash/flash_io.c

83

last = (bp->b_rawblkno * DEV_BSIZE + bp->b_resid - 1)

sys/dev/flash/flash_io.c

89

bp->b_rawblkno * DEV_BSIZE,

sys/dev/flash/flash_io.c

90

bp->b_rawblkno * DEV_BSIZE + bp->b_resid - 1);

sys/dev/fss.c

302

bounds_check_with_mediasize(bp, DEV_BSIZE,

sys/dev/gpib/rd.c

1027

lp->d_secsize = DEV_BSIZE;

sys/dev/gpib/rd.c

1042

lp->d_secperunit * (lp->d_secsize / DEV_BSIZE);

sys/dev/gpib/rd.c

1072

(sc->sc_dk.dk_label->d_secsize / DEV_BSIZE);

sys/dev/gpib/rd.c

403

DEV_BSIZE);

sys/dev/gpib/rd.c

577

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

sys/dev/ic/cac.c

359

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

sys/dev/isa/fd.c

1095

fd->sc_blkno = bp->b_blkno / (FDC_BSIZE / DEV_BSIZE);

sys/dev/isa/fd.c

1538

form_parms->nbps / DEV_BSIZE;

sys/dev/isa/fd.c

1624

+ finfo->head * type->sectrac) * FDC_BSIZE / DEV_BSIZE;

sys/dev/isa/fd.c

737

bp->b_blkno / (FDC_BSIZE / DEV_BSIZE) / fd->sc_type->seccyl;

sys/dev/isa/mcd.c

490

blkno = bp->b_blkno / (lp->d_secsize / DEV_BSIZE);

sys/dev/isa/mcd.c

768

lp->d_secperunit * (lp->d_secsize / DEV_BSIZE);

sys/dev/isa/mcd.c

772

lp->d_secperunit * (lp->d_secsize / DEV_BSIZE);

sys/dev/isa/mcd.c

817

sc->disksize = size * (MCD_BLKSIZE_COOKED / DEV_BSIZE);

sys/dev/ld.c

140

if (sc->sc_secsize < DEV_BSIZE) {

sys/dev/ld.c

157

sc->sc_disksize512 = sc->sc_secperunit * sc->sc_secsize / DEV_BSIZE;

sys/dev/mca/ed_mca.c

173

(u_int64_t) ed->sc_capacity * DEV_BSIZE);

sys/dev/mca/ed_mca.c

252

if (lp->d_secsize >= DEV_BSIZE)

sys/dev/mca/ed_mca.c

253

blkno = bp->b_blkno / (lp->d_secsize / DEV_BSIZE);

sys/dev/mca/ed_mca.c

255

blkno = bp->b_blkno * (DEV_BSIZE / lp->d_secsize);

sys/dev/mca/ed_mca.c

408

lp->d_secsize = DEV_BSIZE;

sys/dev/mca/ed_mca.c

425

lp->d_secperunit * (lp->d_secsize / DEV_BSIZE);

sys/dev/mca/ed_mca.c

598

(wd->sc_dk.dk_label->d_secsize / DEV_BSIZE);

sys/dev/mca/ed_mca.c

641

blkno = blkno / (lp->d_secsize / DEV_BSIZE);

sys/dev/mca/edc_mca.c

842

bp->b_resid = sc->sc_resblk * DEV_BSIZE;

sys/dev/mca/edc_mca.c

888

cmd_args[1] = bcount / DEV_BSIZE;

sys/dev/md.c

535

lp->d_secsize = DEV_BSIZE;

sys/dev/md.c

536

lp->d_secperunit = sc->sc_size / DEV_BSIZE;

sys/dev/md.c

594

if (size < DEV_BSIZE || (size % DEV_BSIZE) != 0)

sys/dev/md_root.c

59

uint32_t md_root_size = sizeof(md_root_image) & ~(DEV_BSIZE - 1);

sys/dev/mscp/mscp_disk.c

524

(ra->ra_disk.dk_label->d_secsize / DEV_BSIZE);

sys/dev/mscp/mscp_disk.c

713

dl->d_secsize = DEV_BSIZE;

sys/dev/ofw/ofdisk.c

313

off = (u_quad_t)blkno * DEV_BSIZE;

sys/dev/ofw/ofdisk.c

466

(lp->d_secsize / DEV_BSIZE);

sys/dev/ofw/ofdisk.c

485

lp->d_secsize = DEV_BSIZE;

sys/dev/qbus/rf.c

473

dl->d_secsize = DEV_BSIZE; /* bytes per sector */

sys/dev/qbus/rf.c

878

+ rfc_sc->sc_curbuf->b_blkno * DEV_BSIZE) /

sys/dev/qbus/rf.c

896

+ rfc_sc->sc_curbuf->b_blkno * DEV_BSIZE) /

sys/dev/qbus/rl.c

279

dl->d_secsize = DEV_BSIZE; /* XXX - wrong, but OK for now */

sys/dev/qbus/rl.c

510

(dl->d_secsize / DEV_BSIZE);

sys/dev/qbus/rl.c

638

blks = sc->sc_bytecnt/DEV_BSIZE;

sys/dev/qbus/rl.c

642

RL_WREG(RL_MP, -(blks*DEV_BSIZE)/2);

sys/dev/qbus/rl.c

644

(blks*DEV_BSIZE), (bp->b_flags & B_PHYS ? bp->b_proc : 0),

sys/dev/qbus/rl.c

652

sc->sc_bufaddr = (char *)sc->sc_bufaddr + (blks*DEV_BSIZE);

sys/dev/qbus/rl.c

654

sc->sc_bytecnt -= (blks*DEV_BSIZE);

sys/dev/raidframe/rf_netbsdkintf.c

2520

bp->b_blkno = offset / DEV_BSIZE;

sys/dev/raidframe/rf_netbsdkintf.c

2569

bp->b_blkno = offset / DEV_BSIZE;

sys/dev/scsipi/cd.c

1625

cd->params.disksize512 = ((u_int64_t)cd->params.disksize * blksize) / DEV_BSIZE;

sys/dev/scsipi/cd.c

660

bps = howmany(secsize, DEV_BSIZE);

sys/dev/scsipi/cd.c

661

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

sys/dev/scsipi/cd.c

666

total = roundup(nblks + skip, bps) * DEV_BSIZE;

sys/dev/scsipi/cd.c

671

bounce->head = skip * DEV_BSIZE;

sys/dev/scsipi/cd.c

679

blkno += howmany(count, DEV_BSIZE);

sys/dev/scsipi/sd.c

1539

dp->disksize512 = (dp->disksize * dp->blksize) / DEV_BSIZE;

sys/dev/scsipi/sd.c

1638

dp->disksize512 = (blocks * dp->blksize) / DEV_BSIZE;

sys/dev/scsipi/sd.c

720

if (sd->params.blksize == DEV_BSIZE)

sys/dev/spi/spiflash.c

216

sc->sc_device_blks = sc->sc_device_size / DEV_BSIZE;

sys/dev/spi/spiflash.c

336

if (bounds_check_with_mediasize(bp, DEV_BSIZE,

sys/dev/spi/spiflash.c

374

size_t addr = bp->b_blkno * DEV_BSIZE;

sys/dev/spi/spiflash.c

416

base = (blkno * DEV_BSIZE) & ~ (sc->sc_erase_size - 1);

sys/dev/spi/spiflash.c

442

dst = save + (bp->b_blkno * DEV_BSIZE) - base;

sys/dev/spi/spiflash.c

484

addr = bp->b_blkno * DEV_BSIZE;

sys/dev/spi/spiflash.c

497

addr = bp->b_blkno * DEV_BSIZE;

sys/dev/spkr.c

505

sc->sc_inbuf = kmem_alloc(DEV_BSIZE, KM_SLEEP);

sys/dev/spkr.c

524

size_t n = uimin(DEV_BSIZE, uio->uio_resid);

sys/dev/spkr.c

546

kmem_free(sc->sc_inbuf, DEV_BSIZE);

sys/dev/sun/disksubr.c

150

DEV_BSIZE - sizeof(*dlp));

sys/dev/vme/xd.c

1205

(xdsc->sc_dk.dk_label->d_secsize / DEV_BSIZE);

sys/dev/vme/xy.c

1123

(xysc->sc_dk.dk_label->d_secsize / DEV_BSIZE);

sys/dev/vme/xy.c

1189

blkno = bp->b_blkno / (lp->d_secsize / DEV_BSIZE);

sys/dev/vnd.c

1436

vnd->sc_iosize = DEV_BSIZE;

sys/dev/vnd.c

1462

(vnd->sc_geom.vng_secsize / DEV_BSIZE) *

sys/dev/vnd.c

1473

(vnd->sc_geom.vng_secsize / DEV_BSIZE);

sys/dev/vnd.c

1488

vnd->sc_geom.vng_secsize = DEV_BSIZE;

sys/dev/vnd.c

1493

vnd->sc_geom.vng_secsize = DEV_BSIZE;

sys/dev/vnd.c

1700

tmpbuf = malloc(DEV_BSIZE, M_TEMP, M_WAITOK);

sys/dev/vnd.c

1704

aiov.iov_len = uimin(DEV_BSIZE, dbtob(vnd->sc_size));

sys/dev/vnd.c

1851

(lp->d_secsize / DEV_BSIZE);

sys/dev/vnd.c

1877

spb = vng->vng_secsize / DEV_BSIZE;

sys/dev/vnd.c

2114

spb = vnd->sc_geom.vng_secsize / DEV_BSIZE;

sys/dev/vnd.c

525

if (bounds_check_with_mediasize(bp, DEV_BSIZE,

sys/dev/vnd.c

539

blkno = bp->b_blkno / (lp->d_secsize / DEV_BSIZE);

sys/fs/adosfs/adutil.c

58

bp->b_blkno / (amp->bsize / DEV_BSIZE));

sys/fs/adosfs/adutil.c

69

bp->b_blkno / (amp->bsize / DEV_BSIZE), adoswordn(bp,0));

sys/fs/adosfs/adutil.c

94

bp->b_blkno / (amp->bsize / DEV_BSIZE), adoswordn(bp, amp->nwords - 1));

sys/fs/adosfs/advfsops.c

406

if ((error = bread(amp->devvp, an * amp->bsize / DEV_BSIZE,

sys/fs/adosfs/advfsops.c

528

error = bread(amp->devvp, ap->linkto * amp->bsize / DEV_BSIZE,

sys/fs/adosfs/advfsops.c

612

if ((error = bread(amp->devvp, bn * amp->bsize / DEV_BSIZE, amp->bsize,

sys/fs/adosfs/advfsops.c

629

adoswordn(bp, blkix) * amp->bsize / DEV_BSIZE, amp->bsize,

sys/fs/adosfs/advfsops.c

656

if ((error = bread(amp->devvp, bn * amp->bsize / DEV_BSIZE,

sys/fs/adosfs/advnops.c

288

bp->b_blkno / (amp->bsize / DEV_BSIZE));

sys/fs/adosfs/advnops.c

294

bp->b_blkno / (amp->bsize / DEV_BSIZE));

sys/fs/adosfs/advnops.c

468

error = bread(ap->amp->devvp, nb * ap->amp->bsize / DEV_BSIZE,

sys/fs/adosfs/advnops.c

498

*bnp = adoswordn(flbp, flblkoff) * ap->amp->bsize / DEV_BSIZE;

sys/fs/cd9660/cd9660_vfsops.c

358

if (logical_block_size < DEV_BSIZE || logical_block_size > MAXBSIZE

sys/fs/efs/efs_subr.c

192

return (bread(emp->em_devvp, (daddr_t)bboff * (EFS_BB_SIZE / DEV_BSIZE),

sys/fs/hfs/hfs_subr.c

200

cbdata->devblksz = DEV_BSIZE;

sys/fs/hfs/hfs_subr.c

320

error = bread(vp, (start + curoff) / DEV_BSIZE,/* no rounding involved*/

sys/fs/msdosfs/msdosfs_vfsops.c

492

secsize = DEV_BSIZE;

sys/fs/msdosfs/msdosfs_vfsops.c

496

if (secsize < DEV_BSIZE) {

sys/fs/nfs/client/nfs_clbio.c

1118

(long)bp->b_blkno * DEV_BSIZE,

sys/fs/nfs/client/nfs_clbio.c

1285

bp->b_blkno = bn * (vp->v_bufobj.bo_bsize / DEV_BSIZE);

sys/fs/nfs/client/nfs_clbio.c

1601

uiop->uio_offset = ((off_t)bp->b_blkno) * DEV_BSIZE;

sys/fs/nfs/client/nfs_clbio.c

1673

off = ((u_quad_t)bp->b_blkno) * DEV_BSIZE + bp->b_dirtyoff;

sys/fs/nfs/client/nfs_clbio.c

1692

if ((off_t)bp->b_blkno * DEV_BSIZE + bp->b_dirtyend > np->n_size)

sys/fs/nfs/client/nfs_clbio.c

1693

bp->b_dirtyend = np->n_size - (off_t)bp->b_blkno * DEV_BSIZE;

sys/fs/nfs/client/nfs_clbio.c

1699

uiop->uio_offset = (off_t)bp->b_blkno * DEV_BSIZE

sys/fs/nfs/client/nfs_clvnops.c

2763

toff = ((u_quad_t)bp->b_blkno) * DEV_BSIZE +

sys/fs/nfs/client/nfs_clvnops.c

2788

off = ((u_quad_t)bp->b_blkno) * DEV_BSIZE +

sys/fs/nilfs/nilfs_subr.c

133

int blk2dev = nilfsdev->blocksize / DEV_BSIZE;

sys/fs/nilfs/nilfs_vnops.c

394

int blk2dev = nilfsdev->blocksize / DEV_BSIZE;

sys/fs/ptyfs/ptyfs_vnops.c

359

vap->va_bytes = vap->va_size = DEV_BSIZE;

sys/fs/puffs/puffs_vfsops.c

211

mp->mnt_stat.f_iosize = DEV_BSIZE;

sys/fs/puffs/puffs_vfsops.c

496

statvfs_msg->pvfsr_sb.f_iosize = DEV_BSIZE;

sys/fs/sysvbfs/bfs.c

248

uint8_t tmpbuf[DEV_BSIZE];

sys/fs/sysvbfs/bfs.c

262

n *= DEV_BSIZE;

sys/fs/sysvbfs/bfs.c

364

uint8_t *p, tmpbuf[DEV_BSIZE];

sys/fs/sysvbfs/bfs.c

376

if ((start + n) * DEV_BSIZE >= bfs->data_end) {

sys/fs/sysvbfs/bfs.c

395

inode->eof_offset_byte = start * DEV_BSIZE + bufsz - 1;

sys/fs/sysvbfs/bfs.c

417

p += DEV_BSIZE;

sys/fs/sysvbfs/bfs.c

418

n += DEV_BSIZE;

sys/fs/sysvbfs/bfs.c

421

memset(tmpbuf, 0, DEV_BSIZE);

sys/fs/sysvbfs/bfs.c

589

return inode->eof_offset_byte - inode->start_sector * DEV_BSIZE + 1;

sys/fs/sysvbfs/bfs.c

627

if (start * DEV_BSIZE >= bfs->data_end) {

sys/fs/sysvbfs/bfs.c

710

(inode->start_sector * DEV_BSIZE) + 1,/* file size*/

sys/fs/sysvbfs/bfs_sysvbfs.c

106

if (bread(bio->vp, block, DEV_BSIZE, 0, &bp) != 0)

sys/fs/sysvbfs/bfs_sysvbfs.c

108

memcpy(buf, bp->b_data, DEV_BSIZE);

sys/fs/sysvbfs/bfs_sysvbfs.c

129

buf += DEV_BSIZE;

sys/fs/sysvbfs/bfs_sysvbfs.c

145

if ((bp = getblk(bio->vp, block, DEV_BSIZE, 0, 0)) == 0) {

sys/fs/sysvbfs/bfs_sysvbfs.c

149

memcpy(bp->b_data, buf, DEV_BSIZE);

sys/fs/sysvbfs/bfs_sysvbfs.c

93

buf += DEV_BSIZE;

sys/fs/sysvbfs/sysvbfs_vnops.c

922

inode->eof_offset_byte = bnode->data_block * DEV_BSIZE +

sys/fs/udf/udf.h

128

#define UDF_MAX_MAPPINGS (MAXPHYS/DEV_BSIZE) /* 128 */

sys/fs/udf/udf_readwrite.c

292

int blks = sector_size / DEV_BSIZE;

sys/fs/udf/udf_readwrite.c

433

int blks = sector_size / DEV_BSIZE;

sys/fs/udf/udf_readwrite.c

490

int blks = sector_size / DEV_BSIZE;

sys/fs/udf/udf_readwrite.c

525

int blks = sector_size / DEV_BSIZE;

sys/fs/udf/udf_readwrite.c

571

int blks = sector_size / DEV_BSIZE;

sys/fs/udf/udf_strat_direct.c

250

int blks = sector_size / DEV_BSIZE;

sys/fs/udf/udf_strat_direct.c

374

rblk = run_start * (sector_size/DEV_BSIZE);

sys/fs/udf/udf_strat_rmw.c

1112

int blks = sector_size / DEV_BSIZE;

sys/fs/udf/udf_strat_rmw.c

783

int blks = sector_size / DEV_BSIZE;

sys/fs/udf/udf_strat_sequential.c

386

int blks = sector_size / DEV_BSIZE;

sys/fs/udf/udf_subr.c

6744

rblk = run_start * (sector_size/DEV_BSIZE);

sys/fs/udf/udf_subr.c

6858

rblk = run_start * (lb_size/DEV_BSIZE);

sys/fs/unionfs/unionfs_vnops.c

1456

if (uio->uio_resid <= (uio->uio_resid & (DEV_BSIZE -1)))

sys/fs/v7fs/v7fs_io_kern.c

157

buf += DEV_BSIZE;

sys/fs/v7fs/v7fs_io_kern.c

170

if (bread(bio->vp, block, DEV_BSIZE, 0, &bp) != 0)

sys/fs/v7fs/v7fs_io_kern.c

172

memcpy(buf, bp->b_data, DEV_BSIZE);

sys/fs/v7fs/v7fs_io_kern.c

192

buf += DEV_BSIZE;

sys/fs/v7fs/v7fs_io_kern.c

205

if ((bp = getblk(bio->vp, block, DEV_BSIZE, 0, 0)) == 0) {

sys/fs/v7fs/v7fs_io_kern.c

210

memcpy(bp->b_data, buf, DEV_BSIZE);

sys/kern/kern_physio.c

314

if (uio->uio_offset & (DEV_BSIZE - 1)) {

sys/kern/subr_disk.c

126

if (bp->b_bcount <= DEV_BSIZE)

sys/kern/subr_disk.c

134

bp->b_blkno + (bp->b_bcount - 1) / DEV_BSIZE);

sys/kern/subr_disk.c

166

u_int blocksize = DEV_BSIZE;

sys/kern/subr_disk.c

369

if ((lp->d_secsize / DEV_BSIZE) == 0 || lp->d_secpercyl == 0) {

sys/kern/subr_disk.c

383

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

sys/kern/subr_disk.c

416

(lp->d_secsize / DEV_BSIZE) / lp->d_secpercyl;

sys/kern/subr_disk.c

425

if ((lp->d_secsize / DEV_BSIZE) == 0 || lp->d_secpercyl == 0)

sys/kern/subr_disk.c

709

dg->dg_secsize = DEV_BSIZE;

sys/kern/subr_disk_4bsd.c

72

lp->d_secsize = DEV_BSIZE;

sys/kern/subr_disk_4bsd.c

99

DEV_BSIZE - sizeof(*dlp));

sys/kern/subr_disk_mbr.c

413

lp->d_secsize = DEV_BSIZE;

sys/kern/subr_disk_mbr.c

91

#if LABELSECTOR*DEV_BSIZE + LABELOFFSET > SCANBLOCKS*DEV_BSIZE - DISKLABEL_SIZE

sys/kern/subr_disk_open.c

113

secsize = DEV_BSIZE << pdk->dk_blkshift;

sys/kern/subr_disklabel.c

65

|| (nlp->d_secsize % DEV_BSIZE) != 0) {

sys/kern/vfs_bio.c

274

#define MEMPOOL_INDEX_OFFSET (ilog2(DEV_BSIZE)) /* smallest pool is 512 bytes */

sys/kern/vfs_bio.c

521

pool_init(pp, size, DEV_BSIZE, 0, 0, name, pa, IPL_NONE);

sys/kern/vfs_wapbl.c

2982

if (blksize < DEV_BSIZE)

sys/kern/vfs_wapbl.c

2984

if (blksize % DEV_BSIZE)

sys/kern/vfs_wapbl.c

531

if (blksize < DEV_BSIZE)

sys/kern/vfs_wapbl.c

533

if (blksize % DEV_BSIZE)

sys/lib/libsa/cd9660.c

76

#define cdb2devb(bno) ((bno) * ISO_DEFAULT_BLOCK_SIZE / DEV_BSIZE)

sys/lib/libsa/disklabel.c

54

elp = (const void *)(buf + DEV_BSIZE - sizeof(*dlp));

sys/lib/libsa/stand.h

330

secsize = DEV_BSIZE;

sys/lib/libsa/stand.h

339

#define GETSECSIZE(f) DEV_BSIZE

sys/miscfs/fdesc/fdesc_vnops.c

441

vap->va_size = DEV_BSIZE;

sys/miscfs/fdesc/fdesc_vnops.c

447

vap->va_blocksize = DEV_BSIZE;

sys/miscfs/genfs/genfs_io.c

1752

const int mask = DEV_BSIZE - 1;

sys/miscfs/genfs/genfs_vfsops.c

45

sbp->f_bsize = DEV_BSIZE;

sys/miscfs/genfs/genfs_vfsops.c

46

sbp->f_frsize = DEV_BSIZE;

sys/miscfs/genfs/genfs_vfsops.c

47

sbp->f_iosize = DEV_BSIZE;

sys/miscfs/kernfs/kernfs_vnops.c

654

vap->va_blocksize = DEV_BSIZE;

sys/miscfs/kernfs/kernfs_vnops.c

671

vap->va_bytes = vap->va_size = DEV_BSIZE;

sys/miscfs/kernfs/kernfs_vnops.c

681

vap->va_bytes = vap->va_size = DEV_BSIZE;

sys/miscfs/kernfs/kernfs_vnops.c

687

vap->va_bytes = vap->va_size = DEV_BSIZE;

sys/miscfs/procfs/procfs_vnops.c

842

vap->va_bytes = vap->va_size = DEV_BSIZE;

sys/miscfs/procfs/procfs_vnops.c

889

vap->va_bytes = vap->va_size = DEV_BSIZE;

sys/miscfs/specfs/spec_vnops.c

1139

bsize = imin(imax(pi.pi_bsize, DEV_BSIZE), MAXBSIZE);

sys/miscfs/specfs/spec_vnops.c

1255

bsize = imin(imax(pi.pi_bsize, DEV_BSIZE), MAXBSIZE);

sys/rump/librump/rumpvfs/rumpfs.c

1030

rn = makeprivate(VDIR, va->va_mode & ALLPERMS, NODEV, DEV_BSIZE, false);

sys/rump/librump/rumpvfs/rumpfs.c

1128

DEV_BSIZE, false);

sys/rump/librump/rumpvfs/rumpfs.c

1159

newsize = va->va_type == VSOCK ? DEV_BSIZE : 0;

sys/rump/librump/rumpvfs/rumpfs.c

1868

rn = makeprivate(VDIR, RUMPFS_DEFAULTMODE, NODEV, DEV_BSIZE, false);

sys/stand/efiboot/efiblock.c

289

char buf[DEV_BSIZE]; /* XXX, arbitrary size >= struct disklabel */

sys/sys/bootblock.h

1074

#define hppa_lifstodb(s) ((s) * HPPA_LIF_SECTSIZE / DEV_BSIZE)

sys/sys/disk.h

535

#define DK_BSIZE2BLKSHIFT(b) ((ffs((b) / DEV_BSIZE)) - 1)

sys/sys/disk.h

538

((b) >= DEV_BSIZE && ((b) & ((b) - 1)) == 0 && (b) <= MAXPHYS)

sys/ufs/ext2fs/ext2fs.h

87

#define SBLOCK ((daddr_t)(BBLOCK + BBSIZE / DEV_BSIZE))

sys/ufs/ffs/ffs_vfsops.c

1141

daddr_t blkno = APPLEUFS_LABEL_OFFSET / DEV_BSIZE;

sys/ufs/ffs/ffs_vfsops.c

1228

error = bread(devvp, sblock_try[i] / DEV_BSIZE, SBLOCKSIZE,

sys/ufs/ffs/ffs_vfsops.c

1232

sblock_try[i] / DEV_BSIZE, error);

sys/ufs/ffs/ffs_vfsops.c

2419

fs->fs_sblockloc / DEV_BSIZE, FFS_NOBLK,

sys/ufs/ffs/ffs_vfsops.c

848

error = bread(devvp, fs->fs_sblockloc / DEV_BSIZE, fs_sbsize,

sys/ufs/lfs/lfs.h

318

#define LFS_DIRBLKSIZ DEV_BSIZE

sys/ufs/lfs/lfs_vfsops.c

1015

error = bread(devvp, lfs_sb_getsboff(primarysb, 1) * (fsbsize / DEV_BSIZE),

sys/ufs/lfs/lfs_vfsops.c

1120

fs->lfs_devbsize = DEV_BSIZE;

sys/ufs/lfs/lfs_vfsops.c

927

__CTASSERT(sizeof(struct dlfs) == DEV_BSIZE);

sys/ufs/lfs/lfs_vfsops.c

945

sb_addr = LFS_LABELPAD / DEV_BSIZE;

sys/ufs/lfs/lfs_vfsops.c

985

fsbsize = DEV_BSIZE;

sys/ufs/ufs/dir.h

76

#define UFS_DIRBLKSIZ DEV_BSIZE

tests/fs/lfs/t_resize.c

176

int newnseg = (size * DEV_BSIZE) / SEGSIZE;

usr.bin/vndcompress/common.h

105

#define MIN_BLOCKSIZE DEV_BSIZE

usr.bin/vndcompress/vndcompress.c

220

const uint32_t n_extra = (S->offset % DEV_BSIZE);

usr.bin/vndcompress/vndcompress.c

222

const uint32_t n_padding = (DEV_BSIZE - n_extra);

usr.bin/vndcompress/vndcompress.c

404

__CTASSERT(0 < DEV_BSIZE);

usr.bin/vndcompress/vndcompress.c

405

__CTASSERT((MIN_BLOCKSIZE % DEV_BSIZE) == 0);

usr.bin/vndcompress/vndcompress.c

407

__CTASSERT((DEF_BLOCKSIZE % DEV_BSIZE) == 0);

usr.bin/vndcompress/vndcompress.c

409

__CTASSERT((MAX_BLOCKSIZE % DEV_BSIZE) == 0);

usr.bin/vndcompress/vndcompress.c

423

__CTASSERT(DEV_BSIZE <= UINT32_MAX);

usr.bin/vndcompress/vndcompress.c

424

if ((S->blocksize % DEV_BSIZE) != 0)

usr.bin/vndcompress/vndcompress.c

427

S->blocksize, (uint32_t)DEV_BSIZE);

usr.bin/vndcompress/vndcompress.c

429

assert((S->blocksize % DEV_BSIZE) == 0);

usr.bin/vndcompress/vnduncompress.c

101

__CTASSERT(DEV_BSIZE <= UINT32_MAX);

usr.bin/vndcompress/vnduncompress.c

102

if ((blocksize % DEV_BSIZE) != 0)

usr.bin/vndcompress/vnduncompress.c

105

blocksize, (uint32_t)DEV_BSIZE);

usr.sbin/fstyp/hammer2.c

54

return (ssize_t)dkw.dkw_size * DEV_BSIZE;

usr.sbin/makefs/ffs/ffs_alloc.c

123

DIP_ADD(ip, blocks, size / DEV_BSIZE);

usr.sbin/mdconfig/mdconfig.c

69

getprogname(), DEV_BSIZE);

usr.sbin/quot/quot.c

174

return nblk / DEV_BSIZE;

usr.sbin/quot/quot.c

73

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

usr.sbin/sysinst/arch/acorn32/md.c

123

if (lseek(fd, (off_t)offset * DEV_BSIZE, SEEK_SET) < 0

usr.sbin/sysinst/arch/acorn32/md.c

71

static unsigned char bb[DEV_BSIZE];

usr.sbin/sysinst/arch/acorn32/md.c

90

if (lseek(fd, (off_t)FILECORE_BOOT_SECTOR * DEV_BSIZE, SEEK_SET) < 0

usr.sbin/sysinst/arch/cats/md.c

69

static char bb[DEV_BSIZE];

usr.sbin/sysinst/disks.c

296

unsigned char inbuf[DEV_BSIZE];