mirror/freebsd
1
0
Fork 0
mirror of https://git.FreeBSD.org/src.git synced 2025-01-31 16:57:10 +00:00
Code Issues Releases Activity

Remove B_READ, B_WRITE and B_FREEBUF and replace them with a new

Browse Source 
field in struct buf: b_iocmd.  The b_iocmd is enforced to have
exactly one bit set.

B_WRITE was bogusly defined as zero giving rise to obvious coding
mistakes.

Also eliminate the redundant struct buf flag B_CALL, it can just
as efficiently be done by comparing b_iodone to NULL.

Should you get a panic or drop into the debugger, complaining about
"b_iocmd", don't continue.  It is likely to write on your disk
where it should have been reading.

This change is a step in the direction towards a stackable BIO capability.

A lot of this patch were machine generated (Thanks to style(9) compliance!)

Vinum users:  Greg has not had time to test this yet, be careful.
This commit is contained in:
Poul-Henning Kamp 2000-03-20 10:44:49 +00:00
parent 44bdcfa638
commit 21144e3bf1
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/head/; revision=58345
98 changed files with 392 additions and 350 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
sys/alpha/alpha/machdep.c
View File

@ -1929,7 +1929,7 @@ bounds_check_with_label(struct buf *bp, struct disklabel *lp, int wlabel)
#if LABELSECTOR != 0
bp->b_blkno + p->p_offset + sz > LABELSECTOR + labelsect &&
#endif
(bp->b_flags & B_READ) == 0 && wlabel == 0) {
(bp->b_iocmd == BIO_WRITE) && wlabel == 0) {
bp->b_error = EROFS;
goto bad;
}
@ -1937,7 +1937,7 @@ bounds_check_with_label(struct buf *bp, struct disklabel *lp, int wlabel)
#if defined(DOSBBSECTOR) && defined(notyet)
/* overwriting master boot record? */
if (bp->b_blkno + p->p_offset <= DOSBBSECTOR &&
(bp->b_flags & B_READ) == 0 && wlabel == 0) {
(bp->b_iocmd == BIO_WRITE) && wlabel == 0) {
bp->b_error = EROFS;
goto bad;
}

2
sys/alpha/alpha/vm_machdep.c
View File

@ -319,7 +319,7 @@ vmapbuf(bp)
* when reading stuff off device into memory.
*/
vm_fault_quick(addr,
(bp->b_flags&B_READ)?(VM_PROT_READ|VM_PROT_WRITE):VM_PROT_READ);
(bp->b_iocmd == BIO_READ)?(VM_PROT_READ|VM_PROT_WRITE):VM_PROT_READ);
pa = trunc_page(pmap_kextract((vm_offset_t) addr));
if (pa == 0)
panic("vmapbuf: page not present");

1
sys/amd64/amd64/genassym.c
View File

@ -153,7 +153,6 @@ ASSYM(SC_GS, offsetof(struct osigcontext, sc_gs));
ASSYM(SC_TRAPNO, offsetof(struct osigcontext, sc_trapno));
ASSYM(UC_EFLAGS, offsetof(ucontext_t, uc_mcontext.mc_eflags));
ASSYM(UC_GS, offsetof(ucontext_t, uc_mcontext.mc_gs));
ASSYM(B_READ, B_READ);
ASSYM(ENOENT, ENOENT);
ASSYM(EFAULT, EFAULT);
ASSYM(ENAMETOOLONG, ENAMETOOLONG);

4
sys/amd64/amd64/machdep.c
View File

@ -2360,7 +2360,7 @@ bounds_check_with_label(struct buf *bp, struct disklabel *lp, int wlabel)
#if LABELSECTOR != 0
bp->b_blkno + p->p_offset + sz > LABELSECTOR + labelsect &&
#endif
(bp->b_flags & B_READ) == 0 && wlabel == 0) {
(bp->b_iocmd == BIO_WRITE) && wlabel == 0) {
bp->b_error = EROFS;
goto bad;
}
@ -2368,7 +2368,7 @@ bounds_check_with_label(struct buf *bp, struct disklabel *lp, int wlabel)
#if defined(DOSBBSECTOR) && defined(notyet)
/* overwriting master boot record? */
if (bp->b_blkno + p->p_offset <= DOSBBSECTOR &&
(bp->b_flags & B_READ) == 0 && wlabel == 0) {
(bp->b_iocmd == BIO_WRITE) && wlabel == 0) {
bp->b_error = EROFS;
goto bad;
}

2
sys/amd64/amd64/vm_machdep.c
View File

@ -357,7 +357,7 @@ vmapbuf(bp)
* when reading stuff off device into memory.
*/
vm_fault_quick(addr,
(bp->b_flags&B_READ)?(VM_PROT_READ|VM_PROT_WRITE):VM_PROT_READ);
(bp->b_iocmd == BIO_READ)?(VM_PROT_READ|VM_PROT_WRITE):VM_PROT_READ);
pa = trunc_page(pmap_kextract((vm_offset_t) addr));
if (pa == 0)
panic("vmapbuf: page not present");

13
sys/cam/cam_periph.c
View File

@ -556,7 +556,7 @@ cam_periph_mapmem(union ccb *ccb, struct cam_periph_map_info *mapinfo)
}
if (dirs[i] & CAM_DIR_OUT) {
flags[i] = B_WRITE;
flags[i] = BIO_WRITE;
if (!useracc(*data_ptrs[i], lengths[i],
VM_PROT_READ)) {
printf("cam_periph_mapmem: error, "
@ -568,12 +568,8 @@ cam_periph_mapmem(union ccb *ccb, struct cam_periph_map_info *mapinfo)
}
}
/*
* XXX this check is really bogus, since B_WRITE currently
* is all 0's, and so it is "set" all the time.
*/
if (dirs[i] & CAM_DIR_IN) {
flags[i] |= B_READ;
flags[i] = BIO_READ;
if (!useracc(*data_ptrs[i], lengths[i],
VM_PROT_WRITE)) {
printf("cam_periph_mapmem: error, "
@ -610,7 +606,10 @@ cam_periph_mapmem(union ccb *ccb, struct cam_periph_map_info *mapinfo)
mapinfo->bp[i]->b_bufsize = lengths[i];
/* set the flags */
mapinfo->bp[i]->b_flags = flags[i] | B_PHYS;
mapinfo->bp[i]->b_flags = B_PHYS;
/* set the direction */
mapinfo->bp[i]->b_iocmd = flags[i];
/* map the buffer into kernel memory */
vmapbuf(mapinfo->bp[i]);

2
sys/cam/scsi/scsi_cd.c
View File

@ -1432,7 +1432,7 @@ cdstart(struct cam_periph *periph, union ccb *start_ccb)
(bp->b_flags & B_ORDERED) != 0 ?
MSG_ORDERED_Q_TAG :
MSG_SIMPLE_Q_TAG,
/* read */bp->b_flags & B_READ,
/* read */bp->b_iocmd == BIO_READ,
/* byte2 */ 0,
/* minimum_cmd_size */ 10,
/* lba */ bp->b_pblkno,

2
sys/cam/scsi/scsi_da.c
View File

@ -1056,7 +1056,7 @@ dastart(struct cam_periph *periph, union ccb *start_ccb)
/*retries*/4,
dadone,
tag_code,
bp->b_flags & B_READ,
bp->b_iocmd == BIO_READ,
/*byte2*/0,
softc->minimum_cmd_size,
bp->b_pblkno,

2
sys/cam/scsi/scsi_pt.c
View File

@ -539,7 +539,7 @@ ptstart(struct cam_periph *periph, union ccb *start_ccb)
/*retries*/4,
ptdone,
MSG_SIMPLE_Q_TAG,
bp->b_flags & B_READ,
bp->b_iocmd == BIO_READ,
/*byte2*/0,
bp->b_bcount,
bp->b_data,

10
sys/cam/scsi/scsi_sa.c
View File

@ -710,7 +710,7 @@ sastrategy(struct buf *bp)
CAM_DEBUG(periph->path, CAM_DEBUG_INFO, ("sastrategy: enqueuing a %d "
"%s byte %s queue count now %d\n", (int) bp->b_bcount,
(softc->flags & SA_FLAG_FIXED)? "fixed" : "variable",
(bp->b_flags & B_READ)? "read" : "write", softc->queue_count));
(bp->b_iocmd == BIO_READ)? "read" : "write", softc->queue_count));
splx(s);
@ -1491,7 +1491,7 @@ sastart(struct cam_periph *periph, union ccb *start_ccb)
bp->b_resid = bp->b_bcount;
bp->b_flags |= B_ERROR;
if ((softc->flags & SA_FLAG_EOM_PENDING) != 0) {
if ((bp->b_flags & B_READ) == 0)
if (bp->b_iocmd == BIO_WRITE)
bp->b_error = ENOSPC;
else
bp->b_error = EIO;
@ -1568,10 +1568,10 @@ sastart(struct cam_periph *periph, union ccb *start_ccb)
* have to do deal with 512 byte or 1KB intermediate
* records.
*/
softc->dsreg = (bp->b_flags & B_READ)?
softc->dsreg = (bp->b_iocmd == BIO_READ)?
MTIO_DSREG_RD : MTIO_DSREG_WR;
scsi_sa_read_write(&start_ccb->csio, 0, sadone,
MSG_SIMPLE_Q_TAG, (bp->b_flags & B_READ) != 0,
MSG_SIMPLE_Q_TAG, (bp->b_iocmd == BIO_READ),
FALSE, (softc->flags & SA_FLAG_FIXED) != 0,
length, bp->b_data, bp->b_bcount, SSD_FULL_SIZE,
120 * 60 * 1000);
@ -1661,7 +1661,7 @@ sadone(struct cam_periph *periph, union ccb *done_ccb)
if (csio->resid != 0) {
bp->b_flags |= B_ERROR;
}
if ((bp->b_flags & B_READ) == 0) {
if (bp->b_iocmd == BIO_WRITE) {
softc->flags |= SA_FLAG_TAPE_WRITTEN;
softc->filemarks = 0;
}

2
sys/cam/scsi/scsi_target.c
View File

@ -1165,7 +1165,7 @@ targstrategy(struct buf *bp)
*
*/
bp->b_resid = bp->b_bcount;
if ((bp->b_flags & B_READ) != 0) {
if (bp->b_iocmd == BIO_READ) {
CAM_DEBUG(periph->path, CAM_DEBUG_PERIPH,
("Queued a SEND buffer\n"));
bufq_insert_tail(&softc->snd_buf_queue, bp);

4
sys/contrib/dev/fla/fla.c
View File

@ -221,9 +221,9 @@ flastrategy(struct buf *bp)
bp->b_resid = bp->b_bcount;
unit = dkunit(bp->b_dev);
if (bp->b_flags & B_FREEBUF)
if (bp->b_iocmd == BIO_DELETE)
what = DOC2K_ERASE;
else if (bp->b_flags & B_READ)
else if (bp->b_iocmd == BIO_READ)
what = DOC2K_READ;
else
what = DOC2K_WRITE;

2
sys/contrib/softupdates/ffs_softdep.c
View File

@ -2780,7 +2780,7 @@ softdep_disk_io_initiation(bp)
* We only care about write operations. There should never
* be dependencies for reads.
*/
if (bp->b_flags & B_READ)
if (bp->b_iocmd == BIO_READ)
panic("softdep_disk_io_initiation: read");
/*
* Do any necessary pre-I/O processing.

2
sys/dev/amr/amr.c
View File

@ -853,7 +853,7 @@ amr_startio(struct amr_softc *sc)
ac->ac_private = bp;
ac->ac_data = bp->b_data;
ac->ac_length = bp->b_bcount;
if (bp->b_flags & B_READ) {
if (bp->b_iocmd == BIO_READ) {
ac->ac_flags |= AMR_CMD_DATAIN;
cmd = AMR_CMD_LREAD;
} else {

2
sys/dev/ata/ata-disk.c
View File

@ -337,7 +337,7 @@ ad_start(struct ad_softc *adp)
request->blockaddr = bp->b_pblkno;
request->bytecount = bp->b_bcount;
request->data = bp->b_data;
request->flags = (bp->b_flags & B_READ) ? ADR_F_READ : 0;
request->flags = (bp->b_iocmd == BIO_READ) ? ADR_F_READ : 0;
/* remove from drive queue */
bufq_remove(&adp->queue, bp);

9
sys/dev/ata/atapi-cd.c
View File

@ -1107,7 +1107,6 @@ acd_start(struct atapi_softc *atp)
}
acd_select_slot(cdp);
bzero(ccb, sizeof(ccb));
count = (bp->b_bcount + (cdp->block_size - 1)) / cdp->block_size;
if (bp->b_flags & B_PHYS)
@ -1115,7 +1114,7 @@ acd_start(struct atapi_softc *atp)
else
lba = bp->b_blkno / (cdp->block_size / DEV_BSIZE);
if (bp->b_flags & B_READ) {
if (bp->b_iocmd == BIO_READ) {
/* if transfer goes beyond EOM adjust it to be within limits */
if (lba + count > cdp->info.volsize) {
/* if we are entirely beyond EOM return EOF */
@ -1145,8 +1144,8 @@ acd_start(struct atapi_softc *atp)
devstat_start_transaction(cdp->stats);
atapi_queue_cmd(cdp->atp, ccb, bp->b_data, count * cdp->block_size,
bp->b_flags&B_READ ? ATPR_F_READ : 0, 30, acd_done, bp);
atapi_queue_cmd(cdp->atp, ccb, bp->b_data, bp->b_bcount,
(bp->b_iocmd == BIO_READ)?ATPR_F_READ : 0, 30, acd_done, bp);
}
static int32_t
@ -1161,7 +1160,7 @@ acd_done(struct atapi_request *request)
}
else {
bp->b_resid = bp->b_bcount - request->donecount;
if (!(bp->b_flags & B_READ))
if (bp->b_iocmd == BIO_WRITE)
cdp->flags |= F_WRITTEN;
}
devstat_end_transaction_buf(cdp->stats, bp);

6
sys/dev/ata/atapi-fd.c
View File

@ -321,7 +321,7 @@ afd_start(struct atapi_softc *atp)
bzero(ccb, sizeof(ccb));
if (bp->b_flags & B_READ)
if (bp->b_iocmd == BIO_READ)
ccb[0] = ATAPI_READ_BIG;
else
ccb[0] = ATAPI_WRITE_BIG;
@ -338,7 +338,7 @@ afd_start(struct atapi_softc *atp)
atapi_queue_cmd(fdp->atp, ccb, data_ptr,
fdp->transfersize * fdp->cap.sector_size,
(bp->b_flags & B_READ) ? ATPR_F_READ : 0, 30,
(bp->b_iocmd == BIO_READ) ? ATPR_F_READ : 0, 30,
afd_partial_done, bp);
count -= fdp->transfersize;
@ -354,7 +354,7 @@ afd_start(struct atapi_softc *atp)
ccb[8] = count;
atapi_queue_cmd(fdp->atp, ccb, data_ptr, count * fdp->cap.sector_size,
bp->b_flags&B_READ ? ATPR_F_READ : 0, 30, afd_done, bp);
(bp->b_iocmd == BIO_READ) ? ATPR_F_READ : 0, 30, afd_done, bp);
}
static int32_t

8
sys/dev/ata/atapi-tape.c
View File

@ -421,7 +421,7 @@ aststrategy(struct buf *bp)
biodone(bp);
return;
}
if (!(bp->b_flags & B_READ) && stp->flags & F_WRITEPROTECT) {
if (!(bp->b_iocmd == BIO_READ) && stp->flags & F_WRITEPROTECT) {
bp->b_error = EPERM;
bp->b_flags |= B_ERROR;
biodone(bp);
@ -466,7 +466,7 @@ ast_start(struct atapi_softc *atp)
bzero(ccb, sizeof(ccb));
if (bp->b_flags & B_READ)
if (bp->b_iocmd == BIO_READ)
ccb[0] = ATAPI_READ;
else
ccb[0] = ATAPI_WRITE;
@ -482,7 +482,7 @@ ast_start(struct atapi_softc *atp)
devstat_start_transaction(&stp->stats);
atapi_queue_cmd(stp->atp, ccb, bp->b_data, blkcount * stp->blksize,
bp->b_flags & B_READ ? ATPR_F_READ : 0, 60, ast_done, bp);
(bp->b_iocmd == BIO_READ) ? ATPR_F_READ : 0, 60, ast_done, bp);
}
static int32_t
@ -496,7 +496,7 @@ ast_done(struct atapi_request *request)
bp->b_flags |= B_ERROR;
}
else {
if (!(bp->b_flags & B_READ))
if (!(bp->b_iocmd == BIO_READ))
stp->flags |= F_DATA_WRITTEN;
bp->b_resid = bp->b_bcount - request->donecount;
ast_total += (bp->b_bcount - bp->b_resid);

20
sys/dev/ccd/ccd.c
View File

@ -193,7 +193,7 @@ static void ccdattach __P((void));
static int ccd_modevent __P((module_t, int, void *));
/* called by biodone() at interrupt time */
static void ccdiodone __P((struct ccdbuf *cbp));
static void ccdiodone __P((struct buf *bp));
static void ccdstart __P((struct ccd_softc *, struct buf *));
static void ccdinterleave __P((struct ccd_softc *, int));
@ -887,7 +887,7 @@ ccdstart(cs, bp)
* to writes when making this determination and we
* also try to avoid hogging.
*/
if ((cbp[0]->cb_buf.b_flags & B_READ) == 0) {
if (cbp[0]->cb_buf.b_iocmd == BIO_WRITE) {
cbp[0]->cb_buf.b_vp->v_numoutput++;
cbp[1]->cb_buf.b_vp->v_numoutput++;
VOP_STRATEGY(cbp[0]->cb_buf.b_vp,
@ -911,7 +911,7 @@ ccdstart(cs, bp)
/*
* Not mirroring
*/
if ((cbp[0]->cb_buf.b_flags & B_READ) == 0)
if (cbp[0]->cb_buf.b_iocmd == BIO_WRITE)
cbp[0]->cb_buf.b_vp->v_numoutput++;
VOP_STRATEGY(cbp[0]->cb_buf.b_vp, &cbp[0]->cb_buf);
}
@ -1050,8 +1050,9 @@ ccdbuffer(cb, cs, bp, bn, addr, bcount)
* Fill in the component buf structure.
*/
cbp = getccdbuf(NULL);
cbp->cb_buf.b_flags = bp->b_flags | B_CALL;
cbp->cb_buf.b_iodone = (void (*)(struct buf *))ccdiodone;
cbp->cb_buf.b_flags = bp->b_flags;
cbp->cb_buf.b_iocmd = bp->b_iocmd;
cbp->cb_buf.b_iodone = ccdiodone;
cbp->cb_buf.b_dev = ci->ci_dev; /* XXX */
cbp->cb_buf.b_blkno = cbn + cboff + CCD_OFFSET;
cbp->cb_buf.b_offset = dbtob(cbn + cboff + CCD_OFFSET);
@ -1122,9 +1123,10 @@ ccdintr(cs, bp)
* take a ccd interrupt.
*/
static void
ccdiodone(cbp)
struct ccdbuf *cbp;
ccdiodone(ibp)
struct buf *ibp;
{
struct ccdbuf *cbp = (struct ccdbuf *)ibp;
struct buf *bp = cbp->cb_obp;
int unit = cbp->cb_unit;
int count, s;
@ -1153,7 +1155,7 @@ ccdiodone(cbp)
const char *msg = "";
if ((ccd_softc[unit].sc_cflags & CCDF_MIRROR) &&
(cbp->cb_buf.b_flags & B_READ) &&
(cbp->cb_buf.b_iocmd == BIO_READ) &&
(cbp->cb_pflags & CCDPF_MIRROR_DONE) == 0) {
/*
* We will try our read on the other disk down
@ -1186,7 +1188,7 @@ ccdiodone(cbp)
*/
if (ccd_softc[unit].sc_cflags & CCDF_MIRROR) {
if ((cbp->cb_buf.b_flags & B_READ) == 0) {
if (cbp->cb_buf.b_iocmd == BIO_WRITE) {
/*
* When writing, handshake with the second buffer
* to determine when both are done. If both are not

12
sys/dev/fdc/fdc.c
View File

@ -1620,7 +1620,7 @@ static int fdcpio(fdc_p fdc, long flags, caddr_t addr, u_int count)
{
u_char *cptr = (u_char *)addr;
if (flags & B_READ) {
if (flags == BIO_READ) {
if (fdc->state != PIOREAD) {
fdc->state = PIOREAD;
return(0);
@ -1679,7 +1679,7 @@ fdstate(fdc_p fdc)
fdblk = 128 << fd->ft->secsize;
if (fdc->fd && (fd != fdc->fd))
device_printf(fd->dev, "confused fd pointers\n");
read = bp->b_flags & B_READ;
read = bp->b_iocmd == BIO_READ;
format = bp->b_flags & B_FORMAT;
if (format) {
finfo = (struct fd_formb *)bp->b_data;
@ -1885,7 +1885,7 @@ fdstate(fdc_p fdc)
*/
SET_BCDR(fdc, 1, bp->b_bcount, 0);
(void)fdcpio(fdc,bp->b_flags,
(void)fdcpio(fdc,bp->b_iocmd,
bp->b_data+fd->skip,
bp->b_bcount);
@ -1918,7 +1918,7 @@ fdstate(fdc_p fdc)
* the WRITE command is sent
*/
if (!read)
(void)fdcpio(fdc,bp->b_flags,
(void)fdcpio(fdc,bp->b_iocmd,
bp->b_data+fd->skip,
fdblk);
}
@ -1948,7 +1948,7 @@ fdstate(fdc_p fdc)
* if this is a read, then simply await interrupt
* before performing PIO
*/
if (read && !fdcpio(fdc,bp->b_flags,
if (read && !fdcpio(fdc,bp->b_iocmd,
bp->b_data+fd->skip,fdblk)) {
fd->tohandle = timeout(fd_iotimeout, fdc, hz);
return(0); /* will return later */
@ -1966,7 +1966,7 @@ fdstate(fdc_p fdc)
* actually perform the PIO read. The IOCOMPLETE case
* removes the timeout for us.
*/
(void)fdcpio(fdc,bp->b_flags,bp->b_data+fd->skip,fdblk);
(void)fdcpio(fdc,bp->b_iocmd,bp->b_data+fd->skip,fdblk);
fdc->state = IOCOMPLETE;
/* FALLTHROUGH */
case IOCOMPLETE: /* IO DONE, post-analyze */

2
sys/dev/ida/ida.c
View File

@ -404,7 +404,7 @@ ida_construct_qcb(struct ida_softc *ida)
hwqcb->req.blkno = bp->b_pblkno;
hwqcb->req.bcount = howmany(bp->b_bcount, DEV_BSIZE);
hwqcb->req.command = bp->b_flags & B_READ ? CMD_READ : CMD_WRITE;
hwqcb->req.command = bp->b_iocmd == BIO_READ ? CMD_READ : CMD_WRITE;
STAILQ_INSERT_TAIL(&ida->qcb_queue, qcb, link.stqe);
}

2
sys/dev/ida/ida_disk.c
View File

@ -163,7 +163,7 @@ idstrategy(struct buf *bp)
/*
* software write protect check
*/
if (drv->flags & DRV_WRITEPROT && (bp->b_flags & B_READ) == 0) {
if (drv->flags & DRV_WRITEPROT && (bp->b_iocmd == BIO_WRITE)) {
bp->b_error = EROFS;
goto bad;
}

2
sys/dev/mcd/mcd.c
View File

@ -414,7 +414,7 @@ MCD_TRACE("strategy: drive not valid\n");
}
/* read only */
if (!(bp->b_flags & B_READ)) {
if (!(bp->b_iocmd == BIO_READ)) {
bp->b_error = EROFS;
goto bad;
}

12
sys/dev/md/md.c
View File

@ -191,9 +191,9 @@ mdstrategy_malloc(struct buf *bp)
devstat_start_transaction(&sc->stats);
if (bp->b_flags & B_FREEBUF)
if (bp->b_iocmd == BIO_DELETE)
dop = DEVSTAT_NO_DATA;
else if (bp->b_flags & B_READ)
else if (bp->b_iocmd == BIO_READ)
dop = DEVSTAT_READ;
else
dop = DEVSTAT_WRITE;
@ -220,13 +220,13 @@ mdstrategy_malloc(struct buf *bp)
if (md_debug > 2)
printf("%lx %p %p %d\n", bp->b_flags, secpp, secp, secval);
if (bp->b_flags & B_FREEBUF) {
if (bp->b_iocmd == BIO_DELETE) {
if (secpp) {
if (secp)
FREE(secp, M_MDSECT);
*secpp = 0;
}
} else if (bp->b_flags & B_READ) {
} else if (bp->b_iocmd == BIO_READ) {
if (secp) {
bcopy(secp, dst, DEV_BSIZE);
} else if (secval) {
@ -316,9 +316,9 @@ mdstrategy_preload(struct buf *bp)
devstat_start_transaction(&sc->stats);
if (bp->b_flags & B_FREEBUF) {
if (bp->b_iocmd == BIO_DELETE) {
dop = DEVSTAT_NO_DATA;
} else if (bp->b_flags & B_READ) {
} else if (bp->b_iocmd == BIO_READ) {
dop = DEVSTAT_READ;
bcopy(sc->pl_ptr + (bp->b_pblkno << DEV_BSHIFT), bp->b_data, bp->b_bcount);
} else {

2
sys/dev/mlx/mlx.c
View File

@ -1658,7 +1658,7 @@ mlx_startio(struct mlx_softc *sc)
mc->mc_private = bp;
mc->mc_data = bp->b_data;
mc->mc_length = bp->b_bcount;
if (bp->b_flags & B_READ) {
if (bp->b_iocmd == BIO_READ) {
mc->mc_flags |= MLX_CMD_DATAIN;
cmd = MLX_CMD_READSG;
} else {

2
sys/dev/scd/scd.c
View File

@ -337,7 +337,7 @@ scdstrategy(struct buf *bp)
}
/* read only */
if (!(bp->b_flags & B_READ)) {
if (!(bp->b_iocmd == BIO_READ)) {
bp->b_error = EROFS;
goto bad;
}

2
sys/dev/vinum/vinumdaemon.c
View File

@ -106,7 +106,7 @@ vinum_daemon(void)
log(LOG_WARNING,
"vinum: recovering I/O request: %p\n%s dev %d.%d, offset 0x%x, length %ld\n",
rq,
rq->bp->b_flags & B_READ ? "Read" : "Write",
rq->bp->b_iocmd == BIO_READ ? "Read" : "Write",
major(rq->bp->b_dev),
minor(rq->bp->b_dev),
rq->bp->b_blkno,

4
sys/dev/vinum/vinumext.h
View File

@ -46,8 +46,8 @@ extern int debug; /* debug flags */
#endif
/* Physical read and write drive */
#define read_drive(a, b, c, d) driveio (a, b, c, d, B_READ)
#define write_drive(a, b, c, d) driveio (a, b, c, d, B_WRITE)
#define read_drive(a, b, c, d) driveio (a, b, c, d, BIO_READ)
#define write_drive(a, b, c, d) driveio (a, b, c, d, BIO_WRITE)
#define CHECKALLOC(ptr, msg) \
if (ptr == NULL) \

22
sys/dev/vinum/vinuminterrupt.c
View File

@ -89,7 +89,7 @@ complete_rqe(struct buf *bp)
else if (rq->error == 0) /* no: do we have one already? */
rq->error = EIO; /* no: catchall "I/O error" */
SD[rqe->sdno].lasterror = rq->error;
if (bp->b_flags & B_READ) {
if (bp->b_iocmd == BIO_READ) {
log(LOG_ERR, "%s: fatal read I/O error\n", SD[rqe->sdno].name);
set_sd_state(rqe->sdno, sd_crashed, setstate_force); /* subdisk is crashed */
} else { /* write operation */
@ -105,7 +105,7 @@ complete_rqe(struct buf *bp)
}
}
/* Now update the statistics */
if (bp->b_flags & B_READ) { /* read operation */
if (bp->b_iocmd == BIO_READ) { /* read operation */
DRIVE[rqe->driveno].reads++;
DRIVE[rqe->driveno].bytes_read += bp->b_bcount;
SD[rqe->sdno].reads++;
@ -226,7 +226,7 @@ sdio_done(struct buf *bp)
#endif
sbp->bp->b_resid = sbp->b.b_resid; /* copy the resid field */
/* Now update the statistics */
if (bp->b_flags & B_READ) { /* read operation */
if (bp->b_iocmd == BIO_READ) { /* read operation */
DRIVE[sbp->driveno].reads++;
DRIVE[sbp->driveno].bytes_read += sbp->b.b_bcount;
SD[sbp->sdno].reads++;
@ -340,11 +340,10 @@ complete_raid5_write(struct rqelement *rqe)
} else
panic("complete_raid5_write: malloc conflict");
if ((rqe->b.b_flags & B_READ) /* this was a read */
if ((rqe->b.b_iocmd == BIO_READ) /* this was a read */
&&((rqe->flags & XFR_BAD_SUBDISK) == 0)) { /* and we can write this block */
rqe->b.b_flags &= ~(B_READ | B_DONE); /* we're writing now */
rqe->b.b_flags |= B_CALL; /* call us when you're done */
rqe->b.b_iodone = complete_rqe; /* by calling us here */
rqe->b.b_flags &= ~B_DONE; /* we're writing now */
rqe->b.b_iodone = complete_rqe; /* call us here when done */
rqe->flags &= ~XFR_PARITYOP; /* reset flags that brought us here */
rqe->b.b_data = &bp->b_data[rqe->useroffset << DEV_BSHIFT]; /* point to the user data */
rqe->b.b_bcount = rqe->datalen << DEV_BSHIFT; /* length to write */
@ -365,7 +364,7 @@ complete_raid5_write(struct rqelement *rqe)
if (debug & DEBUG_ADDRESSES)
log(LOG_DEBUG,
" %s dev %d.%d, sd %d, offset 0x%x, devoffset 0x%x, length %ld\n",
rqe->b.b_flags & B_READ ? "Read" : "Write",
rqe->b.b_iocmd == BIO_READ ? "Read" : "Write",
major(rqe->b.b_dev),
minor(rqe->b.b_dev),
rqe->sdno,
@ -382,9 +381,8 @@ complete_raid5_write(struct rqelement *rqe)
}
/* Finally, write the parity block */
rqe = &rqg->rqe[0];
rqe->b.b_flags &= ~(B_READ | B_DONE); /* we're writing now */
rqe->b.b_flags |= B_CALL; /* call us when you're done */
rqe->b.b_iodone = complete_rqe; /* by calling us here */
rqe->b.b_flags &= ~B_DONE; /* we're writing now */
rqe->b.b_iodone = complete_rqe; /* call us here when done */
rqg->flags &= ~XFR_PARITYOP; /* reset flags that brought us here */
rqe->b.b_bcount = rqe->buflen << DEV_BSHIFT; /* length to write */
rqe->b.b_bufsize = rqe->b.b_bcount; /* don't claim we have more */
@ -404,7 +402,7 @@ complete_raid5_write(struct rqelement *rqe)
if (debug & DEBUG_ADDRESSES)
log(LOG_DEBUG,
" %s dev %d.%d, sd %d, offset 0x%x, devoffset 0x%x, length %ld\n",
rqe->b.b_flags & B_READ ? "Read" : "Write",
rqe->b.b_iocmd == BIO_READ ? "Read" : "Write",
major(rqe->b.b_dev),
minor(rqe->b.b_dev),
rqe->sdno,

5
sys/dev/vinum/vinumio.c
View File

@ -297,7 +297,8 @@ driveio(struct drive *drive, char *buf, size_t length, off_t offset, int flag)
int len = min(length, MAXBSIZE); /* maximum block device transfer is MAXBSIZE */
bp = geteblk(len); /* get a buffer header */
bp->b_flags = flag;
bp->b_flags = 0;
bp->b_iocmd = flag;
bp->b_dev = drive->dev; /* device */
bp->b_blkno = offset / drive->partinfo.disklab->d_secsize; /* block number */
bp->b_saveaddr = bp->b_data;
@ -754,7 +755,7 @@ write_volume_label(int volno)
dlp = (struct disklabel *) bp->b_data;
*dlp = *lp;
bp->b_flags &= ~B_INVAL;
bp->b_flags |= B_WRITE;
bp->b_iocmd = BIO_WRITE;
/*
* This should read:

8
sys/dev/vinum/vinumraid5.c
View File

@ -360,7 +360,7 @@ bre5(struct request *rq,
}
if (SD[plex->sdnos[m.psdno]].state < sd_reborn) /* is our parity subdisk down? */
m.badsdno = m.psdno; /* note that it's down */
if (bp->b_flags & B_READ) { /* read operation */
if (bp->b_iocmd == BIO_READ) { /* read operation */
for (mysdno = m.firstsdno; rsectors > 0; mysdno++) {
if (mysdno == m.psdno) /* ignore parity on read */
mysdno++;
@ -493,7 +493,7 @@ bre5(struct request *rq,
rqe->driveno = sd->driveno;
if (build_rq_buffer(rqe, plex)) /* build the buffer */
return REQUEST_ENOMEM; /* can't do it */
rqe->b.b_flags |= B_READ; /* we must read first */
rqe->b.b_iocmd == BIO_READ; /* we must read first */
m.sdcount++; /* adjust the subdisk count */
rqno++; /* and point to the next request */
}
@ -534,7 +534,7 @@ bre5(struct request *rq,
return REQUEST_ENOMEM; /* can't do it */
if ((m.flags & XFR_PARITYOP) /* parity operation, */
&&((m.flags & XFR_BAD_SUBDISK) == 0)) /* and not the bad subdisk, */
rqe->b.b_flags |= B_READ; /* we must read first */
rqe->b.b_iocmd = BIO_READ; /* we must read first */
/* Now update pointers for the next block */
*diskaddr += m.datalen; /* skip past what we've done */
@ -577,7 +577,7 @@ bre5(struct request *rq,
rqe->driveno = sd->driveno;
if (build_rq_buffer(rqe, plex)) /* build the buffer */
return REQUEST_ENOMEM; /* can't do it */
rqe->b.b_flags |= B_READ; /* we must read first */
rqe->b.b_iocmd = BIO_READ; /* we must read first */
}
}
/*

26
sys/dev/vinum/vinumrequest.c
View File

@ -224,7 +224,7 @@ vinumstart(struct buf *bp, int reviveok)
maxplex = 1; /* just the one plex */
}
if (bp->b_flags & B_READ) {
if (bp->b_iocmd == BIO_READ) {
/*
* This is a read request. Decide
* which plex to read from.
@ -337,7 +337,7 @@ launch_requests(struct request *rq, int reviveok)
"Revive conflict sd %d: %p\n%s dev %d.%d, offset 0x%x, length %ld\n",
rq->sdno,
rq,
rq->bp->b_flags & B_READ ? "Read" : "Write",
rq->bp->b_iocmd == BIO_READ ? "Read" : "Write",
major(rq->bp->b_dev),
minor(rq->bp->b_dev),
rq->bp->b_blkno,
@ -351,7 +351,7 @@ launch_requests(struct request *rq, int reviveok)
log(LOG_DEBUG,
"Request: %p\n%s dev %d.%d, offset 0x%x, length %ld\n",
rq,
rq->bp->b_flags & B_READ ? "Read" : "Write",
rq->bp->b_iocmd == BIO_READ ? "Read" : "Write",
major(rq->bp->b_dev),
minor(rq->bp->b_dev),
rq->bp->b_blkno,
@ -406,7 +406,7 @@ launch_requests(struct request *rq, int reviveok)
if (debug & DEBUG_ADDRESSES)
log(LOG_DEBUG,
" %s dev %d.%d, sd %d, offset 0x%x, devoffset 0x%x, length %ld\n",
rqe->b.b_flags & B_READ ? "Read" : "Write",
rqe->b.b_iocmd == BIO_READ ? "Read" : "Write",
major(rqe->b.b_dev),
minor(rqe->b.b_dev),
rqe->sdno,
@ -505,7 +505,7 @@ bre(struct request *rq,
s = checksdstate(sd, rq, *diskaddr, diskend); /* do we need to change state? */
if (s == REQUEST_DOWN) { /* down? */
rqe->flags = XFR_BAD_SUBDISK; /* yup */
if (rq->bp->b_flags & B_READ) /* read request, */
if (rq->bp->b_iocmd == BIO_READ) /* read request, */
return REQUEST_DEGRADED; /* give up here */
/*
* If we're writing, don't give up
@ -589,7 +589,7 @@ bre(struct request *rq,
s = checksdstate(sd, rq, *diskaddr, diskend); /* do we need to change state? */
if (s == REQUEST_DOWN) { /* down? */
rqe->flags = XFR_BAD_SUBDISK; /* yup */
if (rq->bp->b_flags & B_READ) /* read request, */
if (rq->bp->b_iocmd == BIO_READ) /* read request, */
return REQUEST_DEGRADED; /* give up here */
/*
* If we're writing, don't give up
@ -791,8 +791,8 @@ build_rq_buffer(struct rqelement *rqe, struct plex *plex)
/* Initialize the buf struct */
/* copy these flags from user bp */
bp->b_flags = ubp->b_flags & (B_ORDERED | B_NOCACHE | B_READ | B_ASYNC);
bp->b_flags |= B_CALL; /* inform us when it's done */
bp->b_flags = ubp->b_flags & (B_ORDERED | B_NOCACHE | B_ASYNC);
bp->b_iocmd = BIO_READ; /* inform us when it's done */
BUF_LOCKINIT(bp); /* get a lock for the buffer */
BUF_LOCK(bp, LK_EXCLUSIVE); /* and lock it */
@ -891,9 +891,9 @@ sdio(struct buf *bp)
if (drive->state != drive_up) {
if (sd->state >= sd_crashed) {
if (bp->b_flags & B_READ) /* reading, */
if (bp->b_iocmd == BIO_READ) /* reading, */
set_sd_state(sd->sdno, sd_crashed, setstate_force);
else
else if (bp->b_iocmd == BIO_WRITE) /* writing, */
set_sd_state(sd->sdno, sd_stale, setstate_force);
}
bp->b_flags |= B_ERROR;
@ -920,7 +920,7 @@ sdio(struct buf *bp)
return;
}
bzero(sbp, sizeof(struct sdbuf)); /* start with nothing */
sbp->b.b_flags = bp->b_flags | B_CALL; /* inform us when it's done */
sbp->b.b_flags = bp->b_flags;
sbp->b.b_bufsize = bp->b_bufsize; /* buffer size */
sbp->b.b_bcount = bp->b_bcount; /* number of bytes to transfer */
sbp->b.b_resid = bp->b_resid; /* and amount waiting */
@ -947,7 +947,7 @@ sdio(struct buf *bp)
if (debug & DEBUG_ADDRESSES)
log(LOG_DEBUG,
" %s dev %d.%d, sd %d, offset 0x%x, devoffset 0x%x, length %ld\n",
sbp->b.b_flags & B_READ ? "Read" : "Write",
sbp->b.b_iocmd == BIO_READ ? "Read" : "Write",
major(sbp->b.b_dev),
minor(sbp->b.b_dev),
sbp->sdno,
@ -992,7 +992,7 @@ vinum_bounds_check(struct buf *bp, struct volume *vol)
&& bp->b_blkno + size > LABELSECTOR /* and finishes after */
#endif
&& (!(vol->flags & VF_RAW)) /* and it's not raw */
&&(bp->b_flags & B_READ) == 0 /* and it's a write */
&& (bp->b_iocmd == BIO_WRITE) /* and it's a write */
&& (!vol->flags & (VF_WLABEL | VF_LABELLING))) { /* and we're not allowed to write the label */
bp->b_error = EROFS; /* read-only */
bp->b_flags |= B_ERROR;

16
sys/dev/vinum/vinumrevive.c
View File

@ -170,7 +170,8 @@ revive_block(int sdno)
else /* it's an unattached plex */
bp->b_dev = VINUM_PLEX(sd->plexno); /* create the device number */
bp->b_flags = B_READ; /* either way, read it */
bp->b_flags = 0; /* either way, read it */
bp->b_iocmd = BIO_READ; /* either way, read it */
vinumstart(bp, 1);
biowait(bp);
}
@ -181,7 +182,8 @@ revive_block(int sdno)
/* Now write to the subdisk */
{
bp->b_dev = VINUM_SD(sdno); /* create the device number */
bp->b_flags = B_ORDERED | B_WRITE; /* and make this an ordered write */
bp->b_flags = B_ORDERED; /* and make this an ordered write */
bp->b_iocmd = BIO_WRITE; /* and make this an ordered write */
BUF_LOCKINIT(bp); /* get a lock for the buffer */
BUF_LOCK(bp, LK_EXCLUSIVE); /* and lock it */
bp->b_resid = bp->b_bcount;
@ -211,7 +213,7 @@ revive_block(int sdno)
"Relaunch revive conflict sd %d: %p\n%s dev %d.%d, offset 0x%x, length %ld\n",
rq->sdno,
rq,
rq->bp->b_flags & B_READ ? "Read" : "Write",
rq->bp->b_flags == BIO_READ ? "Read" : "Write",
major(rq->bp->b_dev),
minor(rq->bp->b_dev),
rq->bp->b_blkno,
@ -310,8 +312,7 @@ parityops(struct vinum_ioctl_msg *data, enum parityop op)
}
}
} else { /* rebuildparity */
pbp->b_flags &= ~B_READ;
pbp->b_flags |= B_WRITE;
pbp->b_iocmd = BIO_WRITE;
pbp->b_resid = pbp->b_bcount;
BUF_LOCKINIT(pbp); /* get a lock for the buffer */
BUF_LOCK(pbp, LK_EXCLUSIVE); /* and lock it */
@ -404,7 +405,8 @@ parityrebuild(struct plex *plex,
bzero(parity_buf, mysize);
}
bpp[sdno]->b_dev = VINUM_SD(plex->sdnos[sdno]); /* device number */
bpp[sdno]->b_flags = B_READ; /* either way, read it */
bpp[sdno]->b_flags = 0; /* either way, read it */
bpp[sdno]->b_iocmd = BIO_READ; /* either way, read it */
bpp[sdno]->b_bcount = bpp[sdno]->b_bufsize;
bpp[sdno]->b_resid = bpp[sdno]->b_bcount;
bpp[sdno]->b_blkno = pstripe; /* read from here */
@ -557,7 +559,7 @@ initsd(int sdno, int verify)
bp->b_resid = bp->b_bcount;
bp->b_blkno = sd->initialized; /* read from here */
bp->b_dev = VINUM_SD(sdno); /* create the device number */
bp->b_flags |= B_READ; /* read it back */
bp->b_iocmd = BIO_READ; /* read it back */
splx(s);
BUF_LOCKINIT(bp); /* get a lock for the buffer */
BUF_LOCK(bp, LK_EXCLUSIVE); /* and lock it */

2
sys/dev/vinum/vinumstate.c
View File

@ -617,7 +617,7 @@ enum requeststatus
checksdstate(struct sd *sd, struct request *rq, daddr_t diskaddr, daddr_t diskend)
{
struct plex *plex = &PLEX[sd->plexno];
int writeop = (rq->bp->b_flags & B_READ) == 0; /* note if we're writing */
int writeop = (rq->bp->b_iocmd == BIO_WRITE); /* note if we're writing */
switch (sd->state) {
/* We shouldn't get called if the subdisk is up */

14
sys/dev/vn/vn.c
View File

@ -101,7 +101,7 @@ static d_strategy_t vnstrategy;
/*
* cdevsw
* D_DISK we want to look like a disk
* D_CANFREE We support B_FREEBUF
* D_CANFREE We support BIO_DELETE
*/
static struct cdevsw vn_cdevsw = {
@ -286,7 +286,7 @@ vnstrategy(struct buf *bp)
unit = dkunit(bp->b_dev);
vn = bp->b_dev->si_drv1;
if (!vn)
if (vn == NULL)
vn = vnfindvn(bp->b_dev);
IFOPT(vn, VN_DEBUG)
@ -349,7 +349,7 @@ vnstrategy(struct buf *bp)
bp->b_pblkno = pbn;
}
if (vn->sc_vp && (bp->b_flags & B_FREEBUF)) {
if (vn->sc_vp && (bp->b_iocmd == BIO_DELETE)) {
/*
* Not handled for vnode-backed element yet.
*/
@ -368,7 +368,7 @@ vnstrategy(struct buf *bp)
auio.uio_iovcnt = 1;
auio.uio_offset = (vm_ooffset_t)bp->b_pblkno * vn->sc_secsize;
auio.uio_segflg = UIO_SYSSPACE;
if( bp->b_flags & B_READ)
if(bp->b_iocmd == BIO_READ)
auio.uio_rw = UIO_READ;
else
auio.uio_rw = UIO_WRITE;
@ -378,7 +378,7 @@ vnstrategy(struct buf *bp)
isvplocked = 1;
vn_lock(vn->sc_vp, LK_EXCLUSIVE | LK_RETRY, curproc);
}
if( bp->b_flags & B_READ)
if(bp->b_iocmd == BIO_READ)
error = VOP_READ(vn->sc_vp, &auio, 0, vn->sc_cred);
else
error = VOP_WRITE(vn->sc_vp, &auio, 0, vn->sc_cred);
@ -399,12 +399,12 @@ vnstrategy(struct buf *bp)
*
* ( handles read, write, freebuf )
*
* Note: if we pre-reserved swap, B_FREEBUF is disabled
* Note: if we pre-reserved swap, BIO_DELETE is disabled
*/
KASSERT((bp->b_bufsize & (vn->sc_secsize - 1)) == 0,
("vnstrategy: buffer %p too small for physio", bp));
if ((bp->b_flags & B_FREEBUF) && TESTOPT(vn, VN_RESERVE)) {
if ((bp->b_iocmd == BIO_DELETE) && TESTOPT(vn, VN_RESERVE)) {
biodone(bp);
} else {
vm_pager_strategy(vn->sc_object, bp);

2
sys/fs/ntfs/ntfs_vnops.c
View File

@ -345,7 +345,7 @@ ntfs_strategy(ap)
dprintf(("strategy: bcount: %d flags: 0x%lx\n",
(u_int32_t)bp->b_bcount,bp->b_flags));
if (bp->b_flags & B_READ) {
if (bp->b_iocmd == BIO_READ) {
u_int32_t toread;
if (ntfs_cntob(bp->b_blkno) >= fp->f_size) {

2
sys/fs/nwfs/nwfs_io.c
View File

@ -275,7 +275,7 @@ nwfs_doio(bp, cr, p)
uiop->uio_iovcnt = 1;
uiop->uio_segflg = UIO_SYSSPACE;
uiop->uio_procp = p;
if (bp->b_flags & B_READ) {
if (bp->b_iocmd == BIO_READ) {
io.iov_len = uiop->uio_resid = bp->b_bcount;
io.iov_base = bp->b_data;
uiop->uio_rw = UIO_READ;

2
sys/fs/nwfs/nwfs_vnops.c
View File

@ -812,7 +812,7 @@ static int nwfs_strategy (ap)
p = (struct proc *)0;
else
p = curproc; /* XXX */
if (bp->b_flags & B_READ)
if (bp->b_iocmd == BIO_READ)
cr = bp->b_rcred;
else
cr = bp->b_wcred;

8
sys/fs/specfs/spec_vnops.c
View File

@ -407,7 +407,7 @@ spec_strategy(ap)
struct mount *mp;
bp = ap->a_bp;
if (((bp->b_flags & B_READ) == 0) &&
if ((bp->b_iocmd == BIO_WRITE) &&
(LIST_FIRST(&bp->b_dep)) != NULL && bioops.io_start)
(*bioops.io_start)(bp);
@ -417,7 +417,7 @@ spec_strategy(ap)
*/
vp = ap->a_vp;
if (vn_isdisk(vp, NULL) && (mp = vp->v_specmountpoint) != NULL) {
if ((bp->b_flags & B_READ) == 0) {
if (bp->b_iocmd == BIO_WRITE) {
if (bp->b_lock.lk_lockholder == LK_KERNPROC)
mp->mnt_stat.f_asyncwrites++;
else
@ -458,7 +458,7 @@ spec_freeblks(ap)
if ((bsw->d_flags & D_CANFREE) == 0)
return (0);
bp = geteblk(ap->a_length);
bp->b_flags |= B_FREEBUF;
bp->b_iocmd = BIO_DELETE;
bp->b_dev = ap->a_vp->v_rdev;
bp->b_blkno = ap->a_addr;
bp->b_offset = dbtob(ap->a_addr);
@ -657,7 +657,7 @@ spec_getpages(ap)
pmap_qenter(kva, ap->a_m, pcount);
/* Build a minimal buffer header. */
bp->b_flags = B_READ | B_CALL;
bp->b_iocmd = BIO_READ;
bp->b_iodone = spec_getpages_iodone;
/* B_PHYS is not set, but it is nice to fill this in. */

2
sys/fs/unionfs/union_vnops.c
View File

@ -1923,7 +1923,7 @@ union_strategy(ap)
#ifdef DIAGNOSTIC
if (othervp == NULLVP)
panic("union_strategy: nil vp");
if (((bp->b_flags & B_READ) == 0) &&
if ((bp->b_iocmd == BIO_WRITE) &&
(othervp == LOWERVP(bp->b_vp)))
panic("union_strategy: writing to lowervp");
#endif

20
sys/geom/geom_ccd.c
View File

@ -193,7 +193,7 @@ static void ccdattach __P((void));
static int ccd_modevent __P((module_t, int, void *));
/* called by biodone() at interrupt time */
static void ccdiodone __P((struct ccdbuf *cbp));
static void ccdiodone __P((struct buf *bp));
static void ccdstart __P((struct ccd_softc *, struct buf *));
static void ccdinterleave __P((struct ccd_softc *, int));
@ -887,7 +887,7 @@ ccdstart(cs, bp)
* to writes when making this determination and we
* also try to avoid hogging.
*/
if ((cbp[0]->cb_buf.b_flags & B_READ) == 0) {
if (cbp[0]->cb_buf.b_iocmd == BIO_WRITE) {
cbp[0]->cb_buf.b_vp->v_numoutput++;
cbp[1]->cb_buf.b_vp->v_numoutput++;
VOP_STRATEGY(cbp[0]->cb_buf.b_vp,
@ -911,7 +911,7 @@ ccdstart(cs, bp)
/*
* Not mirroring
*/
if ((cbp[0]->cb_buf.b_flags & B_READ) == 0)
if (cbp[0]->cb_buf.b_iocmd == BIO_WRITE)
cbp[0]->cb_buf.b_vp->v_numoutput++;
VOP_STRATEGY(cbp[0]->cb_buf.b_vp, &cbp[0]->cb_buf);
}
@ -1050,8 +1050,9 @@ ccdbuffer(cb, cs, bp, bn, addr, bcount)
* Fill in the component buf structure.
*/
cbp = getccdbuf(NULL);
cbp->cb_buf.b_flags = bp->b_flags | B_CALL;
cbp->cb_buf.b_iodone = (void (*)(struct buf *))ccdiodone;
cbp->cb_buf.b_flags = bp->b_flags;
cbp->cb_buf.b_iocmd = bp->b_iocmd;
cbp->cb_buf.b_iodone = ccdiodone;
cbp->cb_buf.b_dev = ci->ci_dev; /* XXX */
cbp->cb_buf.b_blkno = cbn + cboff + CCD_OFFSET;
cbp->cb_buf.b_offset = dbtob(cbn + cboff + CCD_OFFSET);
@ -1122,9 +1123,10 @@ ccdintr(cs, bp)
* take a ccd interrupt.
*/
static void
ccdiodone(cbp)
struct ccdbuf *cbp;
ccdiodone(ibp)
struct buf *ibp;
{
struct ccdbuf *cbp = (struct ccdbuf *)ibp;
struct buf *bp = cbp->cb_obp;
int unit = cbp->cb_unit;
int count, s;
@ -1153,7 +1155,7 @@ ccdiodone(cbp)
const char *msg = "";
if ((ccd_softc[unit].sc_cflags & CCDF_MIRROR) &&
(cbp->cb_buf.b_flags & B_READ) &&
(cbp->cb_buf.b_iocmd == BIO_READ) &&
(cbp->cb_pflags & CCDPF_MIRROR_DONE) == 0) {
/*
* We will try our read on the other disk down
@ -1186,7 +1188,7 @@ ccdiodone(cbp)
*/
if (ccd_softc[unit].sc_cflags & CCDF_MIRROR) {
if ((cbp->cb_buf.b_flags & B_READ) == 0) {
if (cbp->cb_buf.b_iocmd == BIO_WRITE) {
/*
* When writing, handshake with the second buffer
* to determine when both are done. If both are not

2
sys/gnu/ext2fs/ext2_bmap.c
View File

@ -192,7 +192,7 @@ ufs_bmaparray(vp, bn, bnp, ap, nump, runp, runb)
panic("ufs_bmaparray: indirect block not in cache");
#endif
bp->b_blkno = blkptrtodb(ump, daddr);
bp->b_flags |= B_READ;
bp->b_iocmd = BIO_READ;
bp->b_flags &= ~(B_INVAL|B_ERROR);
vfs_busy_pages(bp, 0);
VOP_STRATEGY(bp->b_vp, bp);

4
sys/gnu/ext2fs/ext2_inode.c
View File

@ -37,6 +37,8 @@
* SUCH DAMAGE.
*
* @(#)ext2_inode.c 8.5 (Berkeley) 12/30/93
*
* $FreeBSD$
*/
#include "opt_quota.h"
@ -416,7 +418,7 @@ ext2_indirtrunc(ip, lbn, dbn, lastbn, level, countp)
bp = getblk(vp, lbn, (int)fs->s_blocksize, 0, 0);
if (bp->b_flags & (B_DONE | B_DELWRI)) {
} else {
bp->b_flags |= B_READ;
bp->b_iocmd = BIO_READ;
if (bp->b_bcount > bp->b_bufsize)
panic("ext2_indirtrunc: bad buffer size");
bp->b_blkno = dbn;

2
sys/gnu/fs/ext2fs/ext2_bmap.c
View File

@ -192,7 +192,7 @@ ufs_bmaparray(vp, bn, bnp, ap, nump, runp, runb)
panic("ufs_bmaparray: indirect block not in cache");
#endif
bp->b_blkno = blkptrtodb(ump, daddr);
bp->b_flags |= B_READ;
bp->b_iocmd = BIO_READ;
bp->b_flags &= ~(B_INVAL|B_ERROR);
vfs_busy_pages(bp, 0);
VOP_STRATEGY(bp->b_vp, bp);

4
sys/gnu/fs/ext2fs/ext2_inode.c
View File

@ -37,6 +37,8 @@
* SUCH DAMAGE.
*
* @(#)ext2_inode.c 8.5 (Berkeley) 12/30/93
*
* $FreeBSD$
*/
#include "opt_quota.h"
@ -416,7 +418,7 @@ ext2_indirtrunc(ip, lbn, dbn, lastbn, level, countp)
bp = getblk(vp, lbn, (int)fs->s_blocksize, 0, 0);
if (bp->b_flags & (B_DONE | B_DELWRI)) {
} else {
bp->b_flags |= B_READ;
bp->b_iocmd = BIO_READ;
if (bp->b_bcount > bp->b_bufsize)
panic("ext2_indirtrunc: bad buffer size");
bp->b_blkno = dbn;

1
sys/i386/i386/genassym.c
View File

@ -153,7 +153,6 @@ ASSYM(SC_GS, offsetof(struct osigcontext, sc_gs));
ASSYM(SC_TRAPNO, offsetof(struct osigcontext, sc_trapno));
ASSYM(UC_EFLAGS, offsetof(ucontext_t, uc_mcontext.mc_eflags));
ASSYM(UC_GS, offsetof(ucontext_t, uc_mcontext.mc_gs));
ASSYM(B_READ, B_READ);
ASSYM(ENOENT, ENOENT);
ASSYM(EFAULT, EFAULT);
ASSYM(ENAMETOOLONG, ENAMETOOLONG);

4
sys/i386/i386/machdep.c
View File

@ -2360,7 +2360,7 @@ bounds_check_with_label(struct buf *bp, struct disklabel *lp, int wlabel)
#if LABELSECTOR != 0
bp->b_blkno + p->p_offset + sz > LABELSECTOR + labelsect &&
#endif
(bp->b_flags & B_READ) == 0 && wlabel == 0) {
(bp->b_iocmd == BIO_WRITE) && wlabel == 0) {
bp->b_error = EROFS;
goto bad;
}
@ -2368,7 +2368,7 @@ bounds_check_with_label(struct buf *bp, struct disklabel *lp, int wlabel)
#if defined(DOSBBSECTOR) && defined(notyet)
/* overwriting master boot record? */
if (bp->b_blkno + p->p_offset <= DOSBBSECTOR &&
(bp->b_flags & B_READ) == 0 && wlabel == 0) {
(bp->b_iocmd == BIO_WRITE) && wlabel == 0) {
bp->b_error = EROFS;
goto bad;
}

2
sys/i386/i386/vm_machdep.c
View File

@ -357,7 +357,7 @@ vmapbuf(bp)
* when reading stuff off device into memory.
*/
vm_fault_quick(addr,
(bp->b_flags&B_READ)?(VM_PROT_READ|VM_PROT_WRITE):VM_PROT_READ);
(bp->b_iocmd == BIO_READ)?(VM_PROT_READ|VM_PROT_WRITE):VM_PROT_READ);
pa = trunc_page(pmap_kextract((vm_offset_t) addr));
if (pa == 0)
panic("vmapbuf: page not present");

4
sys/i386/isa/labpc.c
View File

@ -992,7 +992,7 @@ labpcstrategy(struct buf *bp)
struct ctlr *ctlr = labpcs[UNIT(bp->b_dev)];
if (DIGITAL(bp->b_dev)) {
if (bp->b_flags & B_READ) {
if (bp->b_iocmd == BIO_READ) {
ctlr->starter = null_start;
ctlr->stop = all_stop;
ctlr->intr = null_intr;
@ -1007,7 +1007,7 @@ labpcstrategy(struct buf *bp)
}
}
else {
if (bp->b_flags & B_READ) {
if (bp->b_iocmd == BIO_READ) {
ctlr->starter = INTERVAL(ctlr->dev) ? ad_interval_start : ad_start;
ctlr->stop = all_stop;

2
sys/i386/isa/matcd/matcd.c
View File

@ -876,7 +876,7 @@ void matcdstrategy(struct buf *bp)
goto bad;
}
if (!(bp->b_flags & B_READ)) {
if (!(bp->b_iocmd == BIO_READ)) {
bp->b_error = EROFS;
goto bad;
}

2
sys/i386/isa/mcd.c
View File

@ -414,7 +414,7 @@ MCD_TRACE("strategy: drive not valid\n");
}
/* read only */
if (!(bp->b_flags & B_READ)) {
if (!(bp->b_iocmd == BIO_READ)) {
bp->b_error = EROFS;
goto bad;
}

2
sys/i386/isa/scd.c
View File

@ -337,7 +337,7 @@ scdstrategy(struct buf *bp)
}
/* read only */
if (!(bp->b_flags & B_READ)) {
if (!(bp->b_iocmd == BIO_READ)) {
bp->b_error = EROFS;
goto bad;
}

22
sys/i386/isa/wd.c
View File

@ -700,7 +700,7 @@ wdstart(int ctrlr)
#ifdef WDDEBUG
if (du->dk_skip == 0)
printf("wd%d: wdstart: %s %d@%d; map ", lunit,
(bp->b_flags & B_READ) ? "read" : "write",
(bp->b_iocmd == BIO_READ) ? "read" : "write",
bp->b_bcount, blknum);
else
printf(" %d)%x", du->dk_skip, inb(du->dk_altport));
@ -734,7 +734,7 @@ wdstart(int ctrlr)
* XXX this looks like an attempt to skip bad sectors
* on write.
*/
if (wdtab[ctrlr].b_errcnt && (bp->b_flags & B_READ) == 0)
if (wdtab[ctrlr].b_errcnt && (bp->b_iocmd == BIO_WRITE))
du->dk_bc += DEV_BSIZE;
count1 = howmany( du->dk_bc, DEV_BSIZE);
@ -742,7 +742,7 @@ wdstart(int ctrlr)
du->dk_flags &= ~DKFL_MULTI;
if (du->dk_flags & DKFL_SINGLE) {
command = (bp->b_flags & B_READ)
command = (bp->b_iocmd == BIO_READ)
? WDCC_READ : WDCC_WRITE;
count1 = 1;
du->dk_currentiosize = 1;
@ -752,16 +752,16 @@ wdstart(int ctrlr)
(void *)((int)bp->b_data +
du->dk_skip * DEV_BSIZE),
du->dk_bc,
bp->b_flags & B_READ)) {
bp->b_iocmd == BIO_READ)) {
du->dk_flags |= DKFL_DMA;
if( bp->b_flags & B_READ)
if(bp->b_iocmd == BIO_READ)
command = WDCC_READ_DMA;
else
command = WDCC_WRITE_DMA;
du->dk_currentiosize = count1;
} else if( (count1 > 1) && (du->dk_multi > 1)) {
du->dk_flags |= DKFL_MULTI;
if( bp->b_flags & B_READ) {
if(bp->b_iocmd == BIO_READ) {
command = WDCC_READ_MULTI;
} else {
command = WDCC_WRITE_MULTI;
@ -770,7 +770,7 @@ wdstart(int ctrlr)
if( du->dk_currentiosize > count1)
du->dk_currentiosize = count1;
} else {
if( bp->b_flags & B_READ) {
if(bp->b_iocmd == BIO_READ) {
command = WDCC_READ;
} else {
command = WDCC_WRITE;
@ -797,7 +797,7 @@ wdstart(int ctrlr)
(void *)((int)bp->b_data +
du->dk_skip * DEV_BSIZE),
du->dk_bc,
bp->b_flags & B_READ);
bp->b_iocmd == BIO_READ);
}
while (wdcommand(du, cylin, head, sector, count1, command)
!= 0) {
@ -842,7 +842,7 @@ wdstart(int ctrlr)
}
/* If this is a read operation, just go away until it's done. */
if (bp->b_flags & B_READ)
if (bp->b_iocmd == BIO_READ)
return;
/* Ready to send data? */
@ -1010,7 +1010,7 @@ wdintr(void *unitnum)
/*
* If this was a successful read operation, fetch the data.
*/
if (((bp->b_flags & (B_READ | B_ERROR)) == B_READ)
if ((bp->b_iocmd == BIO_READ && !(bp->b_flags & B_ERROR))
&& !((du->dk_flags & (DKFL_DMA|DKFL_SINGLE)) == DKFL_DMA)
&& wdtab[unit].b_active) {
u_int chk, dummy, multisize;
@ -1074,7 +1074,7 @@ wdintr(void *unitnum)
/* see if more to transfer */
if (du->dk_bc > 0 && (du->dk_flags & DKFL_ERROR) == 0) {
if( (du->dk_flags & DKFL_SINGLE) ||
((bp->b_flags & B_READ) == 0)) {
(bp->b_iocmd == BIO_WRITE)) {
wdtab[unit].b_active = 0;
wdstart(unit);
} else {

7
sys/i386/isa/wt.c
View File

@ -527,7 +527,7 @@ wtstrategy (struct buf *bp)
goto err2xit;
}
if (bp->b_flags & B_READ) {
if (bp->b_iocmd == BIO_READ) {
/* Check read access and no previous write to this tape. */
if (! (t->flags & TPREAD) || (t->flags & TPWANY))
goto errxit;
@ -566,8 +566,9 @@ wtstrategy (struct buf *bp)
t->flags &= ~TPEXCEP;
s = splbio ();
if (wtstart (t, bp->b_flags & B_READ ? ISADMA_READ : ISADMA_WRITE, bp->b_data, bp->b_bcount)) {
wtwait (t, 0, (bp->b_flags & B_READ) ? "wtread" : "wtwrite");
if (wtstart (t, bp->b_iocmd == BIO_READ ? ISADMA_READ : ISADMA_WRITE,
bp->b_data, bp->b_bcount)) {
wtwait (t, 0, (bp->b_iocmd == BIO_READ) ? "wtread" : "wtwrite");
bp->b_resid -= t->dmacount;
}
splx (s);

12
sys/isa/fd.c
View File

@ -1620,7 +1620,7 @@ static int fdcpio(fdc_p fdc, long flags, caddr_t addr, u_int count)
{
u_char *cptr = (u_char *)addr;
if (flags & B_READ) {
if (flags == BIO_READ) {
if (fdc->state != PIOREAD) {
fdc->state = PIOREAD;
return(0);
@ -1679,7 +1679,7 @@ fdstate(fdc_p fdc)
fdblk = 128 << fd->ft->secsize;
if (fdc->fd && (fd != fdc->fd))
device_printf(fd->dev, "confused fd pointers\n");
read = bp->b_flags & B_READ;
read = bp->b_iocmd == BIO_READ;
format = bp->b_flags & B_FORMAT;
if (format) {
finfo = (struct fd_formb *)bp->b_data;
@ -1885,7 +1885,7 @@ fdstate(fdc_p fdc)
*/
SET_BCDR(fdc, 1, bp->b_bcount, 0);
(void)fdcpio(fdc,bp->b_flags,
(void)fdcpio(fdc,bp->b_iocmd,
bp->b_data+fd->skip,
bp->b_bcount);
@ -1918,7 +1918,7 @@ fdstate(fdc_p fdc)
* the WRITE command is sent
*/
if (!read)
(void)fdcpio(fdc,bp->b_flags,
(void)fdcpio(fdc,bp->b_iocmd,
bp->b_data+fd->skip,
fdblk);
}
@ -1948,7 +1948,7 @@ fdstate(fdc_p fdc)
* if this is a read, then simply await interrupt
* before performing PIO
*/
if (read && !fdcpio(fdc,bp->b_flags,
if (read && !fdcpio(fdc,bp->b_iocmd,
bp->b_data+fd->skip,fdblk)) {
fd->tohandle = timeout(fd_iotimeout, fdc, hz);
return(0); /* will return later */
@ -1966,7 +1966,7 @@ fdstate(fdc_p fdc)
* actually perform the PIO read. The IOCOMPLETE case
* removes the timeout for us.
*/
(void)fdcpio(fdc,bp->b_flags,bp->b_data+fd->skip,fdblk);
(void)fdcpio(fdc,bp->b_iocmd,bp->b_data+fd->skip,fdblk);
fdc->state = IOCOMPLETE;
/* FALLTHROUGH */
case IOCOMPLETE: /* IO DONE, post-analyze */

8
sys/kern/kern_physio.c
View File

@ -33,7 +33,6 @@ static void
physwakeup(struct buf *bp)
{
wakeup((caddr_t) bp);
bp->b_flags &= ~B_CALL;
}
int
@ -63,10 +62,11 @@ physio(dev_t dev, struct uio *uio, int ioflag)
for (i = 0; i < uio->uio_iovcnt; i++) {
while (uio->uio_iov[i].iov_len) {
bp->b_flags = B_PHYS;
if (uio->uio_rw == UIO_READ)
bp->b_flags = B_PHYS | B_CALL | B_READ;
bp->b_iocmd = BIO_READ;
else
bp->b_flags = B_PHYS | B_CALL | B_WRITE;
bp->b_iocmd = BIO_WRITE;
bp->b_dev = dev;
bp->b_iodone = physwakeup;
bp->b_data = uio->uio_iov[i].iov_base;
@ -101,7 +101,7 @@ physio(dev_t dev, struct uio *uio, int ioflag)
if (uio->uio_segflg == UIO_USERSPACE) {
if (!useracc(bp->b_data, bp->b_bufsize,
bp->b_flags & B_READ ?
bp->b_iocmd == BIO_READ ?
VM_PROT_WRITE : VM_PROT_READ)) {
error = EFAULT;
goto doerror;

4
sys/kern/subr_devstat.c
View File

@ -233,9 +233,9 @@ devstat_end_transaction_buf(struct devstat *ds, struct buf *bp)
{
devstat_trans_flags flg;
if (bp->b_flags & B_FREEBUF)
if (bp->b_iocmd == BIO_DELETE)
flg = DEVSTAT_FREE;
else if (bp->b_flags & B_READ)
else if (bp->b_iocmd == BIO_READ)
flg = DEVSTAT_READ;
else
flg = DEVSTAT_WRITE;

12
sys/kern/subr_disklabel.c
View File

@ -181,7 +181,7 @@ readdisklabel(dev, lp)
bp->b_blkno = LABELSECTOR * ((int)lp->d_secsize/DEV_BSIZE);
bp->b_bcount = lp->d_secsize;
bp->b_flags &= ~B_INVAL;
bp->b_flags |= B_READ;
bp->b_iocmd = BIO_READ;
BUF_STRATEGY(bp, 1);
if (biowait(bp))
msg = "I/O error";
@ -284,7 +284,7 @@ writedisklabel(dev, lp)
* (also stupid.. how do you write the first one? by raw writes?)
*/
bp->b_flags &= ~B_INVAL;
bp->b_flags |= B_READ;
bp->b_iocmd = BIO_READ;
BUF_STRATEGY(bp, 1);
error = biowait(bp);
if (error)
@ -296,8 +296,8 @@ writedisklabel(dev, lp)
if (dlp->d_magic == DISKMAGIC && dlp->d_magic2 == DISKMAGIC &&
dkcksum(dlp) == 0) {
*dlp = *lp;
bp->b_flags &= ~(B_DONE | B_READ);
bp->b_flags |= B_WRITE;
bp->b_flags &= ~B_DONE;
bp->b_iocmd = BIO_WRITE;
#ifdef __alpha__
alpha_fix_srm_checksum(bp);
#endif
@ -313,7 +313,7 @@ writedisklabel(dev, lp)
dlp = (struct disklabel *)bp->b_data;
*dlp = *lp;
bp->b_flags &= ~B_INVAL;
bp->b_flags |= B_WRITE;
bp->b_iocmd = BIO_WRITE;
BUF_STRATEGY(bp, 1);
error = biowait(bp);
#endif
@ -375,7 +375,7 @@ diskerr(bp, what, pri, blkdone, lp)
pr = printf;
sname = dsname(bp->b_dev, unit, slice, part, partname);
(*pr)("%s%s: %s %sing fsbn ", sname, partname, what,
bp->b_flags & B_READ ? "read" : "writ");
bp->b_iocmd == BIO_READ ? "read" : "writ");
sn = bp->b_blkno;
if (bp->b_bcount <= DEV_BSIZE)
(*pr)("%ld", (long)sn);

4
sys/kern/subr_diskmbr.c
View File

@ -187,7 +187,7 @@ dsinit(dev, lp, sspp)
bp->b_dev = dkmodpart(dkmodslice(dev, WHOLE_DISK_SLICE), RAW_PART);
bp->b_blkno = mbr_offset;
bp->b_bcount = lp->d_secsize;
bp->b_flags |= B_READ;
bp->b_iocmd = BIO_READ;
BUF_STRATEGY(bp, 1);
if (biowait(bp) != 0) {
diskerr(bp, "reading primary partition table: error",
@ -403,7 +403,7 @@ mbr_extended(dev, lp, ssp, ext_offset, ext_size, base_ext_offset, nsectors,
bp->b_dev = dev;
bp->b_blkno = ext_offset;
bp->b_bcount = lp->d_secsize;
bp->b_flags |= B_READ;
bp->b_iocmd = BIO_READ;
BUF_STRATEGY(bp, 1);
if (biowait(bp) != 0) {
diskerr(bp, "reading extended partition table: error",

12
sys/kern/subr_diskslice.c
View File

@ -208,14 +208,14 @@ if (labelsect != 0) Debugger("labelsect != 0 in dscheck()");
#if LABELSECTOR != 0
slicerel_secno + nsec > LABELSECTOR + labelsect &&
#endif
(bp->b_flags & B_READ) == 0 && sp->ds_wlabel == 0) {
(bp->b_iocmd == BIO_WRITE) && sp->ds_wlabel == 0) {
bp->b_error = EROFS;
goto bad;
}
#if defined(DOSBBSECTOR) && defined(notyet)
/* overwriting master boot record? */
if (slicerel_secno <= DOSBBSECTOR && (bp->b_flags & B_READ) == 0 &&
if (slicerel_secno <= DOSBBSECTOR && (bp->b_iocmd == BIO_WRITE) &&
sp->ds_wlabel == 0) {
bp->b_error = EROFS;
goto bad;
@ -259,10 +259,9 @@ if (labelsect != 0) Debugger("labelsect != 0 in dscheck()");
ic->ic_args[0].ia_long = (LABELSECTOR + labelsect -
slicerel_secno) * ssp->dss_secsize;
ic->ic_args[1].ia_ptr = sp;
bp->b_flags |= B_CALL;
bp->b_iodone = dsiodone;
bp->b_iodone_chain = ic;
if (!(bp->b_flags & B_READ)) {
if (!(bp->b_iocmd == BIO_READ)) {
/*
* XXX even disklabel(8) writes directly so we need
* to adjust writes. Perhaps we should drop support
@ -537,11 +536,10 @@ dsiodone(bp)
char *msg;
ic = bp->b_iodone_chain;
bp->b_flags = (ic->ic_prev_flags & B_CALL)
| (bp->b_flags & ~(B_CALL | B_DONE));
bp->b_flags = bp->b_flags & ~B_DONE;
bp->b_iodone = ic->ic_prev_iodone;
bp->b_iodone_chain = ic->ic_prev_iodone_chain;
if (!(bp->b_flags & B_READ)
if (!(bp->b_iocmd == BIO_READ)
|| (!(bp->b_flags & B_ERROR) && bp->b_error == 0)) {
msg = fixlabel((char *)NULL, ic->ic_args[1].ia_ptr,
(struct disklabel *)

7
sys/kern/vfs_aio.c
View File

@ -996,20 +996,20 @@ aio_qphysio(struct proc *p, struct aiocblist *aiocbe)
bp->b_bcount = cb->aio_nbytes;
bp->b_bufsize = cb->aio_nbytes;
bp->b_flags = B_PHYS | B_CALL;
bp->b_flags = B_PHYS;
bp->b_iodone = aio_physwakeup;
bp->b_saveaddr = bp->b_data;
bp->b_data = (void *)cb->aio_buf;
bp->b_blkno = btodb(cb->aio_offset);
if (cb->aio_lio_opcode == LIO_WRITE) {
bp->b_flags |= B_WRITE;
bp->b_iocmd = BIO_WRITE;
if (!useracc(bp->b_data, bp->b_bufsize, VM_PROT_READ)) {
error = EFAULT;
goto doerror;
}
} else {
bp->b_flags |= B_READ;
bp->b_iocmd = BIO_READ;
if (!useracc(bp->b_data, bp->b_bufsize, VM_PROT_WRITE)) {
error = EFAULT;
goto doerror;
@ -2132,7 +2132,6 @@ aio_physwakeup(struct buf *bp)
s = splbio();
wakeup((caddr_t)bp);
bp->b_flags &= ~B_CALL;
bp->b_flags |= B_DONE;
aiocbe = (struct aiocblist *)bp->b_spc;

56
sys/kern/vfs_bio.c
View File

@ -501,7 +501,7 @@ bread(struct vnode * vp, daddr_t blkno, int size, struct ucred * cred,
if (curproc != NULL)
curproc->p_stats->p_ru.ru_inblock++;
KASSERT(!(bp->b_flags & B_ASYNC), ("bread: illegal async bp %p", bp));
bp->b_flags |= B_READ;
bp->b_iocmd = BIO_READ;
bp->b_flags &= ~(B_ERROR | B_INVAL);
if (bp->b_rcred == NOCRED) {
if (cred != NOCRED)
@ -536,7 +536,7 @@ breadn(struct vnode * vp, daddr_t blkno, int size,
if ((bp->b_flags & B_CACHE) == 0) {
if (curproc != NULL)
curproc->p_stats->p_ru.ru_inblock++;
bp->b_flags |= B_READ;
bp->b_iocmd = BIO_READ;
bp->b_flags &= ~(B_ERROR | B_INVAL);
if (bp->b_rcred == NOCRED) {
if (cred != NOCRED)
@ -556,8 +556,9 @@ breadn(struct vnode * vp, daddr_t blkno, int size,
if ((rabp->b_flags & B_CACHE) == 0) {
if (curproc != NULL)
curproc->p_stats->p_ru.ru_inblock++;
rabp->b_flags |= B_READ | B_ASYNC;
rabp->b_flags |= B_ASYNC;
rabp->b_flags &= ~(B_ERROR | B_INVAL);
rabp->b_iocmd = BIO_READ;
if (rabp->b_rcred == NOCRED) {
if (cred != NOCRED)
crhold(cred);
@ -630,8 +631,10 @@ bwrite(struct buf * bp)
* copy so as to leave this buffer ready for further use.
*/
if ((bp->b_xflags & BX_BKGRDWRITE) && (bp->b_flags & B_ASYNC)) {
if (bp->b_flags & B_CALL)
if (bp->b_iodone != NULL) {
printf("bp->b_iodone = %p\n", bp->b_iodone);
panic("bwrite: need chained iodone");
}
/* get a new block */
newbp = geteblk(bp->b_bufsize);
@ -643,7 +646,7 @@ bwrite(struct buf * bp)
newbp->b_blkno = bp->b_blkno;
newbp->b_offset = bp->b_offset;
newbp->b_iodone = vfs_backgroundwritedone;
newbp->b_flags |= B_ASYNC | B_CALL;
newbp->b_flags |= B_ASYNC;
newbp->b_flags &= ~B_INVAL;
/* move over the dependencies */
@ -664,8 +667,9 @@ bwrite(struct buf * bp)
bp = newbp;
}
bp->b_flags &= ~(B_READ | B_DONE | B_ERROR);
bp->b_flags &= ~(B_DONE | B_ERROR);
bp->b_flags |= B_WRITEINPROG | B_CACHE;
bp->b_iocmd = BIO_WRITE;
bp->b_vp->v_numoutput++;
vfs_busy_pages(bp, 1);
@ -726,11 +730,12 @@ vfs_backgroundwritedone(bp)
}
/*
* This buffer is marked B_NOCACHE, so when it is released
* by biodone, it will be tossed. We mark it with B_READ
* by biodone, it will be tossed. We mark it with BIO_READ
* to avoid biodone doing a second vwakeup.
*/
bp->b_flags |= B_NOCACHE | B_READ;
bp->b_flags &= ~(B_CACHE | B_CALL | B_DONE);
bp->b_flags |= B_NOCACHE;
bp->b_iocmd = BIO_READ;
bp->b_flags &= ~(B_CACHE | B_DONE);
bp->b_iodone = 0;
biodone(bp);
}
@ -806,7 +811,7 @@ bdwrite(struct buf * bp)
/*
* bdirty:
*
* Turn buffer into delayed write request. We must clear B_READ and
* Turn buffer into delayed write request. We must clear BIO_READ and
* B_RELBUF, and we must set B_DELWRI. We reassign the buffer to
* itself to properly update it in the dirty/clean lists. We mark it
* B_DONE to ensure that any asynchronization of the buffer properly
@ -827,7 +832,8 @@ bdirty(bp)
struct buf *bp;
{
KASSERT(bp->b_qindex == QUEUE_NONE, ("bdirty: buffer %p still on queue %d", bp, bp->b_qindex));
bp->b_flags &= ~(B_READ|B_RELBUF);
bp->b_flags &= ~(B_RELBUF);
bp->b_iocmd = BIO_WRITE;
if ((bp->b_flags & B_DELWRI) == 0) {
bp->b_flags |= B_DONE | B_DELWRI;
@ -946,7 +952,8 @@ brelse(struct buf * bp)
if (bp->b_flags & B_LOCKED)
bp->b_flags &= ~B_ERROR;
if ((bp->b_flags & (B_READ | B_ERROR | B_INVAL)) == B_ERROR) {
if (bp->b_iocmd == BIO_WRITE &&
(bp->b_flags & (B_ERROR | B_INVAL)) == B_ERROR) {
/*
* Failed write, redirty. Must clear B_ERROR to prevent
* pages from being scrapped. If B_INVAL is set then
@ -956,8 +963,8 @@ brelse(struct buf * bp)
*/
bp->b_flags &= ~B_ERROR;
bdirty(bp);
} else if ((bp->b_flags & (B_NOCACHE | B_INVAL | B_ERROR | B_FREEBUF)) ||
(bp->b_bufsize <= 0)) {
} else if ((bp->b_flags & (B_NOCACHE | B_INVAL | B_ERROR)) ||
bp->b_iocmd == BIO_DELETE || (bp->b_bufsize <= 0)) {
/*
* Either a failed I/O or we were asked to free or not
* cache the buffer.
@ -969,7 +976,7 @@ brelse(struct buf * bp)
--numdirtybuffers;
numdirtywakeup();
}
bp->b_flags &= ~(B_DELWRI | B_CACHE | B_FREEBUF);
bp->b_flags &= ~(B_DELWRI | B_CACHE);
if ((bp->b_flags & B_VMIO) == 0) {
if (bp->b_bufsize)
allocbuf(bp, 0);
@ -2632,7 +2639,7 @@ biowait(register struct buf * bp)
#if defined(NO_SCHEDULE_MODS)
tsleep(bp, PRIBIO, "biowait", 0);
#else
if (bp->b_flags & B_READ)
if (bp->b_iocmd == BIO_READ)
tsleep(bp, PRIBIO, "biord", 0);
else
tsleep(bp, PRIBIO, "biowr", 0);
@ -2673,6 +2680,7 @@ void
biodone(register struct buf * bp)
{
int s;
void (*b_iodone) __P((struct buf *));
s = splbio();
@ -2681,20 +2689,21 @@ biodone(register struct buf * bp)
bp->b_flags |= B_DONE;
if (bp->b_flags & B_FREEBUF) {
if (bp->b_iocmd == BIO_DELETE) {
brelse(bp);
splx(s);
return;
}
if ((bp->b_flags & B_READ) == 0) {
if (bp->b_iocmd == BIO_WRITE) {
vwakeup(bp);
}
/* call optional completion function if requested */
if (bp->b_flags & B_CALL) {
bp->b_flags &= ~B_CALL;
(*bp->b_iodone) (bp);
if (bp->b_iodone != NULL) {
b_iodone = bp->b_iodone;
bp->b_iodone = NULL;
(*b_iodone) (bp);
splx(s);
return;
}
@ -2745,7 +2754,8 @@ biodone(register struct buf * bp)
* routines.
*/
iosize = bp->b_bcount - bp->b_resid;
if ((bp->b_flags & (B_READ|B_FREEBUF|B_INVAL|B_NOCACHE|B_ERROR)) == B_READ) {
if (bp->b_iocmd == BIO_READ &&
!(bp->b_flags & (B_INVAL|B_NOCACHE|B_ERROR))) {
bp->b_flags |= B_CACHE;
}
@ -2782,7 +2792,7 @@ biodone(register struct buf * bp)
* already changed correctly ( see bdwrite() ), so we
* only need to do this here in the read case.
*/
if ((bp->b_flags & B_READ) && !bogusflag && resid > 0) {
if ((bp->b_iocmd == BIO_READ) && !bogusflag && resid > 0) {
vfs_page_set_valid(bp, foff, i, m);
}
vm_page_flag_clear(m, PG_ZERO);

30
sys/kern/vfs_cluster.c
View File

@ -200,7 +200,8 @@ cluster_read(vp, filesize, lblkno, size, cred, totread, seqcount, bpp)
* if it isn't in the cache, then get a chunk from
* disk if sequential, otherwise just get the block.
*/
bp->b_flags |= B_READ | B_RAM;
bp->b_flags |= B_RAM;
bp->b_iocmd = BIO_READ;
lblkno += 1;
}
}
@ -228,7 +229,8 @@ cluster_read(vp, filesize, lblkno, size, cred, totread, seqcount, bpp)
blkno, size, ntoread, NULL);
} else {
rbp = getblk(vp, lblkno, size, 0, 0);
rbp->b_flags |= B_READ | B_ASYNC | B_RAM;
rbp->b_flags |= B_ASYNC | B_RAM;
rbp->b_iocmd = BIO_READ;
rbp->b_blkno = blkno;
}
}
@ -246,7 +248,7 @@ cluster_read(vp, filesize, lblkno, size, cred, totread, seqcount, bpp)
if ((bp->b_flags & B_CLUSTER) == 0)
vfs_busy_pages(bp, 0);
bp->b_flags &= ~(B_ERROR|B_INVAL);
if (bp->b_flags & (B_ASYNC|B_CALL))
if ((bp->b_flags & B_ASYNC) || bp->b_iodone != NULL)
BUF_KERNPROC(bp);
error = VOP_STRATEGY(vp, bp);
curproc->p_stats->p_ru.ru_inblock++;
@ -257,10 +259,10 @@ cluster_read(vp, filesize, lblkno, size, cred, totread, seqcount, bpp)
*/
if (rbp) {
if (error) {
rbp->b_flags &= ~(B_ASYNC | B_READ);
rbp->b_flags &= ~B_ASYNC;
brelse(rbp);
} else if (rbp->b_flags & B_CACHE) {
rbp->b_flags &= ~(B_ASYNC | B_READ);
rbp->b_flags &= ~B_ASYNC;
bqrelse(rbp);
} else {
#if defined(CLUSTERDEBUG)
@ -281,7 +283,7 @@ cluster_read(vp, filesize, lblkno, size, cred, totread, seqcount, bpp)
if ((rbp->b_flags & B_CLUSTER) == 0)
vfs_busy_pages(rbp, 0);
rbp->b_flags &= ~(B_ERROR|B_INVAL);
if (rbp->b_flags & (B_ASYNC|B_CALL))
if ((rbp->b_flags & B_ASYNC) || rbp->b_iodone != NULL)
BUF_KERNPROC(rbp);
(void) VOP_STRATEGY(vp, rbp);
curproc->p_stats->p_ru.ru_inblock++;
@ -325,12 +327,13 @@ cluster_rbuild(vp, filesize, lbn, blkno, size, run, fbp)
if (fbp) {
tbp = fbp;
tbp->b_flags |= B_READ;
tbp->b_iocmd = BIO_READ;
} else {
tbp = getblk(vp, lbn, size, 0, 0);
if (tbp->b_flags & B_CACHE)
return tbp;
tbp->b_flags |= B_ASYNC | B_READ | B_RAM;
tbp->b_flags |= B_ASYNC | B_RAM;
tbp->b_iocmd = BIO_READ;
}
tbp->b_blkno = blkno;
@ -344,7 +347,8 @@ cluster_rbuild(vp, filesize, lbn, blkno, size, run, fbp)
bp->b_data = (char *)((vm_offset_t)bp->b_data |
((vm_offset_t)tbp->b_data & PAGE_MASK));
bp->b_flags = B_ASYNC | B_READ | B_CALL | B_CLUSTER | B_VMIO;
bp->b_flags = B_ASYNC | B_CLUSTER | B_VMIO;
bp->b_iocmd = BIO_READ;
bp->b_iodone = cluster_callback;
bp->b_blkno = blkno;
bp->b_lblkno = lbn;
@ -400,7 +404,8 @@ cluster_rbuild(vp, filesize, lbn, blkno, size, run, fbp)
if ((fbp && (i == 1)) || (i == (run - 1)))
tbp->b_flags |= B_RAM;
tbp->b_flags |= B_READ | B_ASYNC;
tbp->b_flags |= B_ASYNC;
tbp->b_iocmd = BIO_READ;
if (tbp->b_blkno == tbp->b_lblkno) {
tbp->b_blkno = bn;
} else if (tbp->b_blkno != bn) {
@ -716,7 +721,7 @@ cluster_wbuild(vp, size, start_lbn, len)
bp->b_offset = tbp->b_offset;
bp->b_data = (char *)((vm_offset_t)bp->b_data |
((vm_offset_t)tbp->b_data & PAGE_MASK));
bp->b_flags |= B_CALL | B_CLUSTER |
bp->b_flags |= B_CLUSTER |
(tbp->b_flags & (B_VMIO | B_NEEDCOMMIT));
bp->b_iodone = cluster_callback;
pbgetvp(vp, bp);
@ -811,8 +816,9 @@ cluster_wbuild(vp, size, start_lbn, len)
s = splbio();
bundirty(tbp);
tbp->b_flags &= ~(B_READ | B_DONE | B_ERROR);
tbp->b_flags &= ~(B_DONE | B_ERROR);
tbp->b_flags |= B_ASYNC;
tbp->b_iocmd = BIO_WRITE;
reassignbuf(tbp, tbp->b_vp); /* put on clean list */
++tbp->b_vp->v_numoutput;
splx(s);

8
sys/kern/vfs_default.c
View File

@ -153,10 +153,10 @@ vop_panic(struct vop_generic_args *ap)
* Strategy routine for VFS devices that have none.
*
* B_ERROR and B_INVAL must be cleared prior to calling any strategy
* routine. Typically this is done for a B_READ strategy call. Typically
* B_INVAL is assumed to already be clear prior to a write and should not
* be cleared manually unless you just made the buffer invalid. B_ERROR
* should be cleared either way.
* routine. Typically this is done for a BIO_READ strategy call.
* Typically B_INVAL is assumed to already be clear prior to a write
* and should not be cleared manually unless you just made the buffer
* invalid. B_ERROR should be cleared either way.
*/
static int

6
sys/miscfs/devfs/devfs_vnops.c
View File

@ -1569,7 +1569,7 @@ devfs_strategy(struct vop_strategy_args *ap)
return error;
if (((bp->b_flags & B_READ) == 0) &&
if ((bp->b_iocmd == BIO_WRITE) &&
(LIST_FIRST(&bp->b_dep)) != NULL && bioops.io_start)
(*bioops.io_start)(bp);
switch (vp->v_type) {
@ -1606,7 +1606,7 @@ devfs_freeblks(struct vop_freeblks_args *ap)
if ((bsw->d_flags & D_CANFREE) == 0)
return (0);
bp = geteblk(ap->a_length);
bp->b_flags |= B_FREEBUF;
bp->b_iocmd = BIO_DELETE;
bp->b_dev = vp->v_rdev;
bp->b_blkno = ap->a_addr;
bp->b_offset = dbtob(ap->a_addr);
@ -1834,7 +1834,7 @@ devfs_getpages(struct vop_getpages_args *ap)
pmap_qenter(kva, ap->a_m, pcount);
/* Build a minimal buffer header. */
bp->b_flags = B_READ | B_CALL;
bp->b_iocmd = BIO_READ;
bp->b_iodone = devfs_getpages_iodone;
/* B_PHYS is not set, but it is nice to fill this in. */

8
sys/miscfs/specfs/spec_vnops.c
View File

@ -407,7 +407,7 @@ spec_strategy(ap)
struct mount *mp;
bp = ap->a_bp;
if (((bp->b_flags & B_READ) == 0) &&
if ((bp->b_iocmd == BIO_WRITE) &&
(LIST_FIRST(&bp->b_dep)) != NULL && bioops.io_start)
(*bioops.io_start)(bp);
@ -417,7 +417,7 @@ spec_strategy(ap)
*/
vp = ap->a_vp;
if (vn_isdisk(vp, NULL) && (mp = vp->v_specmountpoint) != NULL) {
if ((bp->b_flags & B_READ) == 0) {
if (bp->b_iocmd == BIO_WRITE) {
if (bp->b_lock.lk_lockholder == LK_KERNPROC)
mp->mnt_stat.f_asyncwrites++;
else
@ -458,7 +458,7 @@ spec_freeblks(ap)
if ((bsw->d_flags & D_CANFREE) == 0)
return (0);
bp = geteblk(ap->a_length);
bp->b_flags |= B_FREEBUF;
bp->b_iocmd = BIO_DELETE;
bp->b_dev = ap->a_vp->v_rdev;
bp->b_blkno = ap->a_addr;
bp->b_offset = dbtob(ap->a_addr);
@ -657,7 +657,7 @@ spec_getpages(ap)
pmap_qenter(kva, ap->a_m, pcount);
/* Build a minimal buffer header. */
bp->b_flags = B_READ | B_CALL;
bp->b_iocmd = BIO_READ;
bp->b_iodone = spec_getpages_iodone;
/* B_PHYS is not set, but it is nice to fill this in. */

2
sys/miscfs/union/union_vnops.c
View File

@ -1923,7 +1923,7 @@ union_strategy(ap)
#ifdef DIAGNOSTIC
if (othervp == NULLVP)
panic("union_strategy: nil vp");
if (((bp->b_flags & B_READ) == 0) &&
if ((bp->b_iocmd == BIO_WRITE) &&
(othervp == LOWERVP(bp->b_vp)))
panic("union_strategy: writing to lowervp");
#endif

24
sys/nfs/nfs_bio.c
View File

@ -465,7 +465,8 @@ nfs_bioread(vp, uio, ioflag, cred)
if (!rabp)
return (EINTR);
if ((rabp->b_flags & (B_CACHE|B_DELWRI)) == 0) {
rabp->b_flags |= (B_READ | B_ASYNC);
rabp->b_flags |= B_ASYNC;
rabp->b_iocmd = BIO_READ;
vfs_busy_pages(rabp, 0);
if (nfs_asyncio(rabp, cred, p)) {
rabp->b_flags |= B_INVAL|B_ERROR;
@ -526,7 +527,7 @@ nfs_bioread(vp, uio, ioflag, cred)
*/
if ((bp->b_flags & B_CACHE) == 0) {
bp->b_flags |= B_READ;
bp->b_iocmd = BIO_READ;
vfs_busy_pages(bp, 0);
error = nfs_doio(bp, cred, p);
if (error) {
@ -553,7 +554,7 @@ nfs_bioread(vp, uio, ioflag, cred)
if (!bp)
return (EINTR);
if ((bp->b_flags & B_CACHE) == 0) {
bp->b_flags |= B_READ;
bp->b_iocmd = BIO_READ;
vfs_busy_pages(bp, 0);
error = nfs_doio(bp, cred, p);
if (error) {
@ -577,7 +578,7 @@ nfs_bioread(vp, uio, ioflag, cred)
if (!bp)
return (EINTR);
if ((bp->b_flags & B_CACHE) == 0) {
bp->b_flags |= B_READ;
bp->b_iocmd = BIO_READ;
vfs_busy_pages(bp, 0);
error = nfs_doio(bp, cred, p);
if (error) {
@ -605,7 +606,7 @@ nfs_bioread(vp, uio, ioflag, cred)
if (!bp)
return (EINTR);
if ((bp->b_flags & B_CACHE) == 0) {
bp->b_flags |= B_READ;
bp->b_iocmd = BIO_READ;
vfs_busy_pages(bp, 0);
error = nfs_doio(bp, cred, p);
/*
@ -648,7 +649,8 @@ nfs_bioread(vp, uio, ioflag, cred)
rabp = nfs_getcacheblk(vp, lbn + 1, NFS_DIRBLKSIZ, p);
if (rabp) {
if ((rabp->b_flags & (B_CACHE|B_DELWRI)) == 0) {
rabp->b_flags |= (B_READ | B_ASYNC);
rabp->b_flags |= B_ASYNC;
rabp->b_iocmd = BIO_READ;
vfs_busy_pages(rabp, 0);
if (nfs_asyncio(rabp, cred, p)) {
rabp->b_flags |= B_INVAL|B_ERROR;
@ -936,7 +938,7 @@ nfs_write(ap)
}
if ((bp->b_flags & B_CACHE) == 0) {
bp->b_flags |= B_READ;
bp->b_iocmd = BIO_READ;
vfs_busy_pages(bp, 0);
error = nfs_doio(bp, cred, p);
if (error) {
@ -1232,7 +1234,7 @@ nfs_asyncio(bp, cred, procp)
* leave the async daemons for more important rpc's (such as reads
* and writes).
*/
if ((bp->b_flags & (B_READ|B_NEEDCOMMIT)) == B_NEEDCOMMIT &&
if (bp->b_iocmd == BIO_WRITE && (bp->b_flags & B_NEEDCOMMIT) &&
(nmp->nm_bufqiods > nfs_numasync / 2)) {
return(EIO);
}
@ -1309,7 +1311,7 @@ nfs_asyncio(bp, cred, procp)
}
}
if (bp->b_flags & B_READ) {
if (bp->b_iocmd == BIO_READ) {
if (bp->b_rcred == NOCRED && cred != NOCRED) {
crhold(cred);
bp->b_rcred = cred;
@ -1383,7 +1385,7 @@ nfs_doio(bp, cr, p)
/* mapping was done by vmapbuf() */
io.iov_base = bp->b_data;
uiop->uio_offset = ((off_t)bp->b_blkno) * DEV_BSIZE;
if (bp->b_flags & B_READ) {
if (bp->b_iocmd == BIO_READ) {
uiop->uio_rw = UIO_READ;
nfsstats.read_physios++;
error = nfs_readrpc(vp, uiop, cr);
@ -1399,7 +1401,7 @@ nfs_doio(bp, cr, p)
bp->b_flags |= B_ERROR;
bp->b_error = error;
}
} else if (bp->b_flags & B_READ) {
} else if (bp->b_iocmd == BIO_READ) {
io.iov_len = uiop->uio_resid = bp->b_bcount;
io.iov_base = bp->b_data;
uiop->uio_rw = UIO_READ;

2
sys/nfs/nfs_syscalls.c
View File

@ -961,7 +961,7 @@ nfssvc_iod(p)
nmp->nm_bufqwant = FALSE;
wakeup(&nmp->nm_bufq);
}
if (bp->b_flags & B_READ)
if (bp->b_iocmd == BIO_READ)
(void) nfs_doio(bp, bp->b_rcred, (struct proc *)0);
else
(void) nfs_doio(bp, bp->b_wcred, (struct proc *)0);

7
sys/nfs/nfs_vnops.c
View File

@ -2705,7 +2705,7 @@ nfs_strategy(ap)
else
p = curproc; /* XXX */
if (bp->b_flags & B_READ)
if (bp->b_iocmd == BIO_READ)
cr = bp->b_rcred;
else
cr = bp->b_wcred;
@ -2939,7 +2939,7 @@ nfs_flush(vp, cred, waitfor, p, commit)
vp->v_numoutput++;
bp->b_flags |= B_ASYNC;
bundirty(bp);
bp->b_flags &= ~(B_READ|B_DONE|B_ERROR);
bp->b_flags &= ~(B_DONE|B_ERROR);
bp->b_dirtyoff = bp->b_dirtyend = 0;
splx(s);
biodone(bp);
@ -3116,7 +3116,8 @@ nfs_writebp(bp, force, procp)
s = splbio();
bundirty(bp);
bp->b_flags &= ~(B_READ|B_DONE|B_ERROR);
bp->b_flags &= ~(B_DONE|B_ERROR);
bp->b_iocmd = BIO_WRITE;
bp->b_vp->v_numoutput++;
curproc->p_stats->p_ru.ru_oublock++;

24
sys/nfsclient/nfs_bio.c
View File

@ -465,7 +465,8 @@ nfs_bioread(vp, uio, ioflag, cred)
if (!rabp)
return (EINTR);
if ((rabp->b_flags & (B_CACHE|B_DELWRI)) == 0) {
rabp->b_flags |= (B_READ | B_ASYNC);
rabp->b_flags |= B_ASYNC;
rabp->b_iocmd = BIO_READ;
vfs_busy_pages(rabp, 0);
if (nfs_asyncio(rabp, cred, p)) {
rabp->b_flags |= B_INVAL|B_ERROR;
@ -526,7 +527,7 @@ nfs_bioread(vp, uio, ioflag, cred)
*/
if ((bp->b_flags & B_CACHE) == 0) {
bp->b_flags |= B_READ;
bp->b_iocmd = BIO_READ;
vfs_busy_pages(bp, 0);
error = nfs_doio(bp, cred, p);
if (error) {
@ -553,7 +554,7 @@ nfs_bioread(vp, uio, ioflag, cred)
if (!bp)
return (EINTR);
if ((bp->b_flags & B_CACHE) == 0) {
bp->b_flags |= B_READ;
bp->b_iocmd = BIO_READ;
vfs_busy_pages(bp, 0);
error = nfs_doio(bp, cred, p);
if (error) {
@ -577,7 +578,7 @@ nfs_bioread(vp, uio, ioflag, cred)
if (!bp)
return (EINTR);
if ((bp->b_flags & B_CACHE) == 0) {
bp->b_flags |= B_READ;
bp->b_iocmd = BIO_READ;
vfs_busy_pages(bp, 0);
error = nfs_doio(bp, cred, p);
if (error) {
@ -605,7 +606,7 @@ nfs_bioread(vp, uio, ioflag, cred)
if (!bp)
return (EINTR);
if ((bp->b_flags & B_CACHE) == 0) {
bp->b_flags |= B_READ;
bp->b_iocmd = BIO_READ;
vfs_busy_pages(bp, 0);
error = nfs_doio(bp, cred, p);
/*
@ -648,7 +649,8 @@ nfs_bioread(vp, uio, ioflag, cred)
rabp = nfs_getcacheblk(vp, lbn + 1, NFS_DIRBLKSIZ, p);
if (rabp) {
if ((rabp->b_flags & (B_CACHE|B_DELWRI)) == 0) {
rabp->b_flags |= (B_READ | B_ASYNC);
rabp->b_flags |= B_ASYNC;
rabp->b_iocmd = BIO_READ;
vfs_busy_pages(rabp, 0);
if (nfs_asyncio(rabp, cred, p)) {
rabp->b_flags |= B_INVAL|B_ERROR;
@ -936,7 +938,7 @@ nfs_write(ap)
}
if ((bp->b_flags & B_CACHE) == 0) {
bp->b_flags |= B_READ;
bp->b_iocmd = BIO_READ;
vfs_busy_pages(bp, 0);
error = nfs_doio(bp, cred, p);
if (error) {
@ -1232,7 +1234,7 @@ nfs_asyncio(bp, cred, procp)
* leave the async daemons for more important rpc's (such as reads
* and writes).
*/
if ((bp->b_flags & (B_READ|B_NEEDCOMMIT)) == B_NEEDCOMMIT &&
if (bp->b_iocmd == BIO_WRITE && (bp->b_flags & B_NEEDCOMMIT) &&
(nmp->nm_bufqiods > nfs_numasync / 2)) {
return(EIO);
}
@ -1309,7 +1311,7 @@ nfs_asyncio(bp, cred, procp)
}
}
if (bp->b_flags & B_READ) {
if (bp->b_iocmd == BIO_READ) {
if (bp->b_rcred == NOCRED && cred != NOCRED) {
crhold(cred);
bp->b_rcred = cred;
@ -1383,7 +1385,7 @@ nfs_doio(bp, cr, p)
/* mapping was done by vmapbuf() */
io.iov_base = bp->b_data;
uiop->uio_offset = ((off_t)bp->b_blkno) * DEV_BSIZE;
if (bp->b_flags & B_READ) {
if (bp->b_iocmd == BIO_READ) {
uiop->uio_rw = UIO_READ;
nfsstats.read_physios++;
error = nfs_readrpc(vp, uiop, cr);
@ -1399,7 +1401,7 @@ nfs_doio(bp, cr, p)
bp->b_flags |= B_ERROR;
bp->b_error = error;
}
} else if (bp->b_flags & B_READ) {
} else if (bp->b_iocmd == BIO_READ) {
io.iov_len = uiop->uio_resid = bp->b_bcount;
io.iov_base = bp->b_data;
uiop->uio_rw = UIO_READ;

2
sys/nfsclient/nfs_nfsiod.c
View File

@ -961,7 +961,7 @@ nfssvc_iod(p)
nmp->nm_bufqwant = FALSE;
wakeup(&nmp->nm_bufq);
}
if (bp->b_flags & B_READ)
if (bp->b_iocmd == BIO_READ)
(void) nfs_doio(bp, bp->b_rcred, (struct proc *)0);
else
(void) nfs_doio(bp, bp->b_wcred, (struct proc *)0);

7
sys/nfsclient/nfs_vnops.c
View File

@ -2705,7 +2705,7 @@ nfs_strategy(ap)
else
p = curproc; /* XXX */
if (bp->b_flags & B_READ)
if (bp->b_iocmd == BIO_READ)
cr = bp->b_rcred;
else
cr = bp->b_wcred;
@ -2939,7 +2939,7 @@ nfs_flush(vp, cred, waitfor, p, commit)
vp->v_numoutput++;
bp->b_flags |= B_ASYNC;
bundirty(bp);
bp->b_flags &= ~(B_READ|B_DONE|B_ERROR);
bp->b_flags &= ~(B_DONE|B_ERROR);
bp->b_dirtyoff = bp->b_dirtyend = 0;
splx(s);
biodone(bp);
@ -3116,7 +3116,8 @@ nfs_writebp(bp, force, procp)
s = splbio();
bundirty(bp);
bp->b_flags &= ~(B_READ|B_DONE|B_ERROR);
bp->b_flags &= ~(B_DONE|B_ERROR);
bp->b_iocmd = BIO_WRITE;
bp->b_vp->v_numoutput++;
curproc->p_stats->p_ru.ru_oublock++;

2
sys/nfsserver/nfs_syscalls.c
View File

@ -961,7 +961,7 @@ nfssvc_iod(p)
nmp->nm_bufqwant = FALSE;
wakeup(&nmp->nm_bufq);
}
if (bp->b_flags & B_READ)
if (bp->b_iocmd == BIO_READ)
(void) nfs_doio(bp, bp->b_rcred, (struct proc *)0);
else
(void) nfs_doio(bp, bp->b_wcred, (struct proc *)0);

2
sys/ntfs/ntfs_vnops.c
View File

@ -345,7 +345,7 @@ ntfs_strategy(ap)
dprintf(("strategy: bcount: %d flags: 0x%lx\n",
(u_int32_t)bp->b_bcount,bp->b_flags));
if (bp->b_flags & B_READ) {
if (bp->b_iocmd == BIO_READ) {
u_int32_t toread;
if (ntfs_cntob(bp->b_blkno) >= fp->f_size) {

2
sys/nwfs/nwfs_io.c
View File

@ -275,7 +275,7 @@ nwfs_doio(bp, cr, p)
uiop->uio_iovcnt = 1;
uiop->uio_segflg = UIO_SYSSPACE;
uiop->uio_procp = p;
if (bp->b_flags & B_READ) {
if (bp->b_iocmd == BIO_READ) {
io.iov_len = uiop->uio_resid = bp->b_bcount;
io.iov_base = bp->b_data;
uiop->uio_rw = UIO_READ;

2
sys/nwfs/nwfs_vnops.c
View File

@ -812,7 +812,7 @@ static int nwfs_strategy (ap)
p = (struct proc *)0;
else
p = curproc; /* XXX */
if (bp->b_flags & B_READ)
if (bp->b_iocmd == BIO_READ)
cr = bp->b_rcred;
else
cr = bp->b_wcred;

12
sys/pc98/cbus/fdc.c
View File

@ -1944,7 +1944,7 @@ static int fdcpio(fdc_p fdc, long flags, caddr_t addr, u_int count)
{
u_char *cptr = (u_char *)addr;
if (flags & B_READ) {
if (flags == BIO_READ) {
if (fdc->state != PIOREAD) {
fdc->state = PIOREAD;
return(0);
@ -2003,7 +2003,7 @@ fdstate(fdc_p fdc)
fdblk = 128 << fd->ft->secsize;
if (fdc->fd && (fd != fdc->fd))
device_printf(fd->dev, "confused fd pointers\n");
read = bp->b_flags & B_READ;
read = bp->b_iocmd == BIO_READ;
format = bp->b_flags & B_FORMAT;
if (format) {
finfo = (struct fd_formb *)bp->b_data;
@ -2257,7 +2257,7 @@ fdstate(fdc_p fdc)
*/
SET_BCDR(fdc, 1, bp->b_bcount, 0);
(void)fdcpio(fdc,bp->b_flags,
(void)fdcpio(fdc,bp->b_iocmd,
bp->b_data+fd->skip,
bp->b_bcount);
@ -2290,7 +2290,7 @@ fdstate(fdc_p fdc)
* the WRITE command is sent
*/
if (!read)
(void)fdcpio(fdc,bp->b_flags,
(void)fdcpio(fdc,bp->b_iocmd,
bp->b_data+fd->skip,
fdblk);
}
@ -2320,7 +2320,7 @@ fdstate(fdc_p fdc)
* if this is a read, then simply await interrupt
* before performing PIO
*/
if (read && !fdcpio(fdc,bp->b_flags,
if (read && !fdcpio(fdc,bp->b_iocmd,
bp->b_data+fd->skip,fdblk)) {
fd->tohandle = timeout(fd_iotimeout, fdc, hz);
return(0); /* will return later */
@ -2368,7 +2368,7 @@ fdstate(fdc_p fdc)
* actually perform the PIO read. The IOCOMPLETE case
* removes the timeout for us.
*/
(void)fdcpio(fdc,bp->b_flags,bp->b_data+fd->skip,fdblk);
(void)fdcpio(fdc,bp->b_iocmd,bp->b_data+fd->skip,fdblk);
fdc->state = IOCOMPLETE;
/* FALLTHROUGH */
case IOCOMPLETE: /* IO DONE, post-analyze */

4
sys/pc98/i386/machdep.c
View File

@ -2656,7 +2656,7 @@ bounds_check_with_label(struct buf *bp, struct disklabel *lp, int wlabel)
#if LABELSECTOR != 0
bp->b_blkno + p->p_offset + sz > LABELSECTOR + labelsect &&
#endif
(bp->b_flags & B_READ) == 0 && wlabel == 0) {
(bp->b_iocmd == BIO_WRITE) && wlabel == 0) {
bp->b_error = EROFS;
goto bad;
}
@ -2664,7 +2664,7 @@ bounds_check_with_label(struct buf *bp, struct disklabel *lp, int wlabel)
#if defined(DOSBBSECTOR) && defined(notyet)
/* overwriting master boot record? */
if (bp->b_blkno + p->p_offset <= DOSBBSECTOR &&
(bp->b_flags & B_READ) == 0 && wlabel == 0) {
(bp->b_iocmd == BIO_WRITE) && wlabel == 0) {
bp->b_error = EROFS;
goto bad;
}

4
sys/pc98/pc98/diskslice_machdep.c
View File

@ -243,7 +243,7 @@ dsinit(dev, lp, sspp)
bp->b_dev = dkmodpart(dkmodslice(dev, WHOLE_DISK_SLICE), RAW_PART);
bp->b_blkno = mbr_offset;
bp->b_bcount = lp->d_secsize;
bp->b_flags |= B_READ;
bp->b_iocmd = BIO_READ;
#ifdef PC98
if (bp->b_bcount < 1024)
bp->b_bcount = 1024;
@ -548,7 +548,7 @@ mbr_extended(dev, lp, ssp, ext_offset, ext_size, base_ext_offset, nsectors,
bp->b_dev = dev;
bp->b_blkno = ext_offset;
bp->b_bcount = lp->d_secsize;
bp->b_flags |= B_READ;
bp->b_iocmd = BIO_READ;
BUF_STRATEGY(bp, 1);
if (biowait(bp) != 0) {
diskerr(bp, "reading extended partition table: error",

12
sys/pc98/pc98/fd.c
View File

@ -1944,7 +1944,7 @@ static int fdcpio(fdc_p fdc, long flags, caddr_t addr, u_int count)
{
u_char *cptr = (u_char *)addr;
if (flags & B_READ) {
if (flags == BIO_READ) {
if (fdc->state != PIOREAD) {
fdc->state = PIOREAD;
return(0);
@ -2003,7 +2003,7 @@ fdstate(fdc_p fdc)
fdblk = 128 << fd->ft->secsize;
if (fdc->fd && (fd != fdc->fd))
device_printf(fd->dev, "confused fd pointers\n");
read = bp->b_flags & B_READ;
read = bp->b_iocmd == BIO_READ;
format = bp->b_flags & B_FORMAT;
if (format) {
finfo = (struct fd_formb *)bp->b_data;
@ -2257,7 +2257,7 @@ fdstate(fdc_p fdc)
*/
SET_BCDR(fdc, 1, bp->b_bcount, 0);
(void)fdcpio(fdc,bp->b_flags,
(void)fdcpio(fdc,bp->b_iocmd,
bp->b_data+fd->skip,
bp->b_bcount);
@ -2290,7 +2290,7 @@ fdstate(fdc_p fdc)
* the WRITE command is sent
*/
if (!read)
(void)fdcpio(fdc,bp->b_flags,
(void)fdcpio(fdc,bp->b_iocmd,
bp->b_data+fd->skip,
fdblk);
}
@ -2320,7 +2320,7 @@ fdstate(fdc_p fdc)
* if this is a read, then simply await interrupt
* before performing PIO
*/
if (read && !fdcpio(fdc,bp->b_flags,
if (read && !fdcpio(fdc,bp->b_iocmd,
bp->b_data+fd->skip,fdblk)) {
fd->tohandle = timeout(fd_iotimeout, fdc, hz);
return(0); /* will return later */
@ -2368,7 +2368,7 @@ fdstate(fdc_p fdc)
* actually perform the PIO read. The IOCOMPLETE case
* removes the timeout for us.
*/
(void)fdcpio(fdc,bp->b_flags,bp->b_data+fd->skip,fdblk);
(void)fdcpio(fdc,bp->b_iocmd,bp->b_data+fd->skip,fdblk);
fdc->state = IOCOMPLETE;
/* FALLTHROUGH */
case IOCOMPLETE: /* IO DONE, post-analyze */

4
sys/pc98/pc98/machdep.c
View File

@ -2656,7 +2656,7 @@ bounds_check_with_label(struct buf *bp, struct disklabel *lp, int wlabel)
#if LABELSECTOR != 0
bp->b_blkno + p->p_offset + sz > LABELSECTOR + labelsect &&
#endif
(bp->b_flags & B_READ) == 0 && wlabel == 0) {
(bp->b_iocmd == BIO_WRITE) && wlabel == 0) {
bp->b_error = EROFS;
goto bad;
}
@ -2664,7 +2664,7 @@ bounds_check_with_label(struct buf *bp, struct disklabel *lp, int wlabel)
#if defined(DOSBBSECTOR) && defined(notyet)
/* overwriting master boot record? */
if (bp->b_blkno + p->p_offset <= DOSBBSECTOR &&
(bp->b_flags & B_READ) == 0 && wlabel == 0) {
(bp->b_iocmd == BIO_WRITE) && wlabel == 0) {
bp->b_error = EROFS;
goto bad;
}

22
sys/pc98/pc98/wd.c
View File

@ -805,7 +805,7 @@ wdstart(int ctrlr)
#ifdef WDDEBUG
if (du->dk_skip == 0)
printf("wd%d: wdstart: %s %d@%d; map ", lunit,
(bp->b_flags & B_READ) ? "read" : "write",
(bp->b_iocmd == BIO_READ) ? "read" : "write",
bp->b_bcount, blknum);
else {
if (old_epson_note)
@ -843,7 +843,7 @@ wdstart(int ctrlr)
* XXX this looks like an attempt to skip bad sectors
* on write.
*/
if (wdtab[ctrlr].b_errcnt && (bp->b_flags & B_READ) == 0)
if (wdtab[ctrlr].b_errcnt && (bp->b_iocmd == BIO_WRITE))
du->dk_bc += DEV_BSIZE;
count1 = howmany( du->dk_bc, DEV_BSIZE);
@ -851,7 +851,7 @@ wdstart(int ctrlr)
du->dk_flags &= ~DKFL_MULTI;
if (du->dk_flags & DKFL_SINGLE) {
command = (bp->b_flags & B_READ)
command = (bp->b_iocmd == BIO_READ)
? WDCC_READ : WDCC_WRITE;
count1 = 1;
du->dk_currentiosize = 1;
@ -861,16 +861,16 @@ wdstart(int ctrlr)
(void *)((int)bp->b_data +
du->dk_skip * DEV_BSIZE),
du->dk_bc,
bp->b_flags & B_READ)) {
bp->b_iocmd == BIO_READ)) {
du->dk_flags |= DKFL_DMA;
if( bp->b_flags & B_READ)
if(bp->b_iocmd == BIO_READ)
command = WDCC_READ_DMA;
else
command = WDCC_WRITE_DMA;
du->dk_currentiosize = count1;
} else if( (count1 > 1) && (du->dk_multi > 1)) {
du->dk_flags |= DKFL_MULTI;
if( bp->b_flags & B_READ) {
if(bp->b_iocmd == BIO_READ) {
command = WDCC_READ_MULTI;
} else {
command = WDCC_WRITE_MULTI;
@ -879,7 +879,7 @@ wdstart(int ctrlr)
if( du->dk_currentiosize > count1)
du->dk_currentiosize = count1;
} else {
if( bp->b_flags & B_READ) {
if(bp->b_iocmd == BIO_READ) {
command = WDCC_READ;
} else {
command = WDCC_WRITE;
@ -906,7 +906,7 @@ wdstart(int ctrlr)
(void *)((int)bp->b_data +
du->dk_skip * DEV_BSIZE),
du->dk_bc,
bp->b_flags & B_READ);
bp->b_iocmd == BIO_READ);
}
while (wdcommand(du, cylin, head, sector, count1, command)
!= 0) {
@ -954,7 +954,7 @@ wdstart(int ctrlr)
}
/* If this is a read operation, just go away until it's done. */
if (bp->b_flags & B_READ)
if (bp->b_iocmd == BIO_READ)
return;
/* Ready to send data? */
@ -1133,7 +1133,7 @@ wdintr(void *unitnum)
/*
* If this was a successful read operation, fetch the data.
*/
if (((bp->b_flags & (B_READ | B_ERROR)) == B_READ)
if (bp->b_iocmd == BIO_READ && !(bp->b_flags & B_ERROR)
&& !((du->dk_flags & (DKFL_DMA|DKFL_SINGLE)) == DKFL_DMA)
&& wdtab[unit].b_active) {
u_int chk, dummy, multisize;
@ -1197,7 +1197,7 @@ wdintr(void *unitnum)
/* see if more to transfer */
if (du->dk_bc > 0 && (du->dk_flags & DKFL_ERROR) == 0) {
if( (du->dk_flags & DKFL_SINGLE) ||
((bp->b_flags & B_READ) == 0)) {
(bp->b_iocmd == BIO_WRITE)) {
wdtab[unit].b_active = 0;
wdstart(unit);
} else {

2
sys/powerpc/aim/vm_machdep.c
View File

@ -319,7 +319,7 @@ vmapbuf(bp)
* when reading stuff off device into memory.
*/
vm_fault_quick(addr,
(bp->b_flags&B_READ)?(VM_PROT_READ|VM_PROT_WRITE):VM_PROT_READ);
(bp->b_iocmd == BIO_READ)?(VM_PROT_READ|VM_PROT_WRITE):VM_PROT_READ);
pa = trunc_page(pmap_kextract((vm_offset_t) addr));
if (pa == 0)
panic("vmapbuf: page not present");

2
sys/powerpc/powerpc/vm_machdep.c
View File

@ -319,7 +319,7 @@ vmapbuf(bp)
* when reading stuff off device into memory.
*/
vm_fault_quick(addr,
(bp->b_flags&B_READ)?(VM_PROT_READ|VM_PROT_WRITE):VM_PROT_READ);
(bp->b_iocmd == BIO_READ)?(VM_PROT_READ|VM_PROT_WRITE):VM_PROT_READ);
pa = trunc_page(pmap_kextract((vm_offset_t) addr));
if (pa == 0)
panic("vmapbuf: page not present");

12
sys/sys/bio.h
View File

@ -100,6 +100,7 @@ struct buf {
TAILQ_ENTRY(buf) b_vnbufs; /* Buffer's associated vnode. */
TAILQ_ENTRY(buf) b_freelist; /* Free list position if not active. */
TAILQ_ENTRY(buf) b_act; /* Device driver queue when active. *new* */
u_int b_iocmd; /* BIO_READ, BIO_WRITE, BIO_DELETE */
long b_flags; /* B_* flags. */
unsigned short b_qindex; /* buffer queue index */
unsigned char b_xflags; /* extra flags */
@ -170,7 +171,7 @@ struct buf {
* B_DELWRI can also be cleared. See the comments for
* getblk() in kern/vfs_bio.c. If B_CACHE is clear,
* the caller is expected to clear B_ERROR|B_INVAL,
* set B_READ, and initiate an I/O.
* set BIO_READ, and initiate an I/O.
*
* The 'entire buffer' is defined to be the range from
* 0 through b_bcount.
@ -192,15 +193,18 @@ struct buf {
*
*/
#define BIO_READ 1
#define BIO_WRITE 2
#define BIO_DELETE 4
#define B_AGE 0x00000001 /* Move to age queue when I/O done. */
#define B_NEEDCOMMIT 0x00000002 /* Append-write in progress. */
#define B_ASYNC 0x00000004 /* Start I/O, do not wait. */
#define B_UNUSED0 0x00000008 /* Old B_BAD */
#define B_DEFERRED 0x00000010 /* Skipped over for cleaning */
#define B_CACHE 0x00000020 /* Bread found us in the cache. */
#define B_CALL 0x00000040 /* Call b_iodone from biodone. */
#define B_UNUSED40 0x00000040 /* Old B_CALL */
#define B_DELWRI 0x00000080 /* Delay I/O until buffer reused. */
#define B_FREEBUF 0x00000100 /* Instruct driver: free blocks */
#define B_DONE 0x00000200 /* I/O completed. */
#define B_EINTR 0x00000400 /* I/O was interrupted */
#define B_ERROR 0x00000800 /* I/O error occurred. */
@ -212,11 +216,9 @@ struct buf {
#define B_CLUSTEROK 0x00020000 /* Pagein op, so swap() can count it. */
#define B_PHYS 0x00040000 /* I/O to user memory. */
#define B_RAW 0x00080000 /* Set by physio for raw transfers. */
#define B_READ 0x00100000 /* Read buffer. */
#define B_DIRTY 0x00200000 /* Needs writing later. */
#define B_RELBUF 0x00400000 /* Release VMIO buffer. */
#define B_WANT 0x00800000 /* Used by vm_pager.c */
#define B_WRITE 0x00000000 /* Write buffer (pseudo flag). */
#define B_WRITEINPROG 0x01000000 /* Write in progress. */
#define B_XXX 0x02000000 /* Debugging flag. */
#define B_PAGING 0x04000000 /* volatile paging I/O -- bypass VMIO */

12
sys/sys/buf.h
View File

@ -100,6 +100,7 @@ struct buf {
TAILQ_ENTRY(buf) b_vnbufs; /* Buffer's associated vnode. */
TAILQ_ENTRY(buf) b_freelist; /* Free list position if not active. */
TAILQ_ENTRY(buf) b_act; /* Device driver queue when active. *new* */
u_int b_iocmd; /* BIO_READ, BIO_WRITE, BIO_DELETE */
long b_flags; /* B_* flags. */
unsigned short b_qindex; /* buffer queue index */
unsigned char b_xflags; /* extra flags */
@ -170,7 +171,7 @@ struct buf {
* B_DELWRI can also be cleared. See the comments for
* getblk() in kern/vfs_bio.c. If B_CACHE is clear,
* the caller is expected to clear B_ERROR|B_INVAL,
* set B_READ, and initiate an I/O.
* set BIO_READ, and initiate an I/O.
*
* The 'entire buffer' is defined to be the range from
* 0 through b_bcount.
@ -192,15 +193,18 @@ struct buf {
*
*/
#define BIO_READ 1
#define BIO_WRITE 2
#define BIO_DELETE 4
#define B_AGE 0x00000001 /* Move to age queue when I/O done. */
#define B_NEEDCOMMIT 0x00000002 /* Append-write in progress. */
#define B_ASYNC 0x00000004 /* Start I/O, do not wait. */
#define B_UNUSED0 0x00000008 /* Old B_BAD */
#define B_DEFERRED 0x00000010 /* Skipped over for cleaning */
#define B_CACHE 0x00000020 /* Bread found us in the cache. */
#define B_CALL 0x00000040 /* Call b_iodone from biodone. */
#define B_UNUSED40 0x00000040 /* Old B_CALL */
#define B_DELWRI 0x00000080 /* Delay I/O until buffer reused. */
#define B_FREEBUF 0x00000100 /* Instruct driver: free blocks */
#define B_DONE 0x00000200 /* I/O completed. */
#define B_EINTR 0x00000400 /* I/O was interrupted */
#define B_ERROR 0x00000800 /* I/O error occurred. */
@ -212,11 +216,9 @@ struct buf {
#define B_CLUSTEROK 0x00020000 /* Pagein op, so swap() can count it. */
#define B_PHYS 0x00040000 /* I/O to user memory. */
#define B_RAW 0x00080000 /* Set by physio for raw transfers. */
#define B_READ 0x00100000 /* Read buffer. */
#define B_DIRTY 0x00200000 /* Needs writing later. */
#define B_RELBUF 0x00400000 /* Release VMIO buffer. */
#define B_WANT 0x00800000 /* Used by vm_pager.c */
#define B_WRITE 0x00000000 /* Write buffer (pseudo flag). */
#define B_WRITEINPROG 0x01000000 /* Write in progress. */
#define B_XXX 0x02000000 /* Debugging flag. */
#define B_PAGING 0x04000000 /* volatile paging I/O -- bypass VMIO */

8
sys/sys/conf.h
View File

@ -137,7 +137,13 @@ typedef void devfs_remove_t __P((dev_t dev));
* of surgery, reset the flag and restart all the stuff on the stall
* queue.
*/
#define BUF_STRATEGY(bp, dummy) (*devsw((bp)->b_dev)->d_strategy)(bp)
#define BUF_STRATEGY(bp, dummy) \
do { \
if ((!(bp)->b_iocmd) || ((bp)->b_iocmd & ((bp)->b_iocmd - 1))) \
Debugger("d_iocmd botch"); \
(*devsw((bp)->b_dev)->d_strategy)(bp); \
} while (0)
/*
* Types for d_flags.
*/

8
sys/sys/linedisc.h
View File

@ -137,7 +137,13 @@ typedef void devfs_remove_t __P((dev_t dev));
* of surgery, reset the flag and restart all the stuff on the stall
* queue.
*/
#define BUF_STRATEGY(bp, dummy) (*devsw((bp)->b_dev)->d_strategy)(bp)
#define BUF_STRATEGY(bp, dummy) \
do { \
if ((!(bp)->b_iocmd) || ((bp)->b_iocmd & ((bp)->b_iocmd - 1))) \
Debugger("d_iocmd botch"); \
(*devsw((bp)->b_dev)->d_strategy)(bp); \
} while (0)
/*
* Types for d_flags.
*/

2
sys/ufs/ffs/ffs_inode.c
View File

@ -447,7 +447,7 @@ ffs_indirtrunc(ip, lbn, dbn, lastbn, level, countp)
bp = getblk(vp, lbn, (int)fs->fs_bsize, 0, 0);
if ((bp->b_flags & B_CACHE) == 0) {
curproc->p_stats->p_ru.ru_inblock++; /* pay for read */
bp->b_flags |= B_READ;
bp->b_iocmd = BIO_READ;
bp->b_flags &= ~(B_ERROR|B_INVAL);
if (bp->b_bcount > bp->b_bufsize)
panic("ffs_indirtrunc: bad buffer size");

2
sys/ufs/ffs/ffs_softdep.c
View File

@ -2780,7 +2780,7 @@ softdep_disk_io_initiation(bp)
* We only care about write operations. There should never
* be dependencies for reads.
*/
if (bp->b_flags & B_READ)
if (bp->b_iocmd == BIO_READ)
panic("softdep_disk_io_initiation: read");
/*
* Do any necessary pre-I/O processing.

19
sys/ufs/mfs/mfs_vnops.c
View File

@ -123,7 +123,7 @@ mfs_fsync(ap)
/*
* mfs_freeblks() - hook to allow us to free physical memory.
*
* We implement the B_FREEBUF strategy. We can't just madvise()
* We implement the BIO_DELETE strategy. We can't just madvise()
* here because we have to do it in the correct order vs other bio
* requests, so we queue it.
*
@ -146,7 +146,8 @@ mfs_freeblks(ap)
panic("mfs_freeblks: bad dev");
bp = geteblk(ap->a_length);
bp->b_flags |= B_FREEBUF | B_ASYNC;
bp->b_flags |= B_ASYNC;
bp->b_iocmd = BIO_DELETE;
bp->b_dev = ap->a_vp->v_rdev;
bp->b_blkno = ap->a_addr;
bp->b_offset = dbtob(ap->a_addr);
@ -185,15 +186,15 @@ mfs_strategy(ap)
if (mfsp->mfs_pid == 0) {
/*
* mini-root. Note: B_FREEBUF not supported at the moment,
* mini-root. Note: BIO_DELETE not supported at the moment,
* I'm not sure what kind of dataspace b_data is in.
*/
caddr_t base;
base = mfsp->mfs_baseoff + (bp->b_blkno << DEV_BSHIFT);
if (bp->b_flags & B_FREEBUF)
if (bp->b_iocmd == BIO_DELETE)
;
if (bp->b_flags & B_READ)
if (bp->b_iocmd == BIO_READ)
bcopy(base, bp->b_data, bp->b_bcount);
else
bcopy(bp->b_data, base, bp->b_bcount);
@ -224,7 +225,7 @@ mfs_strategy(ap)
*
* Read and Write are handled with a simple copyin and copyout.
*
* We also partially support VOP_FREEBLKS() via B_FREEBUF. We can't implement
* We also partially support VOP_FREEBLKS() via BIO_DELETE. We can't implement
* completely -- for example, on fragments or inode metadata, but we can
* implement it for page-aligned requests.
*/
@ -235,9 +236,9 @@ mfs_doio(bp, mfsp)
{
caddr_t base = mfsp->mfs_baseoff + (bp->b_blkno << DEV_BSHIFT);
if (bp->b_flags & B_FREEBUF) {
if (bp->b_iocmd == BIO_DELETE) {
/*
* Implement B_FREEBUF, which allows the filesystem to tell
* Implement BIO_DELETE, which allows the filesystem to tell
* a block device when blocks are no longer needed (like when
* a file is deleted). We use the hook to MADV_FREE the VM.
* This makes an MFS filesystem work as well or better then
@ -263,7 +264,7 @@ mfs_doio(bp, mfsp)
}
}
bp->b_error = 0;
} else if (bp->b_flags & B_READ) {
} else if (bp->b_iocmd == BIO_READ) {
/*
* Read data from our 'memory' disk
*/

2
sys/ufs/ufs/ufs_bmap.c
View File

@ -192,7 +192,7 @@ ufs_bmaparray(vp, bn, bnp, ap, nump, runp, runb)
panic("ufs_bmaparray: indirect block not in cache");
#endif
bp->b_blkno = blkptrtodb(ump, daddr);
bp->b_flags |= B_READ;
bp->b_iocmd = BIO_READ;
bp->b_flags &= ~(B_INVAL|B_ERROR);
vfs_busy_pages(bp, 0);
VOP_STRATEGY(bp->b_vp, bp);

12
sys/ufs/ufs/ufs_disksubr.c
View File

@ -181,7 +181,7 @@ readdisklabel(dev, lp)
bp->b_blkno = LABELSECTOR * ((int)lp->d_secsize/DEV_BSIZE);
bp->b_bcount = lp->d_secsize;
bp->b_flags &= ~B_INVAL;
bp->b_flags |= B_READ;
bp->b_iocmd = BIO_READ;
BUF_STRATEGY(bp, 1);
if (biowait(bp))
msg = "I/O error";
@ -284,7 +284,7 @@ writedisklabel(dev, lp)
* (also stupid.. how do you write the first one? by raw writes?)
*/
bp->b_flags &= ~B_INVAL;
bp->b_flags |= B_READ;
bp->b_iocmd = BIO_READ;
BUF_STRATEGY(bp, 1);
error = biowait(bp);
if (error)
@ -296,8 +296,8 @@ writedisklabel(dev, lp)
if (dlp->d_magic == DISKMAGIC && dlp->d_magic2 == DISKMAGIC &&
dkcksum(dlp) == 0) {
*dlp = *lp;
bp->b_flags &= ~(B_DONE | B_READ);
bp->b_flags |= B_WRITE;
bp->b_flags &= ~B_DONE;
bp->b_iocmd = BIO_WRITE;
#ifdef __alpha__
alpha_fix_srm_checksum(bp);
#endif
@ -313,7 +313,7 @@ writedisklabel(dev, lp)
dlp = (struct disklabel *)bp->b_data;
*dlp = *lp;
bp->b_flags &= ~B_INVAL;
bp->b_flags |= B_WRITE;
bp->b_iocmd = BIO_WRITE;
BUF_STRATEGY(bp, 1);
error = biowait(bp);
#endif
@ -375,7 +375,7 @@ diskerr(bp, what, pri, blkdone, lp)
pr = printf;
sname = dsname(bp->b_dev, unit, slice, part, partname);
(*pr)("%s%s: %s %sing fsbn ", sname, partname, what,
bp->b_flags & B_READ ? "read" : "writ");
bp->b_iocmd == BIO_READ ? "read" : "writ");
sn = bp->b_blkno;
if (bp->b_bcount <= DEV_BSIZE)
(*pr)("%ld", (long)sn);

25
sys/vm/swap_pager.c
View File

@ -844,10 +844,10 @@ swap_pager_strategy(vm_object_t object, struct buf *bp)
s = splvm();
/*
* Deal with B_FREEBUF
* Deal with BIO_DELETE
*/
if (bp->b_flags & B_FREEBUF) {
if (bp->b_iocmd & BIO_DELETE) {
/*
* FREE PAGE(s) - destroy underlying swap that is no longer
* needed.
@ -872,7 +872,7 @@ swap_pager_strategy(vm_object_t object, struct buf *bp)
*/
blk = swp_pager_meta_ctl(object, start, 0);
if ((blk == SWAPBLK_NONE) && (bp->b_flags & B_READ) == 0) {
if ((blk == SWAPBLK_NONE) && (bp->b_iocmd == BIO_WRITE)) {
blk = swp_pager_getswapspace(1);
if (blk == SWAPBLK_NONE) {
bp->b_error = ENOMEM;
@ -897,7 +897,7 @@ swap_pager_strategy(vm_object_t object, struct buf *bp)
)
) {
splx(s);
if (bp->b_flags & B_READ) {
if (bp->b_iocmd == BIO_READ) {
++cnt.v_swapin;
cnt.v_swappgsin += btoc(nbp->b_bcount);
} else {
@ -925,7 +925,7 @@ swap_pager_strategy(vm_object_t object, struct buf *bp)
bp->b_resid -= PAGE_SIZE;
} else {
if (nbp == NULL) {
nbp = getchainbuf(bp, swapdev_vp, (bp->b_flags & B_READ) | B_ASYNC);
nbp = getchainbuf(bp, swapdev_vp, (bp->b_iocmd == BIO_READ) | B_ASYNC);
nbp->b_blkno = blk;
nbp->b_bcount = 0;
nbp->b_data = data;
@ -946,7 +946,7 @@ swap_pager_strategy(vm_object_t object, struct buf *bp)
if (nbp) {
if ((bp->b_flags & B_ASYNC) == 0)
nbp->b_flags &= ~B_ASYNC;
if (nbp->b_flags & B_READ) {
if (nbp->b_iocmd == BIO_READ) {
++cnt.v_swapin;
cnt.v_swappgsin += btoc(nbp->b_bcount);
} else {
@ -1086,7 +1086,7 @@ swap_pager_getpages(object, m, count, reqpage)
pmap_qenter(kva, m + i, j - i);
bp->b_flags = B_READ | B_CALL;
bp->b_iocmd = BIO_READ;
bp->b_iodone = swp_pager_async_iodone;
bp->b_rcred = bp->b_wcred = proc0.p_ucred;
bp->b_data = (caddr_t) kva;
@ -1329,10 +1329,9 @@ swap_pager_putpages(object, m, count, sync, rtvals)
if (sync == TRUE) {
bp = getpbuf(&nsw_wcount_sync);
bp->b_flags = B_CALL;
} else {
bp = getpbuf(&nsw_wcount_async);
bp->b_flags = B_CALL | B_ASYNC;
bp->b_flags = B_ASYNC;
}
bp->b_spc = NULL; /* not used, but NULL-out anyway */
@ -1481,7 +1480,7 @@ swp_pager_async_iodone(bp)
printf(
"swap_pager: I/O error - %s failed; blkno %ld,"
"size %ld, error %d\n",
((bp->b_flags & B_READ) ? "pagein" : "pageout"),
((bp->b_iocmd == BIO_READ) ? "pagein" : "pageout"),
(long)bp->b_blkno,
(long)bp->b_bcount,
bp->b_error
@ -1524,7 +1523,7 @@ swp_pager_async_iodone(bp)
* interrupt.
*/
if (bp->b_flags & B_READ) {
if (bp->b_iocmd == BIO_READ) {
/*
* When reading, reqpage needs to stay
* locked for the parent, but all other
@ -1566,7 +1565,7 @@ swp_pager_async_iodone(bp)
vm_page_activate(m);
vm_page_io_finish(m);
}
} else if (bp->b_flags & B_READ) {
} else if (bp->b_iocmd == BIO_READ) {
/*
* For read success, clear dirty bits. Nobody should
* have this page mapped but don't take any chances,
@ -1637,7 +1636,7 @@ swp_pager_async_iodone(bp)
relpbuf(
bp,
((bp->b_flags & B_READ) ? &nsw_rcount :
((bp->b_iocmd == BIO_READ) ? &nsw_rcount :
((bp->b_flags & B_ASYNC) ?
&nsw_wcount_async :
&nsw_wcount_sync

5
sys/vm/vm_pager.c
View File

@ -348,6 +348,7 @@ initpbuf(struct buf *bp)
bp->b_kvasize = MAXPHYS;
bp->b_xflags = 0;
bp->b_flags = 0;
bp->b_iodone = NULL;
bp->b_error = 0;
BUF_LOCK(bp, LK_EXCLUSIVE);
}
@ -546,7 +547,7 @@ getchainbuf(struct buf *bp, struct vnode *vp, int flags)
if (bp->b_chain.count > 4)
waitchainbuf(bp, 4, 0);
nbp->b_flags = B_CALL | (bp->b_flags & B_ORDERED) | flags;
nbp->b_flags = (bp->b_flags & B_ORDERED) | flags;
nbp->b_rcred = nbp->b_wcred = proc0.p_ucred;
nbp->b_iodone = vm_pager_chain_iodone;
@ -563,7 +564,7 @@ flushchainbuf(struct buf *nbp)
{
if (nbp->b_bcount) {
nbp->b_bufsize = nbp->b_bcount;
if ((nbp->b_flags & B_READ) == 0)
if (nbp->b_iocmd == BIO_WRITE)
nbp->b_dirtyend = nbp->b_bcount;
BUF_KERNPROC(nbp);
VOP_STRATEGY(nbp->b_vp, nbp);

2
sys/vm/vm_swap.c
View File

@ -137,7 +137,7 @@ swapdev_strategy(ap)
vhold(sp->sw_vp);
s = splvm();
if ((bp->b_flags & B_READ) == 0) {
if (bp->b_iocmd == BIO_WRITE) {
vp = bp->b_vp;
if (vp) {
vp->v_numoutput--;

4
sys/vm/vnode_pager.c
View File

@ -411,7 +411,7 @@ vnode_pager_input_smlfs(object, m)
bp = getpbuf(&vnode_pbuf_freecnt);
/* build a minimal buffer header */
bp->b_flags = B_READ | B_CALL;
bp->b_iocmd = BIO_READ;
bp->b_iodone = vnode_pager_iodone;
bp->b_rcred = bp->b_wcred = curproc->p_ucred;
if (bp->b_rcred != NOCRED)
@ -729,7 +729,7 @@ vnode_pager_generic_getpages(vp, m, bytecount, reqpage)
pmap_qenter(kva, m, count);
/* build a minimal buffer header */
bp->b_flags = B_READ | B_CALL;
bp->b_iocmd = BIO_READ;
bp->b_iodone = vnode_pager_iodone;
/* B_PHYS is not set, but it is nice to fill this in */
bp->b_rcred = bp->b_wcred = curproc->p_ucred;