bp 793 altq/altq_rmclass.c rm_class_t *p, *bp;
bp 796 altq/altq_rmclass.c if ((bp = ifd->active_[i]) != NULL) {
bp 797 altq/altq_rmclass.c p = bp;
bp 804 altq/altq_rmclass.c } while (p != bp);
bp 69 arch/i386/i386/disksubr.c struct buf *bp = NULL;
bp 96 arch/i386/i386/disksubr.c bp = geteblk((int)lp->d_secsize);
bp 97 arch/i386/i386/disksubr.c bp->b_dev = dev;
bp 99 arch/i386/i386/disksubr.c msg = readdoslabel(bp, strat, lp, NULL, spoofonly);
bp 117 arch/i386/i386/disksubr.c if (bp) {
bp 118 arch/i386/i386/disksubr.c bp->b_flags |= B_INVAL;
bp 119 arch/i386/i386/disksubr.c brelse(bp);
bp 132 arch/i386/i386/disksubr.c struct buf *bp = NULL;
bp 135 arch/i386/i386/disksubr.c bp = geteblk((int)lp->d_secsize);
bp 136 arch/i386/i386/disksubr.c bp->b_dev = dev;
bp 138 arch/i386/i386/disksubr.c if (readdoslabel(bp, strat, lp, &partoff, 1) != NULL)
bp 142 arch/i386/i386/disksubr.c bp->b_blkno = partoff + LABELSECTOR;
bp 143 arch/i386/i386/disksubr.c bp->b_bcount = lp->d_secsize;
bp 144 arch/i386/i386/disksubr.c bp->b_flags = B_BUSY | B_READ;
bp 145 arch/i386/i386/disksubr.c (*strat)(bp);
bp 146 arch/i386/i386/disksubr.c if ((error = biowait(bp)) != 0)
bp 149 arch/i386/i386/disksubr.c dlp = (struct disklabel *)(bp->b_data + LABELOFFSET);
bp 151 arch/i386/i386/disksubr.c bp->b_flags = B_BUSY | B_WRITE;
bp 152 arch/i386/i386/disksubr.c (*strat)(bp);
bp 153 arch/i386/i386/disksubr.c error = biowait(bp);
bp 156 arch/i386/i386/disksubr.c if (bp) {
bp 157 arch/i386/i386/disksubr.c bp->b_flags |= B_INVAL;
bp 158 arch/i386/i386/disksubr.c brelse(bp);
bp 57 arch/i386/i386/dkcsum.c struct buf *bp;
bp 82 arch/i386/i386/dkcsum.c bp = geteblk(bios_cksumlen * DEV_BSIZE); /* XXX error check? */
bp 87 arch/i386/i386/dkcsum.c bp->b_dev = dev = dev_rawpart(dv);
bp 107 arch/i386/i386/dkcsum.c bp->b_blkno = 0;
bp 108 arch/i386/i386/dkcsum.c bp->b_bcount = bios_cksumlen * DEV_BSIZE;
bp 109 arch/i386/i386/dkcsum.c bp->b_flags = B_BUSY | B_READ;
bp 110 arch/i386/i386/dkcsum.c bp->b_cylinder = 0;
bp 111 arch/i386/i386/dkcsum.c (*bdsw->d_strategy)(bp);
bp 112 arch/i386/i386/dkcsum.c if ((error = biowait(bp))) {
bp 136 arch/i386/i386/dkcsum.c csum = adler32(0, bp->b_data, bios_cksumlen * DEV_BSIZE);
bp 181 arch/i386/i386/dkcsum.c type = major(bp->b_dev);
bp 184 arch/i386/i386/dkcsum.c unit = DISKUNIT(bp->b_dev);
bp 197 arch/i386/i386/dkcsum.c type = major(bp->b_dev);
bp 200 arch/i386/i386/dkcsum.c unit = DISKUNIT(bp->b_dev);
bp 211 arch/i386/i386/dkcsum.c hit->bsd_dev = MAKEBOOTDEV(major(bp->b_dev), 0, 0,
bp 212 arch/i386/i386/dkcsum.c DISKUNIT(bp->b_dev), RAW_PART);
bp 217 arch/i386/i386/dkcsum.c bp->b_flags |= B_INVAL;
bp 218 arch/i386/i386/dkcsum.c brelse(bp);
bp 596 arch/i386/i386/mpbios.c const struct mpbios_bus *bp =
bp 598 arch/i386/i386/mpbios.c if (bp->bus_id >= mp_nbus)
bp 599 arch/i386/i386/mpbios.c mp_nbus = bp->bus_id + 1;
bp 231 arch/i386/i386/vm_machdep.c vmapbuf(struct buf *bp, vsize_t len)
bp 236 arch/i386/i386/vm_machdep.c if ((bp->b_flags & B_PHYS) == 0)
bp 238 arch/i386/i386/vm_machdep.c faddr = trunc_page((vaddr_t)(bp->b_saveaddr = bp->b_data));
bp 239 arch/i386/i386/vm_machdep.c off = (vaddr_t)bp->b_data - faddr;
bp 242 arch/i386/i386/vm_machdep.c bp->b_data = (caddr_t)(taddr + off);
bp 256 arch/i386/i386/vm_machdep.c pmap_extract(vm_map_pmap(&bp->b_proc->p_vmspace->vm_map),
bp 271 arch/i386/i386/vm_machdep.c vunmapbuf(struct buf *bp, vsize_t len)
bp 275 arch/i386/i386/vm_machdep.c if ((bp->b_flags & B_PHYS) == 0)
bp 277 arch/i386/i386/vm_machdep.c addr = trunc_page((vaddr_t)bp->b_data);
bp 278 arch/i386/i386/vm_machdep.c off = (vaddr_t)bp->b_data - addr;
bp 283 arch/i386/i386/vm_machdep.c bp->b_data = bp->b_saveaddr;
bp 284 arch/i386/i386/vm_machdep.c bp->b_saveaddr = 0;
bp 232 arch/i386/pci/pci_machdep.c pci_decompose_tag(pci_chipset_tag_t pc, pcitag_t tag, int *bp, int *dp, int *fp)
bp 237 arch/i386/pci/pci_machdep.c if (bp != NULL)
bp 238 arch/i386/pci/pci_machdep.c *bp = (tag.mode1 >> 16) & 0xff;
bp 245 arch/i386/pci/pci_machdep.c if (bp != NULL)
bp 246 arch/i386/pci/pci_machdep.c *bp = tag.mode2.forward & 0xff;
bp 243 arch/i386/stand/installboot/installboot.c char *bp;
bp 288 arch/i386/stand/installboot/installboot.c if ((bp = calloc(tdsize, 1)) == NULL) {
bp 294 arch/i386/stand/installboot/installboot.c if (read(fd, bp, tdsize) != tdsize) {
bp 306 arch/i386/stand/installboot/installboot.c return bp;
bp 483 arch/i386/stand/installboot/installboot.c u_int8_t *bp;
bp 523 arch/i386/stand/installboot/installboot.c bp = (u_int8_t *) vp;
bp 524 arch/i386/stand/installboot/installboot.c *bp = (u_int8_t) sym->sym_value;
bp 165 compat/freebsd/freebsd_exec.c char *bp, *brand;
bp 178 compat/freebsd/freebsd_exec.c if ((error = emul_find(p, NULL, freebsd_emul_path, itp, &bp, 0)))
bp 180 compat/freebsd/freebsd_exec.c if ((error = copystr(bp, itp, MAXPATHLEN, &len)))
bp 182 compat/freebsd/freebsd_exec.c free(bp, M_TEMP);
bp 93 compat/ibcs2/ibcs2_ipc.c cvt_msqid2imsqid(bp, ibp)
bp 94 compat/ibcs2/ibcs2_ipc.c struct msqid_ds *bp;
bp 97 compat/ibcs2/ibcs2_ipc.c ibp->msg_perm = bp->msg_perm;
bp 98 compat/ibcs2/ibcs2_ipc.c ibp->msg_first = bp->msg_first;
bp 99 compat/ibcs2/ibcs2_ipc.c ibp->msg_last = bp->msg_last;
bp 100 compat/ibcs2/ibcs2_ipc.c ibp->msg_cbytes = (u_short)bp->msg_cbytes;
bp 101 compat/ibcs2/ibcs2_ipc.c ibp->msg_qnum = (u_short)bp->msg_qnum;
bp 102 compat/ibcs2/ibcs2_ipc.c ibp->msg_qbytes = (u_short)bp->msg_qbytes;
bp 103 compat/ibcs2/ibcs2_ipc.c ibp->msg_lspid = (u_short)bp->msg_lspid;
bp 104 compat/ibcs2/ibcs2_ipc.c ibp->msg_lrpid = (u_short)bp->msg_lrpid;
bp 105 compat/ibcs2/ibcs2_ipc.c ibp->msg_stime = bp->msg_stime;
bp 106 compat/ibcs2/ibcs2_ipc.c ibp->msg_rtime = bp->msg_rtime;
bp 107 compat/ibcs2/ibcs2_ipc.c ibp->msg_ctime = bp->msg_ctime;
bp 112 compat/ibcs2/ibcs2_ipc.c cvt_imsqid2msqid(ibp, bp)
bp 114 compat/ibcs2/ibcs2_ipc.c struct msqid_ds *bp;
bp 116 compat/ibcs2/ibcs2_ipc.c bp->msg_perm = ibp->msg_perm;
bp 117 compat/ibcs2/ibcs2_ipc.c bp->msg_first = ibp->msg_first;
bp 118 compat/ibcs2/ibcs2_ipc.c bp->msg_last = ibp->msg_last;
bp 119 compat/ibcs2/ibcs2_ipc.c bp->msg_cbytes = ibp->msg_cbytes;
bp 120 compat/ibcs2/ibcs2_ipc.c bp->msg_qnum = ibp->msg_qnum;
bp 121 compat/ibcs2/ibcs2_ipc.c bp->msg_qbytes = ibp->msg_qbytes;
bp 122 compat/ibcs2/ibcs2_ipc.c bp->msg_lspid = ibp->msg_lspid;
bp 123 compat/ibcs2/ibcs2_ipc.c bp->msg_lrpid = ibp->msg_lrpid;
bp 124 compat/ibcs2/ibcs2_ipc.c bp->msg_stime = ibp->msg_stime;
bp 125 compat/ibcs2/ibcs2_ipc.c bp->msg_rtime = ibp->msg_rtime;
bp 126 compat/ibcs2/ibcs2_ipc.c bp->msg_ctime = ibp->msg_ctime;
bp 218 compat/ibcs2/ibcs2_ipc.c cvt_sem2isem(bp, ibp)
bp 219 compat/ibcs2/ibcs2_ipc.c struct sem *bp;
bp 222 compat/ibcs2/ibcs2_ipc.c ibp->semval = bp->semval;
bp 223 compat/ibcs2/ibcs2_ipc.c ibp->sempid = bp->sempid;
bp 224 compat/ibcs2/ibcs2_ipc.c ibp->semncnt = bp->semncnt;
bp 225 compat/ibcs2/ibcs2_ipc.c ibp->semzcnt = bp->semzcnt;
bp 230 compat/ibcs2/ibcs2_ipc.c cvt_isem2sem(ibp, bp)
bp 232 compat/ibcs2/ibcs2_ipc.c struct sem *bp;
bp 234 compat/ibcs2/ibcs2_ipc.c bp->semval = ibp->semval;
bp 235 compat/ibcs2/ibcs2_ipc.c bp->sempid = ibp->sempid;
bp 236 compat/ibcs2/ibcs2_ipc.c bp->semncnt = ibp->semncnt;
bp 237 compat/ibcs2/ibcs2_ipc.c bp->semzcnt = ibp->semzcnt;
bp 243 compat/ibcs2/ibcs2_ipc.c cvt_semid2isemid(bp, ibp)
bp 244 compat/ibcs2/ibcs2_ipc.c struct semid_ds *bp;
bp 247 compat/ibcs2/ibcs2_ipc.c ibp->sem_perm = bp->sem_perm;
bp 248 compat/ibcs2/ibcs2_ipc.c ibp->sem_base = (struct ibcs2_sem *)bp->sem_base;
bp 249 compat/ibcs2/ibcs2_ipc.c ibp->sem_nsems = bp->sem_nsems;
bp 250 compat/ibcs2/ibcs2_ipc.c ibp->sem_otime = bp->sem_otime;
bp 251 compat/ibcs2/ibcs2_ipc.c ibp->sem_ctime = bp->sem_ctime;
bp 256 compat/ibcs2/ibcs2_ipc.c cvt_isemid2semid(ibp, bp)
bp 258 compat/ibcs2/ibcs2_ipc.c struct semid_ds *bp;
bp 260 compat/ibcs2/ibcs2_ipc.c bp->sem_perm = ibp->sem_perm;
bp 261 compat/ibcs2/ibcs2_ipc.c bp->sem_base = (struct sem *)ibp->sem_base;
bp 262 compat/ibcs2/ibcs2_ipc.c bp->sem_nsems = ibp->sem_nsems;
bp 263 compat/ibcs2/ibcs2_ipc.c bp->sem_otime = ibp->sem_otime;
bp 264 compat/ibcs2/ibcs2_ipc.c bp->sem_ctime = ibp->sem_ctime;
bp 359 compat/ibcs2/ibcs2_ipc.c cvt_shmid2ishmid(bp, ibp)
bp 360 compat/ibcs2/ibcs2_ipc.c struct shmid_ds *bp;
bp 363 compat/ibcs2/ibcs2_ipc.c ibp->shm_perm = bp->shm_perm;
bp 364 compat/ibcs2/ibcs2_ipc.c ibp->shm_segsz = bp->shm_segsz;
bp 365 compat/ibcs2/ibcs2_ipc.c ibp->shm_lpid = bp->shm_lpid;
bp 366 compat/ibcs2/ibcs2_ipc.c ibp->shm_cpid = bp->shm_cpid;
bp 367 compat/ibcs2/ibcs2_ipc.c ibp->shm_nattch = bp->shm_nattch;
bp 369 compat/ibcs2/ibcs2_ipc.c ibp->shm_atime = bp->shm_atime;
bp 370 compat/ibcs2/ibcs2_ipc.c ibp->shm_dtime = bp->shm_dtime;
bp 371 compat/ibcs2/ibcs2_ipc.c ibp->shm_ctime = bp->shm_ctime;
bp 376 compat/ibcs2/ibcs2_ipc.c cvt_ishmid2shmid(ibp, bp)
bp 378 compat/ibcs2/ibcs2_ipc.c struct shmid_ds *bp;
bp 380 compat/ibcs2/ibcs2_ipc.c bp->shm_perm = ibp->shm_perm;
bp 381 compat/ibcs2/ibcs2_ipc.c bp->shm_segsz = ibp->shm_segsz;
bp 382 compat/ibcs2/ibcs2_ipc.c bp->shm_lpid = ibp->shm_lpid;
bp 383 compat/ibcs2/ibcs2_ipc.c bp->shm_cpid = ibp->shm_cpid;
bp 384 compat/ibcs2/ibcs2_ipc.c bp->shm_nattch = ibp->shm_nattch;
bp 385 compat/ibcs2/ibcs2_ipc.c bp->shm_atime = ibp->shm_atime;
bp 386 compat/ibcs2/ibcs2_ipc.c bp->shm_dtime = ibp->shm_dtime;
bp 387 compat/ibcs2/ibcs2_ipc.c bp->shm_ctime = ibp->shm_ctime;
bp 388 compat/ibcs2/ibcs2_ipc.c bp->shm_internal = (void *)0; /* ignored anyway */
bp 481 compat/linux/linux_exec.c char *bp, *brand;
bp 489 compat/linux/linux_exec.c if ((error = emul_find(p, NULL, linux_emul_path, itp, &bp, 0)))
bp 491 compat/linux/linux_exec.c if ((error = copystr(bp, itp, MAXPATHLEN, &len)))
bp 493 compat/linux/linux_exec.c free(bp, M_TEMP);
bp 125 compat/svr4/svr4_exec.c char *bp;
bp 130 compat/svr4/svr4_exec.c if ((error = emul_find(p, NULL, svr4_emul_path, itp, &bp, 0)))
bp 132 compat/svr4/svr4_exec.c if ((error = copystr(bp, itp, MAXPATHLEN, &len)))
bp 134 compat/svr4/svr4_exec.c free(bp, M_TEMP);
bp 378 dev/ata/wd.c struct buf *dp, *bp;
bp 383 dev/ata/wd.c for (dp = &sc->sc_q; (bp = dp->b_actf) != NULL; ) {
bp 384 dev/ata/wd.c dp->b_actf = bp->b_actf;
bp 385 dev/ata/wd.c bp->b_error = ENXIO;
bp 386 dev/ata/wd.c bp->b_flags |= B_ERROR;
bp 387 dev/ata/wd.c biodone(bp);
bp 416 dev/ata/wd.c wdstrategy(struct buf *bp)
bp 421 dev/ata/wd.c wd = wdlookup(DISKUNIT(bp->b_dev));
bp 423 dev/ata/wd.c bp->b_error = ENXIO;
bp 431 dev/ata/wd.c if (bp->b_blkno < 0 ||
bp 432 dev/ata/wd.c (bp->b_bcount % wd->sc_dk.dk_label->d_secsize) != 0 ||
bp 433 dev/ata/wd.c (bp->b_bcount / wd->sc_dk.dk_label->d_secsize) >= (1 << NBBY)) {
bp 434 dev/ata/wd.c bp->b_error = EINVAL;
bp 440 dev/ata/wd.c bp->b_error = EIO;
bp 445 dev/ata/wd.c if (bp->b_bcount == 0)
bp 452 dev/ata/wd.c if (DISKPART(bp->b_dev) != RAW_PART &&
bp 453 dev/ata/wd.c bounds_check_with_label(bp, wd->sc_dk.dk_label,
bp 458 dev/ata/wd.c disksort(&wd->sc_q, bp);
bp 464 dev/ata/wd.c bp->b_flags |= B_ERROR;
bp 467 dev/ata/wd.c bp->b_resid = bp->b_bcount;
bp 469 dev/ata/wd.c biodone(bp);
bp 482 dev/ata/wd.c struct buf *dp, *bp = NULL;
bp 490 dev/ata/wd.c if ((bp = dp->b_actf) == NULL) /* yes, an assign */
bp 492 dev/ata/wd.c dp->b_actf = bp->b_actf;
bp 500 dev/ata/wd.c __wdstart(wd, bp);
bp 505 dev/ata/wd.c __wdstart(struct wd_softc *wd, struct buf *bp)
bp 509 dev/ata/wd.c wd->sc_wdc_bio.blkno = bp->b_blkno +
bp 510 dev/ata/wd.c DL_GETPOFFSET(&wd->sc_dk.dk_label->d_partitions[DISKPART(bp->b_dev)]);
bp 513 dev/ata/wd.c wd->sc_bp = bp;
bp 523 dev/ata/wd.c nblks = bp->b_bcount / wd->sc_dk.dk_label->d_secsize;
bp 531 dev/ata/wd.c if (bp->b_flags & B_READ)
bp 533 dev/ata/wd.c wd->sc_wdc_bio.bcount = bp->b_bcount;
bp 534 dev/ata/wd.c wd->sc_wdc_bio.databuf = bp->b_data;
bp 563 dev/ata/wd.c struct buf *bp = wd->sc_bp;
bp 568 dev/ata/wd.c bp->b_resid = wd->sc_wdc_bio.bcount;
bp 572 dev/ata/wd.c bp->b_flags |= B_ERROR;
bp 573 dev/ata/wd.c bp->b_error = ENXIO;
bp 594 dev/ata/wd.c diskerr(bp, "wd", errbuf, LOG_PRINTF,
bp 602 dev/ata/wd.c bp->b_flags |= B_ERROR;
bp 603 dev/ata/wd.c bp->b_error = EIO;
bp 610 dev/ata/wd.c disk_unbusy(&wd->sc_dk, (bp->b_bcount - bp->b_resid),
bp 611 dev/ata/wd.c (bp->b_flags & B_READ));
bp 612 dev/ata/wd.c biodone(bp);
bp 621 dev/ata/wd.c struct buf *bp = wd->sc_bp;
bp 627 dev/ata/wd.c disk_unbusy(&wd->sc_dk, 0, (bp->b_flags & B_READ));
bp 628 dev/ata/wd.c __wdstart(v, bp);
bp 941 dev/ata/wd.c wdformat(struct buf *bp)
bp 944 dev/ata/wd.c bp->b_flags |= B_FORMAT;
bp 945 dev/ata/wd.c return wdstrategy(bp);
bp 167 dev/atapiscsi/atapiscsi.c void wdc_atapi_minphys(struct buf *bp);
bp 436 dev/atapiscsi/atapiscsi.c wdc_atapi_minphys (struct buf *bp)
bp 438 dev/atapiscsi/atapiscsi.c if(bp->b_bcount > MAX_SIZE)
bp 439 dev/atapiscsi/atapiscsi.c bp->b_bcount = MAX_SIZE;
bp 440 dev/atapiscsi/atapiscsi.c minphys(bp);
bp 658 dev/ccd.c ccdstrategy(struct buf *bp)
bp 660 dev/ccd.c int unit = DISKUNIT(bp->b_dev);
bp 666 dev/ccd.c CCD_DPRINTF(CCDB_FOLLOW, ("ccdstrategy(%p): unit %d\n", bp, unit));
bp 669 dev/ccd.c bp->b_error = ENXIO;
bp 670 dev/ccd.c bp->b_resid = bp->b_bcount;
bp 671 dev/ccd.c bp->b_flags |= B_ERROR;
bp 676 dev/ccd.c if (bp->b_bcount == 0)
bp 686 dev/ccd.c if (DISKPART(bp->b_dev) != RAW_PART &&
bp 687 dev/ccd.c bounds_check_with_label(bp, lp, wlabel) <= 0)
bp 690 dev/ccd.c bp->b_resid = bp->b_bcount;
bp 696 dev/ccd.c ccdstart(cs, bp);
bp 701 dev/ccd.c biodone(bp);
bp 706 dev/ccd.c ccdstart(struct ccd_softc *cs, struct buf *bp)
bp 714 dev/ccd.c CCD_DPRINTF(CCDB_FOLLOW, ("ccdstart(%p, %p, %s)\n", cs, bp,
bp 715 dev/ccd.c bp->b_flags & B_READ? "read" : "write"));
bp 723 dev/ccd.c bn = bp->b_blkno;
bp 724 dev/ccd.c pp = &cs->sc_dkdev.dk_label->d_partitions[DISKPART(bp->b_dev)];
bp 733 dev/ccd.c addr = bp->b_data;
bp 734 dev/ccd.c for (bcount = bp->b_bcount; bcount > 0; bcount -= rcount) {
bp 735 dev/ccd.c rcount = ccdbuffer(cs, bp, bn, addr, bcount, cbpp);
bp 763 dev/ccd.c ccdbuffer(struct ccd_softc *cs, struct buf *bp, daddr64_t bn, caddr_t addr,
bp 775 dev/ccd.c cs, bp, bn, addr, bcount, cbpp));
bp 816 dev/ccd.c if (bp->b_flags & B_READ &&
bp 817 dev/ccd.c bcount > bp->b_bcount / 2 &&
bp 842 dev/ccd.c nbp->b_flags = bp->b_flags | B_CALL;
bp 844 dev/ccd.c nbp->b_proc = bp->b_proc;
bp 855 dev/ccd.c cbp->cb_obp = bp;
bp 879 dev/ccd.c ci->ci_dev, ci-cs->sc_cinfo, cbp, bp->b_blkno,
bp 880 dev/ccd.c bp->b_data, bp->b_bcount));
bp 886 dev/ccd.c ccdintr(struct ccd_softc *cs, struct buf *bp)
bp 891 dev/ccd.c CCD_DPRINTF(CCDB_FOLLOW, ("ccdintr(%p, %p)\n", cs, bp));
bp 896 dev/ccd.c if (bp->b_flags & B_ERROR)
bp 897 dev/ccd.c bp->b_resid = bp->b_bcount;
bp 898 dev/ccd.c disk_unbusy(&cs->sc_dkdev, (bp->b_bcount - bp->b_resid),
bp 899 dev/ccd.c (bp->b_flags & B_READ));
bp 900 dev/ccd.c biodone(bp);
bp 912 dev/ccd.c struct buf *bp = cbp->cb_obp;
bp 914 dev/ccd.c long count = bp->b_bcount;
bp 923 dev/ccd.c bp, bp->b_bcount, bp->b_resid));
bp 933 dev/ccd.c bp->b_flags |= B_ERROR;
bp 934 dev/ccd.c bp->b_error = vbp->b_error ?
bp 940 dev/ccd.c cs->sc_xname, bp->b_error, cbp->cb_comp, comptype);
bp 966 dev/ccd.c if (count > bp->b_resid)
bp 968 dev/ccd.c bp->b_resid -= count;
bp 969 dev/ccd.c if (bp->b_resid == 0)
bp 970 dev/ccd.c ccdintr(cs, bp);
bp 928 dev/eisa/aha1742.c ahbminphys(bp)
bp 929 dev/eisa/aha1742.c struct buf *bp;
bp 932 dev/eisa/aha1742.c if (bp->b_bcount > ((AHB_NSEG - 1) << PGSHIFT))
bp 933 dev/eisa/aha1742.c bp->b_bcount = ((AHB_NSEG - 1) << PGSHIFT);
bp 934 dev/eisa/aha1742.c minphys(bp);
bp 780 dev/flash.c flashstrategy(struct buf *bp)
bp 785 dev/flash.c sc = flashlookup(flashunit(bp->b_dev));
bp 787 dev/flash.c bp->b_error = ENXIO;
bp 792 dev/flash.c if ((bp->b_bcount % sc->sc_flashdev->pagesize) != 0) {
bp 793 dev/flash.c bp->b_error = EINVAL;
bp 799 dev/flash.c bp->b_error = EIO;
bp 804 dev/flash.c if (flashsafe(bp->b_dev) && flashsafestrategy(sc, bp) <= 0)
bp 808 dev/flash.c if (bp->b_bcount == 0)
bp 812 dev/flash.c if (flashpart(bp->b_dev) != RAW_PART &&
bp 813 dev/flash.c bounds_check_with_label(bp, sc->sc_dk.dk_label, 0) <= 0)
bp 818 dev/flash.c disksort(&sc->sc_q, bp);
bp 825 dev/flash.c bp->b_flags |= B_ERROR;
bp 827 dev/flash.c if ((bp->b_flags & B_ERROR) != 0)
bp 828 dev/flash.c bp->b_resid = bp->b_bcount;
bp 830 dev/flash.c biodone(bp);
bp 881 dev/flash.c struct buf *dp, *bp;
bp 886 dev/flash.c bp = dp->b_actf;
bp 887 dev/flash.c if (bp == NULL)
bp 889 dev/flash.c dp->b_actf = bp->b_actf;
bp 892 dev/flash.c _flashstart(sc, bp);
bp 897 dev/flash.c _flashstart(struct flash_softc *sc, struct buf *bp)
bp 903 dev/flash.c part = flashpart(bp->b_dev);
bp 905 dev/flash.c bp->b_blkno;
bp 912 dev/flash.c if (!flashsafe(bp->b_dev) && pgno == sc->sc_flashdev->capacity) {
bp 913 dev/flash.c bp->b_resid = bp->b_bcount;
bp 914 dev/flash.c biodone(bp);
bp 917 dev/flash.c bp->b_error = EINVAL;
bp 918 dev/flash.c bp->b_flags |= B_ERROR;
bp 919 dev/flash.c biodone(bp);
bp 923 dev/flash.c sc->sc_bp = bp;
bp 930 dev/flash.c if ((bp->b_flags & B_READ) != 0)
bp 931 dev/flash.c bp->b_error = flash_chip_read_page(sc, pgno, bp->b_data,
bp 934 dev/flash.c bp->b_error = flash_chip_write_page(sc, pgno, bp->b_data,
bp 936 dev/flash.c if (bp->b_error == 0)
bp 937 dev/flash.c bp->b_resid = bp->b_bcount - sc->sc_flashdev->pagesize;
bp 946 dev/flash.c struct buf *bp = sc->sc_bp;
bp 949 dev/flash.c disk_unbusy(&sc->sc_dk, bp->b_bcount - bp->b_resid,
bp 950 dev/flash.c (bp->b_flags & B_READ) != 0);
bp 952 dev/flash.c if (bp->b_error != 0)
bp 953 dev/flash.c bp->b_flags |= B_ERROR;
bp 955 dev/flash.c biodone(bp);
bp 1029 dev/flash.c flashminphys(struct buf *bp)
bp 1033 dev/flash.c sc = flashlookup(flashunit(bp->b_dev));
bp 1035 dev/flash.c if (bp->b_bcount > sc->sc_flashdev->pagesize)
bp 1036 dev/flash.c bp->b_bcount = sc->sc_flashdev->pagesize;
bp 1061 dev/flash.c flashsafestrategy(struct flash_softc *sc, struct buf *bp)
bp 1064 dev/flash.c return sc->sc_tag->safe_strategy(sc->sc_cookie, bp);
bp 555 dev/i2o/ioprbs.c ioprbsminphys(bp)
bp 556 dev/i2o/ioprbs.c struct buf *bp;
bp 558 dev/i2o/ioprbs.c minphys(bp);
bp 566 dev/i2o/ioprbs.c struct buf *bp = ccb->ic_xs->bp;
bp 594 dev/i2o/ioprbs.c if (bp) {
bp 596 dev/i2o/ioprbs.c bp->b_flags |= B_ERROR;
bp 597 dev/i2o/ioprbs.c bp->b_error = EIO;
bp 598 dev/i2o/ioprbs.c bp->b_resid = bp->b_bcount;
bp 600 dev/i2o/ioprbs.c bp->b_resid = bp->b_bcount - letoh32(rb->transfercount);
bp 82 dev/i2o/iopsp.c void iopspminphys(struct buf *bp);
bp 412 dev/i2o/iopsp.c iopspminphys(bp)
bp 413 dev/i2o/iopsp.c struct buf *bp;
bp 415 dev/i2o/iopsp.c if (bp->b_bcount > IOP_MAX_XFER)
bp 416 dev/i2o/iopsp.c bp->b_bcount = IOP_MAX_XFER;
bp 417 dev/i2o/iopsp.c minphys(bp);
bp 2484 dev/ic/aac.c aacminphys(struct buf *bp)
bp 2487 dev/ic/aac.c u_int8_t *buf = bp->b_data;
bp 2492 dev/ic/aac.c AAC_DPRINTF(AAC_D_MISC, ("aacminphys(0x%x)\n", bp));
bp 2495 dev/ic/aac.c if (bp->b_bcount > ((AAC_MAXOFFSETS - 1) * PAGE_SIZE))
bp 2496 dev/ic/aac.c bp->b_bcount = ((AAC_MAXOFFSETS - 1) * PAGE_SIZE);
bp 2500 dev/ic/aac.c for (off = PAGE_SIZE, pa = vtophys(buf); off < bp->b_bcount;
bp 2503 dev/ic/aac.c bp->b_bcount = off;
bp 2507 dev/ic/aac.c minphys(bp);
bp 626 dev/ic/adv.c advminphys(bp)
bp 627 dev/ic/adv.c struct buf *bp;
bp 630 dev/ic/adv.c if (bp->b_bcount > ((ASC_MAX_SG_LIST - 1) * PAGE_SIZE))
bp 631 dev/ic/adv.c bp->b_bcount = ((ASC_MAX_SG_LIST - 1) * PAGE_SIZE);
bp 632 dev/ic/adv.c minphys(bp);
bp 640 dev/ic/adw.c adw_minphys(bp)
bp 641 dev/ic/adw.c struct buf *bp;
bp 644 dev/ic/adw.c if (bp->b_bcount > ((ADW_MAX_SG_LIST - 1) * PAGE_SIZE))
bp 645 dev/ic/adw.c bp->b_bcount = ((ADW_MAX_SG_LIST - 1) * PAGE_SIZE);
bp 646 dev/ic/adw.c minphys(bp);
bp 566 dev/ic/aic6360.c aic_minphys(struct buf *bp)
bp 570 dev/ic/aic6360.c if (bp->b_bcount > (AIC_NSEG << PGSHIFT))
bp 571 dev/ic/aic6360.c bp->b_bcount = (AIC_NSEG << PGSHIFT);
bp 572 dev/ic/aic6360.c minphys(bp);
bp 288 dev/ic/aic79xx_openbsd.c ahd_minphys(struct buf *bp)
bp 297 dev/ic/aic79xx_openbsd.c if (bp->b_bcount > ((AHD_NSEG - 1) * PAGE_SIZE)) {
bp 298 dev/ic/aic79xx_openbsd.c bp->b_bcount = ((AHD_NSEG - 1) * PAGE_SIZE);
bp 300 dev/ic/aic79xx_openbsd.c minphys(bp);
bp 291 dev/ic/aic7xxx_openbsd.c ahc_minphys(bp)
bp 292 dev/ic/aic7xxx_openbsd.c struct buf *bp;
bp 301 dev/ic/aic7xxx_openbsd.c if (bp->b_bcount > ((AHC_NSEG - 1) * PAGE_SIZE)) {
bp 302 dev/ic/aic7xxx_openbsd.c bp->b_bcount = ((AHC_NSEG - 1) * PAGE_SIZE);
bp 304 dev/ic/aic7xxx_openbsd.c minphys(bp);
bp 102 dev/ic/ami.c void amiminphys(struct buf *bp);
bp 1253 dev/ic/ami.c amiminphys(struct buf *bp)
bp 1255 dev/ic/ami.c if (bp->b_bcount > AMI_MAXFER)
bp 1256 dev/ic/ami.c bp->b_bcount = AMI_MAXFER;
bp 1257 dev/ic/ami.c minphys(bp);
bp 879 dev/ic/awi.c struct awi_bss *bp;
bp 900 dev/ic/awi.c while ((bp = TAILQ_FIRST(&sc->sc_scan)) != NULL) {
bp 901 dev/ic/awi.c TAILQ_REMOVE(&sc->sc_scan, bp, list);
bp 902 dev/ic/awi.c free(bp, M_DEVBUF);
bp 1712 dev/ic/awi.c struct awi_bss *bp;
bp 1714 dev/ic/awi.c while ((bp = TAILQ_FIRST(&sc->sc_scan)) != NULL) {
bp 1715 dev/ic/awi.c TAILQ_REMOVE(&sc->sc_scan, bp, list);
bp 1716 dev/ic/awi.c free(bp, M_DEVBUF);
bp 1778 dev/ic/awi.c struct awi_bss *bp, *sbp;
bp 1781 dev/ic/awi.c bp = TAILQ_FIRST(&sc->sc_scan);
bp 1782 dev/ic/awi.c if (bp == NULL) {
bp 1799 dev/ic/awi.c for (; bp != NULL; bp = TAILQ_NEXT(bp, list)) {
bp 1800 dev/ic/awi.c if (bp->fails) {
bp 1806 dev/ic/awi.c if (bp->fails++ < 3)
bp 1808 dev/ic/awi.c bp->fails = 0;
bp 1817 dev/ic/awi.c if (bp->pattern < sc->sc_scan_min ||
bp 1818 dev/ic/awi.c bp->pattern > sc->sc_scan_max)
bp 1821 dev/ic/awi.c if (bp->chanset < sc->sc_scan_min ||
bp 1822 dev/ic/awi.c bp->chanset > sc->sc_scan_max)
bp 1826 dev/ic/awi.c if (!(bp->capinfo & IEEE80211_CAPINFO_ESS) ||
bp 1827 dev/ic/awi.c (bp->capinfo & IEEE80211_CAPINFO_IBSS))
bp 1830 dev/ic/awi.c if ((bp->capinfo & IEEE80211_CAPINFO_ESS) ||
bp 1831 dev/ic/awi.c !(bp->capinfo & IEEE80211_CAPINFO_IBSS))
bp 1835 dev/ic/awi.c if (bp->capinfo & IEEE80211_CAPINFO_PRIVACY)
bp 1838 dev/ic/awi.c if (!(bp->capinfo & IEEE80211_CAPINFO_PRIVACY))
bp 1842 dev/ic/awi.c memcmp(&sc->sc_mib_mac.aDesired_ESS_ID, bp->essid,
bp 1843 dev/ic/awi.c sizeof(bp->essid)) != 0)
bp 1847 dev/ic/awi.c ether_sprintf(bp->esrc));
bp 1849 dev/ic/awi.c printf(" %2d/%d%c", bp->pattern, bp->chanset,
bp 1852 dev/ic/awi.c printf(" %4d%c", bp->chanset,
bp 1854 dev/ic/awi.c printf(" %+4d", bp->rssi);
bp 1856 dev/ic/awi.c (bp->capinfo & IEEE80211_CAPINFO_ESS) ? "ess" :
bp 1857 dev/ic/awi.c (bp->capinfo & IEEE80211_CAPINFO_IBSS) ? "ibss" :
bp 1861 dev/ic/awi.c (bp->capinfo & IEEE80211_CAPINFO_PRIVACY) ? "wep" :
bp 1864 dev/ic/awi.c awi_print_essid(bp->essid);
bp 1868 dev/ic/awi.c if (sbp == NULL || bp->rssi > sbp->rssi)
bp 1869 dev/ic/awi.c sbp = bp;
bp 1886 dev/ic/awi.c struct awi_bss *bp;
bp 1953 dev/ic/awi.c for (bp = TAILQ_FIRST(&sc->sc_scan); bp != NULL;
bp 1954 dev/ic/awi.c bp = TAILQ_NEXT(bp, list)) {
bp 1955 dev/ic/awi.c if (memcmp(bp->esrc, wh->i_addr2, ETHER_ADDR_LEN) == 0 &&
bp 1956 dev/ic/awi.c memcmp(bp->bssid, wh->i_addr3, ETHER_ADDR_LEN) == 0)
bp 1959 dev/ic/awi.c if (bp == NULL) {
bp 1960 dev/ic/awi.c bp = malloc(sizeof(struct awi_bss), M_DEVBUF, M_NOWAIT);
bp 1961 dev/ic/awi.c if (bp == NULL)
bp 1963 dev/ic/awi.c TAILQ_INSERT_TAIL(&sc->sc_scan, bp, list);
bp 1964 dev/ic/awi.c memcpy(bp->esrc, wh->i_addr2, ETHER_ADDR_LEN);
bp 1965 dev/ic/awi.c memcpy(bp->bssid, wh->i_addr3, ETHER_ADDR_LEN);
bp 1966 dev/ic/awi.c memset(bp->essid, 0, sizeof(bp->essid));
bp 1967 dev/ic/awi.c memcpy(bp->essid, ssid, 2 + ssid[1]);
bp 1969 dev/ic/awi.c bp->rssi = rssi;
bp 1970 dev/ic/awi.c bp->rxtime = rxts;
bp 1971 dev/ic/awi.c memcpy(bp->timestamp, tstamp, sizeof(bp->timestamp));
bp 1972 dev/ic/awi.c bp->interval = LE_READ_2(bintval);
bp 1973 dev/ic/awi.c bp->capinfo = LE_READ_2(capinfo);
bp 1975 dev/ic/awi.c bp->chanset = parms[4];
bp 1976 dev/ic/awi.c bp->pattern = parms[5];
bp 1977 dev/ic/awi.c bp->index = parms[6];
bp 1978 dev/ic/awi.c bp->dwell_time = LE_READ_2(parms + 2);
bp 1980 dev/ic/awi.c bp->chanset = parms[2];
bp 1981 dev/ic/awi.c bp->pattern = 0;
bp 1982 dev/ic/awi.c bp->index = 0;
bp 1983 dev/ic/awi.c bp->dwell_time = 0;
bp 1994 dev/ic/awi.c struct awi_bss *bp;
bp 1998 dev/ic/awi.c bp = &sc->sc_bss;
bp 2001 dev/ic/awi.c sc->sc_dev.dv_xname, bp->chanset,
bp 2002 dev/ic/awi.c bp->pattern, bp->index, bp->dwell_time, bp->interval,
bp 2003 dev/ic/awi.c ether_sprintf(bp->bssid));
bp 2004 dev/ic/awi.c awi_print_essid(bp->essid);
bp 2007 dev/ic/awi.c memcpy(&sc->sc_mib_mgt.aCurrent_BSS_ID, bp->bssid, ETHER_ADDR_LEN);
bp 2008 dev/ic/awi.c memcpy(&sc->sc_mib_mgt.aCurrent_ESS_ID, bp->essid,
bp 2010 dev/ic/awi.c LE_WRITE_2(&sc->sc_mib_mgt.aBeacon_Period, bp->interval);
bp 2019 dev/ic/awi.c struct awi_bss *bp;
bp 2022 dev/ic/awi.c bp = &sc->sc_bss;
bp 2029 dev/ic/awi.c awi_write_1(sc, AWI_CMD_PARAMS+AWI_CA_SYNC_SET, bp->chanset);
bp 2030 dev/ic/awi.c awi_write_1(sc, AWI_CMD_PARAMS+AWI_CA_SYNC_PATTERN, bp->pattern);
bp 2031 dev/ic/awi.c awi_write_1(sc, AWI_CMD_PARAMS+AWI_CA_SYNC_IDX, bp->index);
bp 2034 dev/ic/awi.c awi_write_2(sc, AWI_CMD_PARAMS+AWI_CA_SYNC_DWELL, bp->dwell_time);
bp 2037 dev/ic/awi.c bp->timestamp, 8);
bp 2038 dev/ic/awi.c awi_write_4(sc, AWI_CMD_PARAMS+AWI_CA_SYNC_REFTIME, bp->rxtime);
bp 2164 dev/ic/awi.c struct awi_bss *bp;
bp 2196 dev/ic/awi.c for (bp = TAILQ_FIRST(&sc->sc_scan); bp != NULL;
bp 2197 dev/ic/awi.c bp = TAILQ_NEXT(bp, list)) {
bp 2198 dev/ic/awi.c if (memcmp(bp->esrc, sc->sc_bss.esrc, ETHER_ADDR_LEN)
bp 2200 dev/ic/awi.c bp->fails++;
bp 2286 dev/ic/awi.c struct awi_bss *bp;
bp 2308 dev/ic/awi.c for (bp = TAILQ_FIRST(&sc->sc_scan); bp != NULL;
bp 2309 dev/ic/awi.c bp = TAILQ_NEXT(bp, list)) {
bp 2310 dev/ic/awi.c if (memcmp(bp->esrc, sc->sc_bss.esrc, ETHER_ADDR_LEN)
bp 2312 dev/ic/awi.c bp->fails++;
bp 1330 dev/ic/bha.c bhaminphys(bp)
bp 1331 dev/ic/bha.c struct buf *bp;
bp 1334 dev/ic/bha.c if (bp->b_bcount > BHA_MAXXFER)
bp 1335 dev/ic/bha.c bp->b_bcount = BHA_MAXXFER;
bp 1336 dev/ic/bha.c minphys(bp);
bp 99 dev/ic/cac.c void cacminphys(struct buf *bp);
bp 532 dev/ic/cac.c cacminphys(bp)
bp 533 dev/ic/cac.c struct buf *bp;
bp 535 dev/ic/cac.c if (bp->b_bcount > CAC_MAX_XFER)
bp 536 dev/ic/cac.c bp->b_bcount = CAC_MAX_XFER;
bp 537 dev/ic/cac.c minphys(bp);
bp 75 dev/ic/ciss.c void cissminphys(struct buf *bp);
bp 463 dev/ic/ciss.c cissminphys(struct buf *bp)
bp 467 dev/ic/ciss.c if (bp->b_bcount > CISS_MAXFER)
bp 468 dev/ic/ciss.c bp->b_bcount = CISS_MAXFER;
bp 470 dev/ic/ciss.c minphys(bp);
bp 658 dev/ic/dpt.c dpt_minphys(bp)
bp 659 dev/ic/dpt.c struct buf *bp;
bp 662 dev/ic/dpt.c if (bp->b_bcount > DPT_MAX_XFER)
bp 663 dev/ic/dpt.c bp->b_bcount = DPT_MAX_XFER;
bp 664 dev/ic/dpt.c minphys(bp);
bp 1121 dev/ic/dpt.c if (xs->bp != NULL && (xs->bp->b_flags & (B_ASYNC | B_READ)) == 0)
bp 1222 dev/ic/gdt_common.c gdtminphys(bp)
bp 1223 dev/ic/gdt_common.c struct buf *bp;
bp 1225 dev/ic/gdt_common.c GDT_DPRINTF(GDT_D_MISC, ("gdtminphys(0x%x) ", bp));
bp 1229 dev/ic/gdt_common.c bp->b_bcount > ((GDT_MAXOFFSETS - 1) * PAGE_SIZE))
bp 1230 dev/ic/gdt_common.c bp->b_bcount = ((GDT_MAXOFFSETS - 1) * PAGE_SIZE);
bp 1232 dev/ic/gdt_common.c minphys(bp);
bp 484 dev/ic/iha.c iha_minphys(bp)
bp 485 dev/ic/iha.c struct buf *bp;
bp 487 dev/ic/iha.c if (bp->b_bcount > ((IHA_MAX_SG_ENTRIES - 1) * PAGE_SIZE))
bp 488 dev/ic/iha.c bp->b_bcount = ((IHA_MAX_SG_ENTRIES - 1) * PAGE_SIZE);
bp 490 dev/ic/iha.c minphys(bp);
bp 187 dev/ic/isp_openbsd.c ispminphys(struct buf *bp)
bp 192 dev/ic/isp_openbsd.c if (bp->b_bcount >= (1 << 24)) {
bp 193 dev/ic/isp_openbsd.c bp->b_bcount = (1 << 24);
bp 195 dev/ic/isp_openbsd.c minphys(bp);
bp 63 dev/ic/mfi.c void mfiminphys(struct buf *bp);
bp 568 dev/ic/mfi.c mfiminphys(struct buf *bp)
bp 570 dev/ic/mfi.c DNPRINTF(MFI_D_MISC, "mfiminphys: %d\n", bp->b_bcount);
bp 573 dev/ic/mfi.c if (bp->b_bcount > MFI_MAXFER)
bp 574 dev/ic/mfi.c bp->b_bcount = MFI_MAXFER;
bp 575 dev/ic/mfi.c minphys(bp);
bp 58 dev/ic/mpi.c void mpi_minphys(struct buf *bp);
bp 1319 dev/ic/mpi.c mpi_minphys(struct buf *bp)
bp 1322 dev/ic/mpi.c if (bp->b_bcount > MAXPHYS)
bp 1323 dev/ic/mpi.c bp->b_bcount = MAXPHYS;
bp 1324 dev/ic/mpi.c minphys(bp);
bp 708 dev/ic/oosiop.c oosiop_minphys(struct buf *bp)
bp 711 dev/ic/oosiop.c if (bp->b_bcount > OOSIOP_MAX_XFER)
bp 712 dev/ic/oosiop.c bp->b_bcount = OOSIOP_MAX_XFER;
bp 713 dev/ic/oosiop.c minphys(bp);
bp 363 dev/ic/osiop.c osiop_minphys(bp)
bp 364 dev/ic/osiop.c struct buf *bp;
bp 367 dev/ic/osiop.c if (bp->b_bcount > OSIOP_MAX_XFER)
bp 368 dev/ic/osiop.c bp->b_bcount = OSIOP_MAX_XFER;
bp 369 dev/ic/osiop.c minphys(bp);
bp 1653 dev/ic/siop.c if (siop_cmd->cmd_c.xs->bp != NULL &&
bp 1654 dev/ic/siop.c (siop_cmd->cmd_c.xs->bp->b_flags & B_ASYNC))
bp 710 dev/ic/siop_common.c siop_minphys(bp)
bp 711 dev/ic/siop_common.c struct buf *bp;
bp 713 dev/ic/siop_common.c if (bp->b_bcount > SIOP_MAXFER)
bp 714 dev/ic/siop_common.c bp->b_bcount = SIOP_MAXFER;
bp 716 dev/ic/siop_common.c minphys(bp);
bp 2371 dev/ic/trm.c trm_minphys(struct buf *bp)
bp 2373 dev/ic/trm.c if (bp->b_bcount > (TRM_MAX_SG_LISTENTRY-1) * (long) NBPG) {
bp 2374 dev/ic/trm.c bp->b_bcount = (TRM_MAX_SG_LISTENTRY-1) * (long) NBPG;
bp 2376 dev/ic/trm.c minphys(bp);
bp 751 dev/ic/twe.c tweminphys(bp)
bp 752 dev/ic/twe.c struct buf *bp;
bp 754 dev/ic/twe.c if (bp->b_bcount > TWE_MAXFER)
bp 755 dev/ic/twe.c bp->b_bcount = TWE_MAXFER;
bp 756 dev/ic/twe.c minphys(bp);
bp 87 dev/ic/twevar.h void tweminphys(struct buf *bp);
bp 342 dev/ic/uha.c uhaminphys(bp)
bp 343 dev/ic/uha.c struct buf *bp;
bp 346 dev/ic/uha.c if (bp->b_bcount > ((UHA_NSEG - 1) << PGSHIFT))
bp 347 dev/ic/uha.c bp->b_bcount = ((UHA_NSEG - 1) << PGSHIFT);
bp 348 dev/ic/uha.c minphys(bp);
bp 2151 dev/ic/wdc.c wdc_ioctl_find(bp)
bp 2152 dev/ic/wdc.c struct buf *bp;
bp 2159 dev/ic/wdc.c if (bp == &wi->wi_bp)
bp 2188 dev/ic/wdc.c wdc_ioctl_strategy(bp)
bp 2189 dev/ic/wdc.c struct buf *bp;
bp 2196 dev/ic/wdc.c wi = wdc_ioctl_find(bp);
bp 2209 dev/ic/wdc.c if ((u_long)bp->b_bcount != wi->wi_atareq.datalen) {
bp 2278 dev/ic/wdc.c bp->b_error = 0;
bp 2280 dev/ic/wdc.c biodone(bp);
bp 2284 dev/ic/wdc.c bp->b_flags |= B_ERROR;
bp 2285 dev/ic/wdc.c bp->b_error = error;
bp 2287 dev/ic/wdc.c biodone(bp);
bp 86 dev/isa/aha.c ((xs)->datalen > 0 && (xs)->bp == NULL && \
bp 1242 dev/isa/aha.c ahaminphys(bp)
bp 1243 dev/isa/aha.c struct buf *bp;
bp 1246 dev/isa/aha.c if (bp->b_bcount > ((AHA_NSEG - 1) << PGSHIFT))
bp 1247 dev/isa/aha.c bp->b_bcount = ((AHA_NSEG - 1) << PGSHIFT);
bp 1248 dev/isa/aha.c minphys(bp);
bp 152 dev/isa/fd.c void fdfinish(struct fd_softc *fd, struct buf *bp);
bp 343 dev/isa/fd.c fdstrategy(bp)
bp 344 dev/isa/fd.c register struct buf *bp; /* IO operation to perform */
bp 346 dev/isa/fd.c struct fd_softc *fd = fd_cd.cd_devs[FDUNIT(bp->b_dev)];
bp 353 dev/isa/fd.c if (bp->b_blkno < 0 ||
bp 354 dev/isa/fd.c (((bp->b_blkno % bf) != 0 ||
bp 355 dev/isa/fd.c (bp->b_bcount % fd_bsize) != 0) &&
bp 356 dev/isa/fd.c (bp->b_flags & B_FORMAT) == 0)) {
bp 357 dev/isa/fd.c bp->b_error = EINVAL;
bp 362 dev/isa/fd.c if (bp->b_bcount == 0)
bp 365 dev/isa/fd.c sz = howmany(bp->b_bcount, DEV_BSIZE);
bp 367 dev/isa/fd.c if (bp->b_blkno + sz > fd->sc_type->size * bf) {
bp 368 dev/isa/fd.c sz = fd->sc_type->size * bf - bp->b_blkno;
bp 374 dev/isa/fd.c bp->b_error = EINVAL;
bp 378 dev/isa/fd.c bp->b_bcount = sz << DEV_BSHIFT;
bp 381 dev/isa/fd.c bp->b_cylinder = bp->b_blkno / (fd_bsize / DEV_BSIZE) / fd->sc_type->seccyl;
bp 385 dev/isa/fd.c bp->b_blkno, bp->b_bcount, fd->sc_blkno, bp->b_cylinder, sz);
bp 390 dev/isa/fd.c disksort(&fd->sc_q, bp);
bp 407 dev/isa/fd.c bp->b_flags |= B_ERROR;
bp 410 dev/isa/fd.c bp->b_resid = bp->b_bcount;
bp 412 dev/isa/fd.c biodone(bp);
bp 433 dev/isa/fd.c fdfinish(fd, bp)
bp 435 dev/isa/fd.c struct buf *bp;
bp 450 dev/isa/fd.c if (bp->b_actf) {
bp 456 dev/isa/fd.c bp->b_resid = fd->sc_bcount;
bp 458 dev/isa/fd.c fd->sc_q.b_actf = bp->b_actf;
bp 460 dev/isa/fd.c biodone(bp);
bp 614 dev/isa/fd.c struct buf *bp;
bp 632 dev/isa/fd.c bp = fd->sc_q.b_actf;
bp 633 dev/isa/fd.c if (bp == NULL) {
bp 640 dev/isa/fd.c if (bp->b_flags & B_FORMAT)
bp 641 dev/isa/fd.c finfo = (struct fd_formb *)bp->b_data;
bp 647 dev/isa/fd.c fd->sc_bcount = bp->b_bcount;
bp 648 dev/isa/fd.c fd->sc_blkno = bp->b_blkno / (fd_bsize / DEV_BSIZE);
bp 675 dev/isa/fd.c if (fd->sc_cylin == bp->b_cylinder)
bp 684 dev/isa/fd.c out_fdc(iot, ioh, bp->b_cylinder * fd->sc_type->step);
bp 706 dev/isa/fd.c fd->sc_nbytes = finfo ? bp->b_bcount : nblks * fd_bsize;
bp 719 dev/isa/fd.c read = bp->b_flags & B_READ ? DMAMODE_READ : DMAMODE_WRITE;
bp 720 dev/isa/fd.c isadma_start(bp->b_data + fd->sc_skip, fd->sc_nbytes,
bp 775 dev/isa/fd.c cyl != bp->b_cylinder * fd->sc_type->step) {
bp 782 dev/isa/fd.c fd->sc_cylin = bp->b_cylinder;
bp 796 dev/isa/fd.c disk_unbusy(&fd->sc_dk, (bp->b_bcount - bp->b_resid),
bp 797 dev/isa/fd.c (bp->b_flags & B_READ));
bp 802 dev/isa/fd.c fdcstatus(&fd->sc_dev, 7, bp->b_flags & B_READ ?
bp 810 dev/isa/fd.c read = bp->b_flags & B_READ ? DMAMODE_READ : DMAMODE_WRITE;
bp 813 dev/isa/fd.c diskerr(bp, "fd", "soft error", LOG_PRINTF,
bp 822 dev/isa/fd.c bp->b_cylinder = fd->sc_blkno / fd->sc_type->seccyl;
bp 825 dev/isa/fd.c fdfinish(fd, bp);
bp 916 dev/isa/fd.c struct buf *bp = fd->sc_q.b_actf;
bp 938 dev/isa/fd.c diskerr(bp, "fd", "hard error", LOG_PRINTF,
bp 946 dev/isa/fd.c bp->b_flags |= B_ERROR;
bp 947 dev/isa/fd.c bp->b_error = EIO;
bp 948 dev/isa/fd.c fdfinish(fd, bp);
bp 1057 dev/isa/fd.c struct buf *bp;
bp 1061 dev/isa/fd.c bp = (struct buf *)malloc(sizeof(struct buf), M_TEMP, M_NOWAIT);
bp 1062 dev/isa/fd.c if (bp == NULL)
bp 1065 dev/isa/fd.c bzero((void *)bp, sizeof(struct buf));
bp 1066 dev/isa/fd.c bp->b_flags = B_BUSY | B_PHYS | B_FORMAT;
bp 1067 dev/isa/fd.c bp->b_proc = p;
bp 1068 dev/isa/fd.c bp->b_dev = dev;
bp 1074 dev/isa/fd.c bp->b_blkno = (finfo->cyl * (type->sectrac * type->heads)
bp 1077 dev/isa/fd.c bp->b_bcount = sizeof(struct fd_idfield_data) * finfo->fd_formb_nsecs;
bp 1078 dev/isa/fd.c bp->b_data = (caddr_t)finfo;
bp 1081 dev/isa/fd.c printf("fdformat: blkno %x count %x\n", bp->b_blkno, bp->b_bcount);
bp 1085 dev/isa/fd.c fdstrategy(bp);
bp 1088 dev/isa/fd.c rv = biowait(bp);
bp 1089 dev/isa/fd.c free(bp, M_TEMP);
bp 96 dev/isa/mcd.c struct buf *bp;
bp 478 dev/isa/mcd.c mcdstrategy(bp)
bp 479 dev/isa/mcd.c struct buf *bp;
bp 481 dev/isa/mcd.c struct mcd_softc *sc = mcd_cd.cd_devs[DISKUNIT(bp->b_dev)];
bp 485 dev/isa/mcd.c MCD_TRACE("strategy: buf=0x%lx blkno=%ld bcount=%ld\n", bp,
bp 486 dev/isa/mcd.c bp->b_blkno, bp->b_bcount, 0);
bp 487 dev/isa/mcd.c if (bp->b_blkno < 0 ||
bp 488 dev/isa/mcd.c (bp->b_bcount % sc->blksize) != 0) {
bp 490 dev/isa/mcd.c sc->sc_dev.dv_xname, bp->b_blkno, bp->b_bcount);
bp 491 dev/isa/mcd.c bp->b_error = EINVAL;
bp 498 dev/isa/mcd.c bp->b_error = EIO;
bp 503 dev/isa/mcd.c if (bp->b_bcount == 0)
bp 510 dev/isa/mcd.c if (DISKPART(bp->b_dev) != RAW_PART &&
bp 511 dev/isa/mcd.c bounds_check_with_label(bp, sc->sc_dk.dk_label,
bp 517 dev/isa/mcd.c disksort(&sc->buf_queue, bp);
bp 524 dev/isa/mcd.c bp->b_flags |= B_ERROR;
bp 526 dev/isa/mcd.c bp->b_resid = bp->b_bcount;
bp 528 dev/isa/mcd.c biodone(bp);
bp 536 dev/isa/mcd.c struct buf *bp, *dp = &sc->buf_queue;
bp 542 dev/isa/mcd.c bp = dp->b_actf;
bp 543 dev/isa/mcd.c if (bp == NULL) {
bp 551 dev/isa/mcd.c MCD_TRACE("start: found block bp=0x%x\n", bp, 0, 0, 0);
bp 552 dev/isa/mcd.c dp->b_actf = bp->b_actf;
bp 558 dev/isa/mcd.c bp->b_error = EIO;
bp 559 dev/isa/mcd.c bp->b_flags |= B_ERROR;
bp 561 dev/isa/mcd.c biodone(bp);
bp 574 dev/isa/mcd.c sc->mbx.bp = bp;
bp 575 dev/isa/mcd.c sc->mbx.blkno = bp->b_blkno / (sc->blksize / DEV_BSIZE);
bp 576 dev/isa/mcd.c if (DISKPART(bp->b_dev) != RAW_PART) {
bp 578 dev/isa/mcd.c p = &sc->sc_dk.dk_label->d_partitions[DISKPART(bp->b_dev)];
bp 581 dev/isa/mcd.c sc->mbx.nblk = bp->b_bcount / sc->blksize;
bp 1141 dev/isa/mcd.c struct buf *bp = mbx->bp;
bp 1186 dev/isa/mcd.c bp, 0, 0);
bp 1234 dev/isa/mcd.c bp->b_data + mbx->skip, mbx->sz);
bp 1244 dev/isa/mcd.c bp->b_resid = 0;
bp 1245 dev/isa/mcd.c disk_unbusy(&sc->sc_dk, bp->b_bcount, (bp->b_flags & B_READ));
bp 1246 dev/isa/mcd.c biodone(bp);
bp 1275 dev/isa/mcd.c bp->b_flags |= B_ERROR;
bp 1276 dev/isa/mcd.c bp->b_resid = bp->b_bcount - mbx->skip;
bp 1277 dev/isa/mcd.c disk_unbusy(&sc->sc_dk, (bp->b_bcount - bp->b_resid),
bp 1278 dev/isa/mcd.c (bp->b_flags & B_READ));
bp 1279 dev/isa/mcd.c biodone(bp);
bp 1236 dev/isa/pss.c pss_get_bass(sc, bp)
bp 1238 dev/isa/pss.c u_char *bp;
bp 1240 dev/isa/pss.c *bp = sc->monitor_bass;
bp 1035 dev/isa/wds.c wdsminphys(bp)
bp 1036 dev/isa/wds.c struct buf *bp;
bp 1038 dev/isa/wds.c if (bp->b_bcount > ((WDS_NSEG - 1) << PGSHIFT))
bp 1039 dev/isa/wds.c bp->b_bcount = ((WDS_NSEG - 1) << PGSHIFT);
bp 1040 dev/isa/wds.c minphys(bp);
bp 860 dev/pci/arc.c arc_minphys(struct buf *bp)
bp 862 dev/pci/arc.c if (bp->b_bcount > MAXPHYS)
bp 863 dev/pci/arc.c bp->b_bcount = MAXPHYS;
bp 864 dev/pci/arc.c minphys(bp);
bp 2625 dev/pci/if_bnx.c cpu_reg.bp = BNX_RXP_CPU_HW_BREAKPOINT;
bp 2672 dev/pci/if_bnx.c cpu_reg.bp = BNX_TXP_CPU_HW_BREAKPOINT;
bp 2719 dev/pci/if_bnx.c cpu_reg.bp = BNX_TPAT_CPU_HW_BREAKPOINT;
bp 2766 dev/pci/if_bnx.c cpu_reg.bp = BNX_COM_CPU_HW_BREAKPOINT;
bp 230 dev/pci/if_bnxreg.h #define BNX_CHIP_BOND(bp) (((sc)->bnx_chipid) & 0x0000000f)
bp 4502 dev/pci/if_bnxreg.h u_int32_t bp;
bp 219 dev/raidframe/rf_aselect.c void *bp = desc->bp;
bp 510 dev/raidframe/rf_aselect.c bp, flags,
bp 533 dev/raidframe/rf_aselect.c tempdag_h, bp, flags,
bp 556 dev/raidframe/rf_aselect.c bp, flags, tempdag_h->allocList);
bp 273 dev/raidframe/rf_dag.h void *bp; /*
bp 346 dev/raidframe/rf_dag.h void *bp, \
bp 81 dev/raidframe/rf_dagdegrd.c void *bp,
bp 85 dev/raidframe/rf_dagdegrd.c rf_CreateDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
bp 118 dev/raidframe/rf_dagdegrd.c void *bp,
bp 262 dev/raidframe/rf_dagdegrd.c void *bp,
bp 479 dev/raidframe/rf_dagdegrd.c RF_BZERO(bp, failedPDA->bufPtr, rf_RaidAddressToByte(raidPtr,
bp 564 dev/raidframe/rf_dagdegrd.c void *bp,
bp 1142 dev/raidframe/rf_dagdegrd.c void *bp,
bp 79 dev/raidframe/rf_dagdegwr.c rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp,
bp 85 dev/raidframe/rf_dagdegwr.c RF_DagHeader_t *dag_h, void *bp, RF_RaidAccessFlags_t flags,
bp 107 dev/raidframe/rf_dagdegwr.c rf_CreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp,
bp 155 dev/raidframe/rf_dagdegwr.c RF_AccessStripeMap_t *asmap, RF_DagHeader_t *dag_h, void *bp,
bp 717 dev/raidframe/rf_dagdegwr.c RF_DagHeader_t *dag_h, void *bp, RF_RaidAccessFlags_t flags,
bp 85 dev/raidframe/rf_dagffrd.c void *bp,
bp 90 dev/raidframe/rf_dagffrd.c rf_CreateNonredundantDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
bp 140 dev/raidframe/rf_dagffrd.c void *bp,
bp 327 dev/raidframe/rf_dagffrd.c void *bp,
bp 438 dev/raidframe/rf_dagffrd.c void *bp,
bp 443 dev/raidframe/rf_dagffrd.c rf_CreateMirrorReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
bp 452 dev/raidframe/rf_dagffrd.c void *bp,
bp 457 dev/raidframe/rf_dagffrd.c rf_CreateMirrorReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
bp 80 dev/raidframe/rf_dagffwr.c RF_DagHeader_t *dag_h, void *bp, RF_RaidAccessFlags_t flags,
bp 83 dev/raidframe/rf_dagffwr.c rf_CreateNonredundantDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
bp 89 dev/raidframe/rf_dagffwr.c RF_DagHeader_t *dag_h, void *bp, RF_RaidAccessFlags_t flags,
bp 92 dev/raidframe/rf_dagffwr.c rf_CreateNonredundantDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
bp 98 dev/raidframe/rf_dagffwr.c RF_DagHeader_t *dag_h, void *bp, RF_RaidAccessFlags_t flags,
bp 102 dev/raidframe/rf_dagffwr.c rf_CommonCreateSmallWriteDAG(raidPtr, asmap, dag_h, bp, flags,
bp 108 dev/raidframe/rf_dagffwr.c RF_DagHeader_t *dag_h, void *bp, RF_RaidAccessFlags_t flags,
bp 112 dev/raidframe/rf_dagffwr.c rf_CommonCreateLargeWriteDAG(raidPtr, asmap, dag_h, bp, flags,
bp 157 dev/raidframe/rf_dagffwr.c RF_DagHeader_t *dag_h, void *bp, RF_RaidAccessFlags_t flags,
bp 468 dev/raidframe/rf_dagffwr.c RF_DagHeader_t *dag_h, void *bp, RF_RaidAccessFlags_t flags,
bp 1133 dev/raidframe/rf_dagffwr.c RF_DagHeader_t *dag_h, void *bp, RF_RaidAccessFlags_t flags,
bp 1293 dev/raidframe/rf_dagffwr.c RF_DagHeader_t *dag_h, void *bp, RF_RaidAccessFlags_t flags,
bp 1599 dev/raidframe/rf_dagffwr.c RF_DagHeader_t *dag_h, void *bp, RF_RaidAccessFlags_t flags,
bp 2230 dev/raidframe/rf_dagffwr.c RF_DagHeader_t *dag_h, void *bp, RF_RaidAccessFlags_t flags,
bp 292 dev/raidframe/rf_dagfuncs.c if (node->dagHdr->bp)
bp 293 dev/raidframe/rf_dagfuncs.c b_proc = (void *) ((struct buf *) node->dagHdr->bp)->b_proc;
bp 334 dev/raidframe/rf_dagfuncs.c if (node->dagHdr->bp)
bp 335 dev/raidframe/rf_dagfuncs.c b_proc = (void *) ((struct buf *) node->dagHdr->bp)->b_proc;
bp 495 dev/raidframe/rf_dagfuncs.c node->dagHdr->bp);
bp 525 dev/raidframe/rf_dagfuncs.c (struct buf *) node->dagHdr->bp);
bp 571 dev/raidframe/rf_dagfuncs.c pda->numSector), node->dagHdr->bp);
bp 597 dev/raidframe/rf_dagfuncs.c char *targbuf, void *bp)
bp 608 dev/raidframe/rf_dagfuncs.c retcode = rf_bxor(srcbuf, targptr, length, bp);
bp 619 dev/raidframe/rf_dagfuncs.c rf_bxor(char *src, char *dest, int len, void *bp)
bp 626 dev/raidframe/rf_dagfuncs.c (unsigned long *) dest, len >> RF_LONGSHIFT, bp);
bp 645 dev/raidframe/rf_dagfuncs.c rf_longword_bxor(unsigned long *src, unsigned long *dest, int len, void *bp)
bp 652 dev/raidframe/rf_dagfuncs.c REMAP_VA(bp, src, pg_src);
bp 653 dev/raidframe/rf_dagfuncs.c REMAP_VA(bp, dest, pg_dest);
bp 692 dev/raidframe/rf_dagfuncs.c REMAP_VA(bp, src, pg_src);
bp 694 dev/raidframe/rf_dagfuncs.c REMAP_VA(bp, dest, pg_dest);
bp 705 dev/raidframe/rf_dagfuncs.c REMAP_VA(bp, src, pg_src);
bp 707 dev/raidframe/rf_dagfuncs.c REMAP_VA(bp, dest, pg_dest);
bp 721 dev/raidframe/rf_dagfuncs.c unsigned long *c, int len, void *bp)
bp 731 dev/raidframe/rf_dagfuncs.c REMAP_VA(bp, a, pg_a);
bp 732 dev/raidframe/rf_dagfuncs.c REMAP_VA(bp, b, pg_b);
bp 733 dev/raidframe/rf_dagfuncs.c REMAP_VA(bp, c, pg_c);
bp 738 dev/raidframe/rf_dagfuncs.c REMAP_VA(bp, dst, pg_dst);
bp 749 dev/raidframe/rf_dagfuncs.c REMAP_VA(bp, a, pg_a);
bp 754 dev/raidframe/rf_dagfuncs.c REMAP_VA(bp, a, pg_b);
bp 759 dev/raidframe/rf_dagfuncs.c REMAP_VA(bp, a, pg_c);
bp 825 dev/raidframe/rf_dagfuncs.c REMAP_VA(bp, a, pg_a);
bp 832 dev/raidframe/rf_dagfuncs.c REMAP_VA(bp, b, pg_b);
bp 837 dev/raidframe/rf_dagfuncs.c REMAP_VA(bp, c, pg_c);
bp 843 dev/raidframe/rf_dagfuncs.c REMAP_VA(bp, dst, pg_dst);
bp 856 dev/raidframe/rf_dagfuncs.c REMAP_VA(bp, a, pg_a);
bp 863 dev/raidframe/rf_dagfuncs.c REMAP_VA(bp, b, pg_b);
bp 868 dev/raidframe/rf_dagfuncs.c REMAP_VA(bp, c, pg_c);
bp 874 dev/raidframe/rf_dagfuncs.c REMAP_VA(bp, dst, pg_dst);
bp 885 dev/raidframe/rf_dagfuncs.c unsigned char *c, unsigned long len, void *bp)
bp 892 dev/raidframe/rf_dagfuncs.c bp));
bp 110 dev/raidframe/rf_desc.h void *bp; /*
bp 166 dev/raidframe/rf_diskqueue.c dqd->bp = (struct buf *) malloc(sizeof(struct buf), M_RAIDFRAME,
bp 168 dev/raidframe/rf_diskqueue.c if (dqd->bp == NULL) {
bp 172 dev/raidframe/rf_diskqueue.c memset(dqd->bp, 0, sizeof(struct buf));
bp 180 dev/raidframe/rf_diskqueue.c free(dqd->bp, M_RAIDFRAME);
bp 112 dev/raidframe/rf_diskqueue.h struct buf *bp; /* A bp to use to get this I/O done. */
bp 157 dev/raidframe/rf_driver.c #define IO_BUF_ERR(bp, err) \
bp 159 dev/raidframe/rf_driver.c bp->b_flags |= B_ERROR; \
bp 160 dev/raidframe/rf_driver.c bp->b_resid = bp->b_bcount; \
bp 161 dev/raidframe/rf_driver.c bp->b_error = err; \
bp 162 dev/raidframe/rf_driver.c biodone(bp); \
bp 607 dev/raidframe/rf_driver.c void *bp,
bp 638 dev/raidframe/rf_driver.c desc->bp = bp;
bp 707 dev/raidframe/rf_driver.c struct buf *bp = (struct buf *) bp_in;
bp 714 dev/raidframe/rf_driver.c IO_BUF_ERR(bp, EINVAL);
bp 736 dev/raidframe/rf_driver.c IO_BUF_ERR(bp, ENOSPC);
bp 740 dev/raidframe/rf_driver.c numBlocks, lbufPtr, bp, paramDAG, paramASM,
bp 145 dev/raidframe/rf_evenodd_dagfuncs.c node->params[k + 1].p, length, node->dagHdr->bp);
bp 172 dev/raidframe/rf_evenodd_dagfuncs.c node->params[k + 1].p, length, node->dagHdr->bp);
bp 205 dev/raidframe/rf_evenodd_dagfuncs.c length, node->dagHdr->bp);
bp 217 dev/raidframe/rf_evenodd_dagfuncs.c node->dagHdr->bp);
bp 1069 dev/raidframe/rf_evenodd_dagfuncs.c olddata[0], numbytes, node->dagHdr->bp);
bp 1084 dev/raidframe/rf_evenodd_dagfuncs.c rf_bxor(olddata[0], ppda->bufPtr, numbytes, node->dagHdr->bp);
bp 61 dev/raidframe/rf_evenodd_dags.c rf_CreateDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
bp 71 dev/raidframe/rf_evenodd_dags.c rf_CreateDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
bp 87 dev/raidframe/rf_evenodd_dags.c rf_CreateDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
bp 96 dev/raidframe/rf_evenodd_dags.c rf_EO_DoubleDegRead(raidPtr, asmap, dag_h, bp, flags, allocList);
bp 104 dev/raidframe/rf_evenodd_dags.c rf_EOCreateDoubleDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags,
bp 114 dev/raidframe/rf_evenodd_dags.c rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp,
bp 124 dev/raidframe/rf_evenodd_dags.c rf_CommonCreateSmallWriteDAG(raidPtr, asmap, dag_h, bp, flags,
bp 133 dev/raidframe/rf_evenodd_dags.c rf_CommonCreateLargeWriteDAG(raidPtr, asmap, dag_h, bp, flags,
bp 148 dev/raidframe/rf_evenodd_dags.c rf_CommonCreateSmallWriteDAG(raidPtr, asmap, dag_h, bp, flags,
bp 163 dev/raidframe/rf_evenodd_dags.c rf_CommonCreateLargeWriteDAG(raidPtr, asmap, dag_h, bp, flags,
bp 169 dev/raidframe/rf_evenodd_dags.c rf_CreateNonRedundantWriteDAG(raidPtr, asmap, dag_h, bp, flags,
bp 186 dev/raidframe/rf_evenodd_dags.c rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp,
bp 198 dev/raidframe/rf_evenodd_dags.c rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp,
bp 204 dev/raidframe/rf_evenodd_dags.c rf_DoubleDegRead(raidPtr, asmap, dag_h, bp, flags, allocList,
bp 210 dev/raidframe/rf_evenodd_dags.c rf_CommonCreateSmallWriteDAG(raidPtr, asmap, dag_h, bp, flags,
bp 216 dev/raidframe/rf_evenodd_dags.c rf_CommonCreateLargeWriteDAG(raidPtr, asmap, dag_h, bp, flags,
bp 222 dev/raidframe/rf_evenodd_dags.c rf_DoubleDegSmallWrite(raidPtr, asmap, dag_h, bp, flags, allocList,
bp 745 dev/raidframe/rf_openbsdkintf.c raidstrategy(struct buf *bp)
bp 749 dev/raidframe/rf_openbsdkintf.c unsigned int raidID = DISKUNIT(bp->b_dev);
bp 758 dev/raidframe/rf_openbsdkintf.c bp->b_error = ENXIO;
bp 759 dev/raidframe/rf_openbsdkintf.c bp->b_flags |= B_ERROR;
bp 760 dev/raidframe/rf_openbsdkintf.c bp->b_resid = bp->b_bcount;
bp 761 dev/raidframe/rf_openbsdkintf.c biodone(bp);
bp 765 dev/raidframe/rf_openbsdkintf.c bp->b_error = ENODEV;
bp 766 dev/raidframe/rf_openbsdkintf.c bp->b_flags |= B_ERROR;
bp 767 dev/raidframe/rf_openbsdkintf.c bp->b_resid = bp->b_bcount;
bp 768 dev/raidframe/rf_openbsdkintf.c biodone(bp);
bp 773 dev/raidframe/rf_openbsdkintf.c bp->b_error = ENODEV;
bp 774 dev/raidframe/rf_openbsdkintf.c bp->b_flags |= B_ERROR;
bp 775 dev/raidframe/rf_openbsdkintf.c bp->b_resid = bp->b_bcount;
bp 776 dev/raidframe/rf_openbsdkintf.c biodone(bp);
bp 779 dev/raidframe/rf_openbsdkintf.c if (bp->b_bcount == 0) {
bp 781 dev/raidframe/rf_openbsdkintf.c biodone(bp);
bp 791 dev/raidframe/rf_openbsdkintf.c if (DISKPART(bp->b_dev) != RAW_PART)
bp 792 dev/raidframe/rf_openbsdkintf.c if (bounds_check_with_label(bp, lp, wlabel) <= 0) {
bp 794 dev/raidframe/rf_openbsdkintf.c (int)bp->b_blkno, (int)wlabel));
bp 795 dev/raidframe/rf_openbsdkintf.c biodone(bp);
bp 799 dev/raidframe/rf_openbsdkintf.c bp->b_resid = 0;
bp 801 dev/raidframe/rf_openbsdkintf.c bp->b_actf = rs->sc_q.b_actf;
bp 802 dev/raidframe/rf_openbsdkintf.c rs->sc_q.b_actf = bp;
bp 1721 dev/raidframe/rf_openbsdkintf.c struct buf *bp;
bp 1740 dev/raidframe/rf_openbsdkintf.c bp = rs->sc_q.b_actf;
bp 1741 dev/raidframe/rf_openbsdkintf.c if (bp == NULL) {
bp 1745 dev/raidframe/rf_openbsdkintf.c rs->sc_q.b_actf = bp->b_actf;
bp 1753 dev/raidframe/rf_openbsdkintf.c blocknum = bp->b_blkno;
bp 1754 dev/raidframe/rf_openbsdkintf.c if (DISKPART(bp->b_dev) != RAW_PART) {
bp 1755 dev/raidframe/rf_openbsdkintf.c pp = &rs->sc_dkdev.dk_label->d_partitions[DISKPART(bp->b_dev)];
bp 1759 dev/raidframe/rf_openbsdkintf.c db1_printf(("Blocks: %d, %lld\n", (int) bp->b_blkno,
bp 1762 dev/raidframe/rf_openbsdkintf.c db1_printf(("bp->b_bcount = %d\n", (int) bp->b_bcount));
bp 1763 dev/raidframe/rf_openbsdkintf.c db1_printf(("bp->b_resid = %d\n", (int) bp->b_resid));
bp 1771 dev/raidframe/rf_openbsdkintf.c num_blocks = bp->b_bcount >> raidPtr->logBytesPerSector;
bp 1772 dev/raidframe/rf_openbsdkintf.c pb = (bp->b_bcount & raidPtr->sectorMask) ? 1 : 0;
bp 1777 dev/raidframe/rf_openbsdkintf.c (int)num_blocks, (int)pb, (int)bp->b_resid));
bp 1781 dev/raidframe/rf_openbsdkintf.c bp->b_error = ENOSPC;
bp 1782 dev/raidframe/rf_openbsdkintf.c bp->b_flags |= B_ERROR;
bp 1783 dev/raidframe/rf_openbsdkintf.c bp->b_resid = bp->b_bcount;
bp 1787 dev/raidframe/rf_openbsdkintf.c biodone(bp);
bp 1795 dev/raidframe/rf_openbsdkintf.c if (bp->b_bcount & raidPtr->sectorMask) {
bp 1796 dev/raidframe/rf_openbsdkintf.c bp->b_error = EINVAL;
bp 1797 dev/raidframe/rf_openbsdkintf.c bp->b_flags |= B_ERROR;
bp 1798 dev/raidframe/rf_openbsdkintf.c bp->b_resid = bp->b_bcount;
bp 1802 dev/raidframe/rf_openbsdkintf.c biodone(bp);
bp 1831 dev/raidframe/rf_openbsdkintf.c retcode = rf_DoAccess(raidPtr, (bp->b_flags & B_READ) ?
bp 1834 dev/raidframe/rf_openbsdkintf.c bp->b_data, bp, NULL, NULL,
bp 1848 dev/raidframe/rf_openbsdkintf.c struct buf *bp;
bp 1871 dev/raidframe/rf_openbsdkintf.c bp = req->bp;
bp 1881 dev/raidframe/rf_openbsdkintf.c if (bp->b_flags & B_ERROR) {
bp 1882 dev/raidframe/rf_openbsdkintf.c bp->b_flags &= ~B_ERROR;
bp 1884 dev/raidframe/rf_openbsdkintf.c if (bp->b_error!=0) {
bp 1885 dev/raidframe/rf_openbsdkintf.c bp->b_error = 0;
bp 1896 dev/raidframe/rf_openbsdkintf.c raidbp->rf_obp = bp;
bp 1929 dev/raidframe/rf_openbsdkintf.c op | bp->b_flags, queue->rf_cinfo->ci_dev,
bp 1936 dev/raidframe/rf_openbsdkintf.c (long)bp->b_blkno));
bp 1978 dev/raidframe/rf_openbsdkintf.c struct buf *bp;
bp 1987 dev/raidframe/rf_openbsdkintf.c bp = raidbp->rf_obp;
bp 1992 dev/raidframe/rf_openbsdkintf.c bp->b_flags |= B_ERROR;
bp 1993 dev/raidframe/rf_openbsdkintf.c bp->b_error =
bp 1999 dev/raidframe/rf_openbsdkintf.c bp->b_resid = raidbp->rf_buf.b_resid;
bp 2014 dev/raidframe/rf_openbsdkintf.c bp->b_bcount = raidbp->rf_buf.b_bcount; /* XXXX ?? */
bp 2022 dev/raidframe/rf_openbsdkintf.c if (bp->b_flags & B_ERROR) {
bp 2044 dev/raidframe/rf_openbsdkintf.c rf_DiskIOComplete(queue, req, (bp->b_flags & B_ERROR) ? 1 : 0);
bp 2045 dev/raidframe/rf_openbsdkintf.c (req->CompleteFunc)(req->argument, (bp->b_flags & B_ERROR) ? 1 : 0);
bp 2055 dev/raidframe/rf_openbsdkintf.c struct buf *bp,
bp 2069 dev/raidframe/rf_openbsdkintf.c bp->b_flags = B_CALL | rw_flag; /* XXX need B_PHYS here too ??? */
bp 2070 dev/raidframe/rf_openbsdkintf.c bp->b_bcount = numSect << logBytesPerSector;
bp 2071 dev/raidframe/rf_openbsdkintf.c bp->b_bufsize = bp->b_bcount;
bp 2072 dev/raidframe/rf_openbsdkintf.c bp->b_error = 0;
bp 2073 dev/raidframe/rf_openbsdkintf.c bp->b_dev = dev;
bp 2074 dev/raidframe/rf_openbsdkintf.c bp->b_data = buf;
bp 2075 dev/raidframe/rf_openbsdkintf.c bp->b_blkno = startSect;
bp 2076 dev/raidframe/rf_openbsdkintf.c bp->b_resid = bp->b_bcount; /* XXX is this right !??!?!! */
bp 2077 dev/raidframe/rf_openbsdkintf.c if (bp->b_bcount == 0) {
bp 2080 dev/raidframe/rf_openbsdkintf.c bp->b_proc = b_proc;
bp 2081 dev/raidframe/rf_openbsdkintf.c bp->b_iodone = cbFunc;
bp 2082 dev/raidframe/rf_openbsdkintf.c bp->b_vp = b_vp;
bp 2083 dev/raidframe/rf_openbsdkintf.c LIST_INIT(&bp->b_dep);
bp 2285 dev/raidframe/rf_openbsdkintf.c struct buf *bp;
bp 2302 dev/raidframe/rf_openbsdkintf.c bp = geteblk((int)RF_COMPONENT_INFO_SIZE);
bp 2303 dev/raidframe/rf_openbsdkintf.c bp->b_dev = dev;
bp 2306 dev/raidframe/rf_openbsdkintf.c bp->b_blkno = RF_COMPONENT_INFO_OFFSET / DEV_BSIZE;
bp 2307 dev/raidframe/rf_openbsdkintf.c bp->b_bcount = RF_COMPONENT_INFO_SIZE;
bp 2308 dev/raidframe/rf_openbsdkintf.c bp->b_flags |= B_READ;
bp 2309 dev/raidframe/rf_openbsdkintf.c bp->b_resid = RF_COMPONENT_INFO_SIZE / DEV_BSIZE;
bp 2311 dev/raidframe/rf_openbsdkintf.c (*bdevsw[major(bp->b_dev)].d_strategy)(bp);
bp 2313 dev/raidframe/rf_openbsdkintf.c error = biowait(bp);
bp 2316 dev/raidframe/rf_openbsdkintf.c memcpy(clabel, bp->b_data, sizeof(RF_ComponentLabel_t));
bp 2324 dev/raidframe/rf_openbsdkintf.c brelse(bp);
bp 2333 dev/raidframe/rf_openbsdkintf.c struct buf *bp;
bp 2337 dev/raidframe/rf_openbsdkintf.c bp = geteblk((int)RF_COMPONENT_INFO_SIZE);
bp 2338 dev/raidframe/rf_openbsdkintf.c bp->b_dev = dev;
bp 2341 dev/raidframe/rf_openbsdkintf.c bp->b_blkno = RF_COMPONENT_INFO_OFFSET / DEV_BSIZE;
bp 2342 dev/raidframe/rf_openbsdkintf.c bp->b_bcount = RF_COMPONENT_INFO_SIZE;
bp 2343 dev/raidframe/rf_openbsdkintf.c bp->b_flags |= B_WRITE;
bp 2344 dev/raidframe/rf_openbsdkintf.c bp->b_resid = RF_COMPONENT_INFO_SIZE / DEV_BSIZE;
bp 2346 dev/raidframe/rf_openbsdkintf.c memset(bp->b_data, 0, RF_COMPONENT_INFO_SIZE );
bp 2348 dev/raidframe/rf_openbsdkintf.c memcpy(bp->b_data, clabel, sizeof(RF_ComponentLabel_t));
bp 2350 dev/raidframe/rf_openbsdkintf.c (*bdevsw[major(bp->b_dev)].d_strategy)(bp);
bp 2351 dev/raidframe/rf_openbsdkintf.c error = biowait(bp);
bp 2352 dev/raidframe/rf_openbsdkintf.c brelse(bp);
bp 3518 dev/raidframe/rf_openbsdkintf.c struct buf *bp;
bp 3520 dev/raidframe/rf_openbsdkintf.c bp = (struct buf *)desc->bp;
bp 3522 dev/raidframe/rf_openbsdkintf.c (bp->b_bcount - bp->b_resid),
bp 3523 dev/raidframe/rf_openbsdkintf.c (bp->b_flags & B_READ));
bp 76 dev/raidframe/rf_parityloggingdags.c RF_AccessStripeMap_t *asmap, RF_DagHeader_t *dag_h, void *bp,
bp 350 dev/raidframe/rf_parityloggingdags.c RF_AccessStripeMap_t *asmap, RF_DagHeader_t *dag_h, void *bp,
bp 734 dev/raidframe/rf_parityloggingdags.c RF_AccessStripeMap_t *asmap, RF_DagHeader_t *dag_h, void *bp,
bp 739 dev/raidframe/rf_parityloggingdags.c rf_CommonCreateParityLoggingSmallWriteDAG(raidPtr, asmap, dag_h, bp,
bp 746 dev/raidframe/rf_parityloggingdags.c RF_AccessStripeMap_t *asmap, RF_DagHeader_t *dag_h, void *bp,
bp 751 dev/raidframe/rf_parityloggingdags.c rf_CommonCreateParityLoggingLargeWriteDAG(raidPtr, asmap, dag_h, bp,
bp 289 dev/raidframe/rf_pq.c rf_CommonCreateLargeWriteDAG(raidPtr, asmap, dag_h, bp, flags,
bp 419 dev/raidframe/rf_pq.c rf_CommonCreateSmallWriteDAG(raidPtr, asmap, dag_h, bp, flags,
bp 72 dev/raidframe/rf_pqdeg.c rf_CreateDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
bp 85 dev/raidframe/rf_pqdeg.c rf_CreateDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
bp 101 dev/raidframe/rf_pqdeg.c rf_CreateDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
bp 113 dev/raidframe/rf_pqdeg.c rf_PQ_DoubleDegRead(raidPtr, asmap, dag_h, bp, flags, allocList);
bp 119 dev/raidframe/rf_pqdeg.c rf_CreateDoubleDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags,
bp 133 dev/raidframe/rf_pqdeg.c rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp,
bp 146 dev/raidframe/rf_pqdeg.c rf_CommonCreateSmallWriteDAG(raidPtr, asmap, dag_h, bp, flags,
bp 153 dev/raidframe/rf_pqdeg.c rf_CommonCreateSmallWriteDAG(raidPtr, asmap, dag_h, bp, flags,
bp 165 dev/raidframe/rf_pqdeg.c rf_CommonCreateLargeWriteDAG(raidPtr, asmap, dag_h, bp, flags,
bp 172 dev/raidframe/rf_pqdeg.c rf_CommonCreateLargeWriteDAG(raidPtr, asmap, dag_h, bp, flags,
bp 182 dev/raidframe/rf_pqdeg.c rf_CreateNonRedundantWriteDAG(raidPtr, asmap, dag_h, bp, flags,
bp 207 dev/raidframe/rf_pqdeg.c rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp, flags,
bp 220 dev/raidframe/rf_pqdeg.c rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp, flags,
bp 126 dev/raidframe/rf_pqdegdags.c rf_DoubleDegRead(raidPtr, asmap, dag_h, bp, flags, allocList,
bp 132 dev/raidframe/rf_pqdegdags.c RF_PhysDiskAddr_t *ppda, RF_PhysDiskAddr_t *qpda, void *bp)
bp 171 dev/raidframe/rf_pqdegdags.c rf_bxor(buf, pbuf, rf_RaidAddressToByte(raidPtr, len), bp);
bp 246 dev/raidframe/rf_pqdegdags.c rf_applyPDA(raidPtr, pda, ppda, qpda, node->dagHdr->bp);
bp 248 dev/raidframe/rf_pqdegdags.c rf_applyPDA(raidPtr, pda, ppda, qpda, node->dagHdr->bp);
bp 362 dev/raidframe/rf_pqdegdags.c node->dagHdr->bp);
bp 415 dev/raidframe/rf_pqdegdags.c rf_RaidAddressToByte(raidPtr, ppda->numSector), node->dagHdr->bp);
bp 420 dev/raidframe/rf_pqdegdags.c node->dagHdr->bp);
bp 477 dev/raidframe/rf_pqdegdags.c rf_PQ_DDLargeWrite(raidPtr, asmap, dag_h, bp, flags, allocList);
bp 482 dev/raidframe/rf_pqdegdags.c rf_PQ_DDSimpleSmallWrite(raidPtr, asmap, dag_h, bp, flags,
bp 491 dev/raidframe/rf_pqdegdags.c rf_DoubleDegSmallWrite(raidPtr, asmap, dag_h, bp, flags, allocList,
bp 212 dev/raidframe/rf_states.c wakeup(desc->bp);
bp 233 dev/raidframe/rf_states.c biodone(desc->bp); /* Access came through ioctl. */
bp 498 dev/raidframe/rf_states.c dag_h->bp = (struct buf *) desc->bp;
bp 114 dev/ramdisk.c void rdstrategy(struct buf *bp);
bp 318 dev/ramdisk.c rdstrategy(bp)
bp 319 dev/ramdisk.c struct buf *bp;
bp 327 dev/ramdisk.c unit = DISKUNIT(bp->b_dev);
bp 331 dev/ramdisk.c if (sc == NULL || bp->b_blkno < 0 ||
bp 332 dev/ramdisk.c (bp->b_bcount % sc->sc_dkdev.dk_label->d_secsize) != 0) {
bp 333 dev/ramdisk.c bp->b_error = EINVAL;
bp 338 dev/ramdisk.c part = DISKPART(bp->b_dev);
bp 340 dev/ramdisk.c bounds_check_with_label(bp, sc->sc_dkdev.dk_label, 1) <= 0)
bp 347 dev/ramdisk.c bp->b_actf = sc->sc_buflist;
bp 348 dev/ramdisk.c sc->sc_buflist = bp;
bp 349 dev/ramdisk.c if (bp->b_actf == NULL) {
bp 361 dev/ramdisk.c bp->b_resid = bp->b_bcount;
bp 362 dev/ramdisk.c off = (bp->b_blkno << DEV_BSHIFT);
bp 363 dev/ramdisk.c xfer = bp->b_bcount;
bp 367 dev/ramdisk.c if (bp->b_flags & B_READ)
bp 368 dev/ramdisk.c bcopy(addr, bp->b_data, xfer);
bp 370 dev/ramdisk.c bcopy(bp->b_data, addr, xfer);
bp 371 dev/ramdisk.c bp->b_resid -= xfer;
bp 375 dev/ramdisk.c bp->b_error = EIO;
bp 377 dev/ramdisk.c bp->b_flags |= B_ERROR;
bp 378 dev/ramdisk.c bp->b_resid = bp->b_bcount;
bp 383 dev/ramdisk.c biodone(bp);
bp 595 dev/ramdisk.c struct buf *bp;
bp 611 dev/ramdisk.c bp = sc->sc_buflist;
bp 612 dev/ramdisk.c sc->sc_buflist = bp->b_actf;
bp 613 dev/ramdisk.c bp->b_actf = NULL;
bp 617 dev/ramdisk.c bp->b_resid = bp->b_bcount;
bp 618 dev/ramdisk.c off = (bp->b_blkno << DEV_BSHIFT);
bp 620 dev/ramdisk.c if (bp->b_flags & B_READ)
bp 625 dev/ramdisk.c xfer = bp->b_resid;
bp 629 dev/ramdisk.c if (bp->b_flags & B_READ)
bp 630 dev/ramdisk.c error = copyin(addr, bp->b_data, xfer);
bp 632 dev/ramdisk.c error = copyout(bp->b_data, addr, xfer);
bp 634 dev/ramdisk.c bp->b_resid -= xfer;
bp 638 dev/ramdisk.c bp->b_error = error;
bp 639 dev/ramdisk.c bp->b_flags |= B_ERROR;
bp 642 dev/ramdisk.c biodone(bp);
bp 466 dev/sbus/be.c caddr_t bp;
bp 468 dev/sbus/be.c bp = sc->sc_rb.rb_txbuf + (idx % sc->sc_rb.rb_ntbuf) * BE_PKT_BUF_SZ;
bp 476 dev/sbus/be.c bcopy(mtod(m, caddr_t), bp+boff, len);
bp 497 dev/sbus/be.c caddr_t bp;
bp 499 dev/sbus/be.c bp = sc->sc_rb.rb_rxbuf + (idx % sc->sc_rb.rb_nrbuf) * BE_PKT_BUF_SZ;
bp 528 dev/sbus/be.c bcopy(bp + boff, mtod(m, caddr_t), len);
bp 312 dev/sbus/bpp.c caddr_t bp = sc->sc_buf;
bp 315 dev/sbus/bpp.c if ((error = uiomove(bp, len, uio)) != 0)
bp 321 dev/sbus/bpp.c DMA_SETUP(lsi, &bp, &len, 0, &size);
bp 327 dev/sbus/bpp.c for (i=0; i<len; i++) printf("%c(0x%x)", bp[i], bp[i]);
bp 1486 dev/sbus/magma.c struct bpp_param *bp;
bp 1492 dev/sbus/magma.c bp = (struct bpp_param *)data;
bp 1493 dev/sbus/magma.c if (bp->bp_burst < BPP_BURST_MIN || bp->bp_burst > BPP_BURST_MAX ||
bp 1494 dev/sbus/magma.c bp->bp_delay < BPP_DELAY_MIN || bp->bp_delay > BPP_DELAY_MIN) {
bp 1497 dev/sbus/magma.c mp->mp_burst = bp->bp_burst;
bp 1498 dev/sbus/magma.c mp->mp_timeout = mbpp_mstohz(bp->bp_timeout);
bp 1499 dev/sbus/magma.c mp->mp_delay = mbpp_mstohz(bp->bp_delay);
bp 1503 dev/sbus/magma.c bp = (struct bpp_param *)data;
bp 1504 dev/sbus/magma.c bp->bp_burst = mp->mp_burst;
bp 1505 dev/sbus/magma.c bp->bp_timeout = mbpp_hztoms(mp->mp_timeout);
bp 1506 dev/sbus/magma.c bp->bp_delay = mbpp_hztoms(mp->mp_delay);
bp 337 dev/sbus/qe.c caddr_t bp;
bp 339 dev/sbus/qe.c bp = sc->sc_rb.rb_rxbuf + (idx % sc->sc_rb.rb_nrbuf) * QE_PKT_BUF_SZ;
bp 367 dev/sbus/qe.c bcopy(bp + boff, mtod(m, caddr_t), len);
bp 389 dev/sbus/qe.c caddr_t bp;
bp 391 dev/sbus/qe.c bp = sc->sc_rb.rb_txbuf + (idx % sc->sc_rb.rb_ntbuf) * QE_PKT_BUF_SZ;
bp 399 dev/sbus/qe.c bcopy(mtod(m, caddr_t), bp+boff, len);
bp 501 dev/sdmmc/sdmmc_scsi.c sdmmc_scsi_minphys(struct buf *bp)
bp 504 dev/sdmmc/sdmmc_scsi.c if (bp->b_bcount > DEV_BSIZE)
bp 505 dev/sdmmc/sdmmc_scsi.c bp->b_bcount = DEV_BSIZE;
bp 506 dev/sdmmc/sdmmc_scsi.c minphys(bp);
bp 80 dev/softraid.c void sr_minphys(struct buf *bp);
bp 212 dev/softraid.c sr_minphys(struct buf *bp)
bp 214 dev/softraid.c DNPRINTF(SR_D_MISC, "sr_minphys: %d\n", bp->b_bcount);
bp 217 dev/softraid.c if (bp->b_bcount > SR_MAXFER)
bp 218 dev/softraid.c bp->b_bcount = SR_MAXFER;
bp 219 dev/softraid.c minphys(bp);
bp 2009 dev/softraid.c struct buf *bp;
bp 2024 dev/softraid.c bp = geteblk(sz);
bp 2025 dev/softraid.c if (!bp)
bp 2036 dev/softraid.c bp->b_dev = dev = MAKEDISKDEV(majdev, dv->dv_unit, RAW_PART);
bp 2083 dev/softraid.c bp->b_dev = devr = MAKEDISKDEV(majdev, dv->dv_unit, i);
bp 2092 dev/softraid.c bp->b_flags = B_BUSY | B_READ;
bp 2093 dev/softraid.c bp->b_blkno = SR_META_OFFSET;
bp 2094 dev/softraid.c bp->b_cylinder = 0;
bp 2095 dev/softraid.c bp->b_bcount = sz;
bp 2096 dev/softraid.c bp->b_bufsize = sz;
bp 2097 dev/softraid.c bp->b_resid = sz;
bp 2098 dev/softraid.c (*bdsw->d_strategy)(bp);
bp 2099 dev/softraid.c if ((error = biowait(bp))) {
bp 2108 dev/softraid.c sm = (struct sr_metadata *)bp->b_data;
bp 2763 dev/softraid.c sr_raid1_intr(struct buf *bp)
bp 2765 dev/softraid.c struct sr_ccb *ccb = (struct sr_ccb *)bp;
bp 2773 dev/softraid.c DEVNAME(sc), bp, xs);
bp 3212 dev/softraid.c sr_raidc_intr(struct buf *bp)
bp 3214 dev/softraid.c struct sr_ccb *ccb = (struct sr_ccb *)bp;
bp 3222 dev/softraid.c DEVNAME(sc), bp, wu->swu_xs);
bp 3230 dev/softraid.c crp->crp_opaque = bp;
bp 3237 dev/softraid.c struct buf *bp = sr_raidc_putcryptop(crp);
bp 3238 dev/softraid.c struct sr_ccb *ccb = (struct sr_ccb *)bp;
bp 293 dev/usb/umass_scsi.c umass_scsi_minphys(struct buf *bp)
bp 295 dev/usb/umass_scsi.c if (bp->b_bcount > UMASS_MAX_TRANSFER_SIZE)
bp 296 dev/usb/umass_scsi.c bp->b_bcount = UMASS_MAX_TRANSFER_SIZE;
bp 298 dev/usb/umass_scsi.c minphys(bp);
bp 163 dev/usb/usscanner.c void usscanner_scsipi_minphys(struct buf *bp);
bp 449 dev/usb/usscanner.c usscanner_scsipi_minphys(struct buf *bp)
bp 451 dev/usb/usscanner.c if (bp->b_bcount > USSCANNER_MAX_TRANSFER_SIZE)
bp 452 dev/usb/usscanner.c bp->b_bcount = USSCANNER_MAX_TRANSFER_SIZE;
bp 453 dev/usb/usscanner.c minphys(bp);
bp 281 dev/vesa/vesafb.c u_char *rp, *gp, *bp;
bp 306 dev/vesa/vesafb.c bp = &sc->sc_cmap_blue[idx];
bp 309 dev/vesa/vesafb.c pe.Blue = *bp;
bp 315 dev/vesa/vesafb.c rp++, gp++, bp++;
bp 379 dev/vnd.c vndstrategy(struct buf *bp)
bp 381 dev/vnd.c int unit = vndunit(bp->b_dev);
bp 393 dev/vnd.c DNPRINTF(VDB_FOLLOW, "vndstrategy(%p): unit %d\n", bp, unit);
bp 396 dev/vnd.c bp->b_error = ENXIO;
bp 397 dev/vnd.c bp->b_flags |= B_ERROR;
bp 399 dev/vnd.c biodone(bp);
bp 404 dev/vnd.c bn = bp->b_blkno;
bp 405 dev/vnd.c bp->b_resid = bp->b_bcount;
bp 408 dev/vnd.c bp->b_error = EINVAL;
bp 409 dev/vnd.c bp->b_flags |= B_ERROR;
bp 411 dev/vnd.c biodone(bp);
bp 418 dev/vnd.c if (bounds_check_with_label(bp, vnd->sc_dk.dk_label, 1) <= 0) {
bp 420 dev/vnd.c biodone(bp);
bp 428 dev/vnd.c bp->b_resid = bp->b_bcount;
bp 431 dev/vnd.c sz = howmany(bp->b_bcount, DEV_BSIZE);
bp 434 dev/vnd.c if (vndsimple(bp->b_dev)) {
bp 437 dev/vnd.c int part = DISKPART(bp->b_dev);
bp 440 dev/vnd.c aiov.iov_base = bp->b_data;
bp 441 dev/vnd.c auio.uio_resid = aiov.iov_len = bp->b_bcount;
bp 444 dev/vnd.c auio.uio_offset = dbtob((off_t)(bp->b_blkno + off));
bp 449 dev/vnd.c if (bp->b_flags & B_READ) {
bp 451 dev/vnd.c bp->b_error = VOP_READ(vnd->sc_vp, &auio, 0,
bp 454 dev/vnd.c vndencrypt(vnd, bp->b_data,
bp 455 dev/vnd.c bp->b_bcount, bp->b_blkno, 0);
bp 458 dev/vnd.c vndencrypt(vnd, bp->b_data,
bp 459 dev/vnd.c bp->b_bcount, bp->b_blkno, 1);
bp 465 dev/vnd.c bp->b_error = VOP_WRITE(vnd->sc_vp, &auio,
bp 469 dev/vnd.c vndencrypt(vnd, bp->b_data,
bp 470 dev/vnd.c bp->b_bcount, bp->b_blkno, 0);
bp 473 dev/vnd.c if (bp->b_error)
bp 474 dev/vnd.c bp->b_flags |= B_ERROR;
bp 475 dev/vnd.c bp->b_resid = auio.uio_resid;
bp 477 dev/vnd.c biodone(bp);
bp 489 dev/vnd.c bp = vnd->sc_tab.b_actf;
bp 490 dev/vnd.c vnd->sc_tab.b_actf = bp->b_actf;
bp 497 dev/vnd.c bn += DL_GETPOFFSET(&vnd->sc_dk.dk_label->d_partitions[DISKPART(bp->b_dev)]);
bp 500 dev/vnd.c addr = bp->b_data;
bp 501 dev/vnd.c flags = bp->b_flags | B_CALL;
bp 502 dev/vnd.c for (resid = bp->b_resid; resid; resid -= sz) {
bp 533 dev/vnd.c nbp->vb_buf.b_bufsize = bp->b_bufsize;
bp 541 dev/vnd.c nbp->vb_buf.b_proc = bp->b_proc;
bp 544 dev/vnd.c nbp->vb_buf.b_dirtyoff = bp->b_dirtyoff;
bp 545 dev/vnd.c nbp->vb_buf.b_dirtyend = bp->b_dirtyend;
bp 546 dev/vnd.c nbp->vb_buf.b_validoff = bp->b_validoff;
bp 547 dev/vnd.c nbp->vb_buf.b_validend = bp->b_validend;
bp 551 dev/vnd.c nbp->vb_obp = bp;
bp 567 dev/vnd.c bp->b_resid -= (resid - sz);
bp 599 dev/vnd.c struct buf *bp;
bp 605 dev/vnd.c bp = vnd->sc_tab.b_actf;
bp 606 dev/vnd.c vnd->sc_tab.b_actf = bp->b_actf;
bp 610 dev/vnd.c vnd-vnd_softc, bp, bp->b_vp, bp->b_blkno, bp->b_data,
bp 611 dev/vnd.c bp->b_bcount);
bp 616 dev/vnd.c if ((bp->b_flags & B_READ) == 0)
bp 617 dev/vnd.c bp->b_vp->v_numoutput++;
bp 618 dev/vnd.c VOP_STRATEGY(bp);
bp 622 dev/vnd.c vndiodone(struct buf *bp)
bp 624 dev/vnd.c struct vndbuf *vbp = (struct vndbuf *) bp;
bp 102 isofs/cd9660/cd9660_lookup.c struct buf *bp; /* a buffer of directory entries */
bp 132 isofs/cd9660/cd9660_lookup.c bp = NULL;
bp 192 isofs/cd9660/cd9660_lookup.c &bp)))
bp 207 isofs/cd9660/cd9660_lookup.c if (bp != NULL)
bp 208 isofs/cd9660/cd9660_lookup.c brelse(bp);
bp 210 isofs/cd9660/cd9660_lookup.c NULL, &bp);
bp 219 isofs/cd9660/cd9660_lookup.c ((char *)bp->b_data + entryoffsetinblock);
bp 269 isofs/cd9660/cd9660_lookup.c ino = dbtob(bp->b_blkno)
bp 286 isofs/cd9660/cd9660_lookup.c ino = dbtob(bp->b_blkno) + entryoffsetinblock;
bp 308 isofs/cd9660/cd9660_lookup.c if (bp != NULL)
bp 309 isofs/cd9660/cd9660_lookup.c brelse(bp);
bp 311 isofs/cd9660/cd9660_lookup.c (off_t)saveoffset, NULL, &bp)) != 0)
bp 316 isofs/cd9660/cd9660_lookup.c ((char *)bp->b_data + entryoffsetinblock);
bp 332 isofs/cd9660/cd9660_lookup.c if (bp != NULL)
bp 333 isofs/cd9660/cd9660_lookup.c brelse(bp);
bp 381 isofs/cd9660/cd9660_lookup.c brelse(bp);
bp 400 isofs/cd9660/cd9660_lookup.c brelse(bp);
bp 406 isofs/cd9660/cd9660_lookup.c brelse(bp);
bp 434 isofs/cd9660/cd9660_lookup.c struct buf *bp;
bp 443 isofs/cd9660/cd9660_lookup.c if ((error = bread(vp, lbn, bsize, NOCRED, &bp)) != 0) {
bp 444 isofs/cd9660/cd9660_lookup.c brelse(bp);
bp 449 isofs/cd9660/cd9660_lookup.c *res = (char *)bp->b_data + blkoff(imp, offset);
bp 450 isofs/cd9660/cd9660_lookup.c *bpp = bp;
bp 297 isofs/cd9660/cd9660_node.c cd9660_defattr(isodir, inop, bp)
bp 300 isofs/cd9660/cd9660_node.c struct buf *bp;
bp 318 isofs/cd9660/cd9660_node.c if (!bp
bp 323 isofs/cd9660/cd9660_node.c bp = bp2;
bp 325 isofs/cd9660/cd9660_node.c if (bp) {
bp 326 isofs/cd9660/cd9660_node.c ap = (struct iso_extended_attributes *)bp->b_data;
bp 360 isofs/cd9660/cd9660_node.c cd9660_deftstamp(isodir,inop,bp)
bp 363 isofs/cd9660/cd9660_node.c struct buf *bp;
bp 370 isofs/cd9660/cd9660_node.c if (!bp
bp 375 isofs/cd9660/cd9660_node.c bp = bp2;
bp 377 isofs/cd9660/cd9660_node.c if (bp) {
bp 378 isofs/cd9660/cd9660_node.c ap = (struct iso_extended_attributes *)bp->b_data;
bp 528 isofs/cd9660/cd9660_rrip.c struct buf *bp = NULL;
bp 593 isofs/cd9660/cd9660_rrip.c ana->imp->logical_block_size, NOCRED, &bp))
bp 597 isofs/cd9660/cd9660_rrip.c (ISO_SUSP_HEADER *)(bp->b_data + ana->iso_ce_off);
bp 603 isofs/cd9660/cd9660_rrip.c if (bp)
bp 604 isofs/cd9660/cd9660_rrip.c brelse(bp);
bp 224 isofs/cd9660/cd9660_vfsops.c struct buf *bp = NULL;
bp 285 isofs/cd9660/cd9660_vfsops.c iso_bsize, NOCRED, &bp)) != 0)
bp 288 isofs/cd9660/cd9660_vfsops.c vdp = (struct iso_volume_descriptor *)bp->b_data;
bp 297 isofs/cd9660/cd9660_vfsops.c pribp = bp;
bp 298 isofs/cd9660/cd9660_vfsops.c bp = NULL;
bp 304 isofs/cd9660/cd9660_vfsops.c supbp = bp;
bp 305 isofs/cd9660/cd9660_vfsops.c bp = NULL;
bp 328 isofs/cd9660/cd9660_vfsops.c if (bp) {
bp 329 isofs/cd9660/cd9660_vfsops.c brelse(bp);
bp 330 isofs/cd9660/cd9660_vfsops.c bp = NULL;
bp 334 isofs/cd9660/cd9660_vfsops.c if (bp) {
bp 335 isofs/cd9660/cd9660_vfsops.c brelse(bp);
bp 336 isofs/cd9660/cd9660_vfsops.c bp = NULL;
bp 388 isofs/cd9660/cd9660_vfsops.c isomp->logical_block_size, NOCRED, &bp)) != 0)
bp 391 isofs/cd9660/cd9660_vfsops.c rootp = (struct iso_directory_record *)bp->b_data;
bp 403 isofs/cd9660/cd9660_vfsops.c bp->b_flags |= B_AGE;
bp 404 isofs/cd9660/cd9660_vfsops.c brelse(bp);
bp 405 isofs/cd9660/cd9660_vfsops.c bp = NULL;
bp 442 isofs/cd9660/cd9660_vfsops.c if (bp)
bp 443 isofs/cd9660/cd9660_vfsops.c brelse(bp);
bp 465 isofs/cd9660/cd9660_vfsops.c struct buf *bp = NULL;
bp 473 isofs/cd9660/cd9660_vfsops.c bp = geteblk(ISO_DEFAULT_BLOCK_SIZE);
bp 474 isofs/cd9660/cd9660_vfsops.c bp->b_dev = dev;
bp 477 isofs/cd9660/cd9660_vfsops.c bp->b_blkno = iso_blknum * btodb(ISO_DEFAULT_BLOCK_SIZE);
bp 478 isofs/cd9660/cd9660_vfsops.c bp->b_bcount = ISO_DEFAULT_BLOCK_SIZE;
bp 479 isofs/cd9660/cd9660_vfsops.c bp->b_flags = B_BUSY | B_READ;
bp 480 isofs/cd9660/cd9660_vfsops.c bp->b_cylinder = bp->b_blkno / lp->d_secpercyl;
bp 485 isofs/cd9660/cd9660_vfsops.c (*strat)(bp);
bp 487 isofs/cd9660/cd9660_vfsops.c if (biowait(bp))
bp 490 isofs/cd9660/cd9660_vfsops.c vdp = (struct iso_volume_descriptor *)bp->b_data;
bp 535 isofs/cd9660/cd9660_vfsops.c bp->b_flags |= B_INVAL;
bp 536 isofs/cd9660/cd9660_vfsops.c brelse(bp);
bp 752 isofs/cd9660/cd9660_vfsops.c struct buf *bp;
bp 815 isofs/cd9660/cd9660_vfsops.c imp->logical_block_size, NOCRED, &bp);
bp 818 isofs/cd9660/cd9660_vfsops.c brelse(bp);
bp 822 isofs/cd9660/cd9660_vfsops.c isodir = (struct iso_directory_record *)(bp->b_data + off);
bp 827 isofs/cd9660/cd9660_vfsops.c if (bp != 0)
bp 828 isofs/cd9660/cd9660_vfsops.c brelse(bp);
bp 838 isofs/cd9660/cd9660_vfsops.c if (bp != 0)
bp 839 isofs/cd9660/cd9660_vfsops.c brelse(bp);
bp 848 isofs/cd9660/cd9660_vfsops.c bp = 0;
bp 860 isofs/cd9660/cd9660_vfsops.c if (bp != 0)
bp 861 isofs/cd9660/cd9660_vfsops.c brelse(bp);
bp 862 isofs/cd9660/cd9660_vfsops.c if ((error = cd9660_bufatoff(ip, (off_t)0, NULL, &bp)) != 0) {
bp 866 isofs/cd9660/cd9660_vfsops.c isodir = (struct iso_directory_record *)bp->b_data;
bp 899 isofs/cd9660/cd9660_vfsops.c if (bp != 0)
bp 900 isofs/cd9660/cd9660_vfsops.c brelse(bp);
bp 287 isofs/cd9660/cd9660_vnops.c struct buf *bp;
bp 330 isofs/cd9660/cd9660_vnops.c ra->sizes, i, NOCRED, &bp);
bp 333 isofs/cd9660/cd9660_vnops.c error = bread(vp, lbn, size, NOCRED, &bp);
bp 335 isofs/cd9660/cd9660_vnops.c n = min(n, size - bp->b_resid);
bp 337 isofs/cd9660/cd9660_vnops.c brelse(bp);
bp 341 isofs/cd9660/cd9660_vnops.c error = uiomove(bp->b_data + on, (int)n, uio);
bp 345 isofs/cd9660/cd9660_vnops.c bp->b_flags |= B_AGE;
bp 346 isofs/cd9660/cd9660_vnops.c brelse(bp);
bp 498 isofs/cd9660/cd9660_vnops.c struct buf *bp = NULL;
bp 538 isofs/cd9660/cd9660_vnops.c (error = cd9660_bufatoff(dp, (off_t)idp->curroff, NULL, &bp))) {
bp 551 isofs/cd9660/cd9660_vnops.c if (bp != NULL)
bp 552 isofs/cd9660/cd9660_vnops.c brelse(bp);
bp 554 isofs/cd9660/cd9660_vnops.c NULL, &bp);
bp 563 isofs/cd9660/cd9660_vnops.c ((char *)bp->b_data + entryoffsetinblock);
bp 596 isofs/cd9660/cd9660_vnops.c idp->current.d_fileno = dbtob(bp->b_blkno) +
bp 657 isofs/cd9660/cd9660_vnops.c if (bp)
bp 658 isofs/cd9660/cd9660_vnops.c brelse (bp);
bp 685 isofs/cd9660/cd9660_vnops.c struct buf *bp;
bp 704 isofs/cd9660/cd9660_vnops.c imp->logical_block_size, NOCRED, &bp);
bp 706 isofs/cd9660/cd9660_vnops.c brelse(bp);
bp 713 isofs/cd9660/cd9660_vnops.c dirp = (ISODIR *)(bp->b_data + (ip->i_number & imp->im_bmask));
bp 721 isofs/cd9660/cd9660_vnops.c brelse(bp);
bp 742 isofs/cd9660/cd9660_vnops.c brelse(bp);
bp 748 isofs/cd9660/cd9660_vnops.c brelse(bp);
bp 822 isofs/cd9660/cd9660_vnops.c struct buf *bp = ap->a_bp;
bp 823 isofs/cd9660/cd9660_vnops.c struct vnode *vp = bp->b_vp;
bp 831 isofs/cd9660/cd9660_vnops.c if (bp->b_blkno == bp->b_lblkno) {
bp 832 isofs/cd9660/cd9660_vnops.c error = VOP_BMAP(vp, bp->b_lblkno, NULL, &bp->b_blkno, NULL);
bp 834 isofs/cd9660/cd9660_vnops.c bp->b_error = error;
bp 835 isofs/cd9660/cd9660_vnops.c bp->b_flags |= B_ERROR;
bp 837 isofs/cd9660/cd9660_vnops.c biodone(bp);
bp 841 isofs/cd9660/cd9660_vnops.c if ((long)bp->b_blkno == -1)
bp 842 isofs/cd9660/cd9660_vnops.c clrbuf(bp);
bp 844 isofs/cd9660/cd9660_vnops.c if ((long)bp->b_blkno == -1) {
bp 846 isofs/cd9660/cd9660_vnops.c biodone(bp);
bp 851 isofs/cd9660/cd9660_vnops.c bp->b_dev = vp->v_rdev;
bp 81 isofs/udf/udf.h struct buf *bp;
bp 101 isofs/udf/udf.h #define RDSECTOR(devvp, sector, size, bp) \
bp 102 isofs/udf/udf.h bread(devvp, sector << (ump->um_bshift - DEV_BSHIFT), size, NOCRED, bp)
bp 105 isofs/udf/udf.h udf_readlblks(struct umount *ump, int sector, int size, struct buf **bp)
bp 108 isofs/udf/udf.h (size + ump->um_bmask) & ~ump->um_bmask, bp));
bp 98 isofs/udf/udf_subr.c struct buf *bp;
bp 105 isofs/udf/udf_subr.c bp = geteblk(bsize);
bp 106 isofs/udf/udf_subr.c bp->b_dev = dev;
bp 111 isofs/udf/udf_subr.c bp->b_blkno = sector * btodb(bsize);
bp 112 isofs/udf/udf_subr.c bp->b_bcount = bsize;
bp 113 isofs/udf/udf_subr.c bp->b_flags = B_BUSY | B_READ;
bp 114 isofs/udf/udf_subr.c bp->b_resid = bp->b_blkno / lp->d_secpercyl;
bp 116 isofs/udf/udf_subr.c (*strat)(bp);
bp 117 isofs/udf/udf_subr.c if (biowait(bp))
bp 120 isofs/udf/udf_subr.c if (udf_checktag((struct desc_tag *)bp->b_data, TAGID_ANCHOR))
bp 123 isofs/udf/udf_subr.c bcopy(bp->b_data, &avdp, sizeof(avdp));
bp 131 isofs/udf/udf_subr.c bp->b_blkno = sector * btodb(bsize);
bp 132 isofs/udf/udf_subr.c bp->b_bcount = bsize;
bp 133 isofs/udf/udf_subr.c bp->b_flags = B_BUSY | B_READ;
bp 134 isofs/udf/udf_subr.c bp->b_resid = bp->b_blkno / lp->d_secpercyl;
bp 136 isofs/udf/udf_subr.c (*strat)(bp);
bp 137 isofs/udf/udf_subr.c if (biowait(bp))
bp 140 isofs/udf/udf_subr.c pvd = (struct pri_vol_desc *)bp->b_data;
bp 180 isofs/udf/udf_subr.c bp->b_flags |= B_INVAL;
bp 181 isofs/udf/udf_subr.c brelse(bp);
bp 233 isofs/udf/udf_subr.c struct buf *bp;
bp 243 isofs/udf/udf_subr.c error = udf_readatoffset(ump->um_vat, &size, *sector << 2, &bp, &data);
bp 245 isofs/udf/udf_subr.c if (bp != NULL)
bp 246 isofs/udf/udf_subr.c brelse(bp);
bp 253 isofs/udf/udf_subr.c if (bp != NULL)
bp 254 isofs/udf/udf_subr.c brelse(bp);
bp 262 isofs/udf/udf_subr.c brelse(bp);
bp 217 isofs/udf/udf_vfsops.c struct buf *bp = NULL;
bp 272 isofs/udf/udf_vfsops.c &bp)) != 0)
bp 274 isofs/udf/udf_vfsops.c if ((error = udf_checktag((struct desc_tag *)bp->b_data, TAGID_ANCHOR)))
bp 277 isofs/udf/udf_vfsops.c bcopy(bp->b_data, &avdp, sizeof(struct anchor_vdp));
bp 278 isofs/udf/udf_vfsops.c brelse(bp);
bp 279 isofs/udf/udf_vfsops.c bp = NULL;
bp 291 isofs/udf/udf_vfsops.c NOCRED, &bp)) != 0) {
bp 295 isofs/udf/udf_vfsops.c lvd = (struct logvol_desc *)bp->b_data;
bp 306 isofs/udf/udf_vfsops.c pd = (struct part_desc *)bp->b_data;
bp 314 isofs/udf/udf_vfsops.c brelse(bp);
bp 315 isofs/udf/udf_vfsops.c bp = NULL;
bp 349 isofs/udf/udf_vfsops.c if ((error = RDSECTOR(devvp, sector, ump->um_bsize, &bp)) != 0) {
bp 353 isofs/udf/udf_vfsops.c fsd = (struct fileset_desc *)bp->b_data;
bp 360 isofs/udf/udf_vfsops.c brelse(bp);
bp 361 isofs/udf/udf_vfsops.c bp = NULL;
bp 375 isofs/udf/udf_vfsops.c if ((error = udf_readlblks(ump, sector, size, &bp)) != 0) {
bp 380 isofs/udf/udf_vfsops.c root_fentry = (struct file_entry *)bp->b_data;
bp 386 isofs/udf/udf_vfsops.c brelse(bp);
bp 387 isofs/udf/udf_vfsops.c bp = NULL;
bp 402 isofs/udf/udf_vfsops.c if (bp != NULL)
bp 403 isofs/udf/udf_vfsops.c brelse(bp);
bp 508 isofs/udf/udf_vfsops.c struct buf *bp;
bp 518 isofs/udf/udf_vfsops.c bp = NULL;
bp 541 isofs/udf/udf_vfsops.c if ((error = RDSECTOR(devvp, sector, ump->um_bsize, &bp)) != 0) {
bp 544 isofs/udf/udf_vfsops.c if (bp != NULL)
bp 545 isofs/udf/udf_vfsops.c brelse(bp);
bp 549 isofs/udf/udf_vfsops.c fe = (struct file_entry *)bp->b_data;
bp 553 isofs/udf/udf_vfsops.c brelse(bp);
bp 562 isofs/udf/udf_vfsops.c brelse(bp);
bp 566 isofs/udf/udf_vfsops.c bcopy(bp->b_data, up->u_fentry, size);
bp 568 isofs/udf/udf_vfsops.c brelse(bp);
bp 569 isofs/udf/udf_vfsops.c bp = NULL;
bp 693 isofs/udf/udf_vfsops.c struct buf *bp;
bp 706 isofs/udf/udf_vfsops.c letoh32(pms->st_size), &bp);
bp 709 isofs/udf/udf_vfsops.c if (bp != NULL)
bp 710 isofs/udf/udf_vfsops.c brelse(bp);
bp 715 isofs/udf/udf_vfsops.c bcopy(bp->b_data, ump->um_stbl, letoh32(pms->st_size));
bp 716 isofs/udf/udf_vfsops.c brelse(bp);
bp 420 isofs/udf/udf_vnops.c struct buf *bp;
bp 437 isofs/udf/udf_vnops.c error = udf_readatoffset(up, &size, offset, &bp, &data);
bp 440 isofs/udf/udf_vnops.c if (bp != NULL)
bp 441 isofs/udf/udf_vnops.c brelse(bp);
bp 580 isofs/udf/udf_vnops.c &ds->bp, &ds->data);
bp 583 isofs/udf/udf_vnops.c if (ds->bp != NULL)
bp 584 isofs/udf/udf_vnops.c brelse(ds->bp);
bp 627 isofs/udf/udf_vnops.c if (ds->bp != NULL)
bp 628 isofs/udf/udf_vnops.c brelse(ds->bp);
bp 634 isofs/udf/udf_vnops.c &ds->bp, &ds->data);
bp 685 isofs/udf/udf_vnops.c if (ds->bp != NULL)
bp 686 isofs/udf/udf_vnops.c brelse(ds->bp);
bp 832 isofs/udf/udf_vnops.c struct buf *bp;
bp 837 isofs/udf/udf_vnops.c bp = ap->a_bp;
bp 838 isofs/udf/udf_vnops.c vp = bp->b_vp;
bp 842 isofs/udf/udf_vnops.c if (bp->b_blkno != bp->b_lblkno) {
bp 847 isofs/udf/udf_vnops.c if (udf_bmap_internal(up, bp->b_lblkno * up->u_ump->um_bsize,
bp 848 isofs/udf/udf_vnops.c &bp->b_lblkno, &maxsize)) {
bp 849 isofs/udf/udf_vnops.c clrbuf(bp);
bp 850 isofs/udf/udf_vnops.c bp->b_blkno = -1;
bp 853 isofs/udf/udf_vnops.c error = VOP_BMAP(vp, bp->b_lblkno, NULL, &bp->b_blkno, NULL);
bp 855 isofs/udf/udf_vnops.c bp->b_error = error;
bp 856 isofs/udf/udf_vnops.c bp->b_flags |= B_ERROR;
bp 858 isofs/udf/udf_vnops.c biodone(bp);
bp 863 isofs/udf/udf_vnops.c if ((long)bp->b_blkno == -1)
bp 864 isofs/udf/udf_vnops.c clrbuf(bp);
bp 867 isofs/udf/udf_vnops.c if ((long)bp->b_blkno == -1) {
bp 869 isofs/udf/udf_vnops.c biodone(bp);
bp 872 isofs/udf/udf_vnops.c bp->b_dev = vp->v_rdev;
bp 1169 isofs/udf/udf_vnops.c struct buf **bp, uint8_t **data)
bp 1180 isofs/udf/udf_vnops.c *bp = NULL;
bp 1200 isofs/udf/udf_vnops.c if ((error = udf_readlblks(ump, sector, *size, bp))) {
bp 1206 isofs/udf/udf_vnops.c bp1 = *bp;
bp 62 kern/kern_physio.c void putphysbuf(struct buf *bp);
bp 71 kern/kern_physio.c physio(void (*strategy)(struct buf *), struct buf *bp, dev_t dev, int flags,
bp 82 kern/kern_physio.c if ((nobuf = (bp == NULL)) != 0)
bp 83 kern/kern_physio.c bp = getphysbuf();
bp 89 kern/kern_physio.c while (bp->b_flags & B_BUSY) {
bp 91 kern/kern_physio.c bp->b_flags |= B_WANTED;
bp 93 kern/kern_physio.c tsleep(bp, PRIBIO+1, "physbuf", 0);
bp 97 kern/kern_physio.c bp->b_flags |= B_BUSY;
bp 103 kern/kern_physio.c bp->b_dev = dev;
bp 104 kern/kern_physio.c bp->b_error = 0;
bp 105 kern/kern_physio.c bp->b_proc = p;
bp 106 kern/kern_physio.c LIST_INIT(&bp->b_dep);
bp 123 kern/kern_physio.c bp->b_flags = B_BUSY | B_PHYS | B_RAW | flags;
bp 126 kern/kern_physio.c bp->b_blkno = btodb(uio->uio_offset);
bp 127 kern/kern_physio.c bp->b_data = iovp->iov_base;
bp 135 kern/kern_physio.c bp->b_bcount = MAXPHYS;
bp 137 kern/kern_physio.c bp->b_bcount = iovp->iov_len;
bp 144 kern/kern_physio.c (*minphys)(bp);
bp 145 kern/kern_physio.c todo = bp->b_bcount;
bp 160 kern/kern_physio.c error = uvm_vslock(p, bp->b_data, todo,
bp 164 kern/kern_physio.c bp->b_flags |= B_ERROR;
bp 165 kern/kern_physio.c bp->b_error = error;
bp 168 kern/kern_physio.c vmapbuf(bp, todo);
bp 171 kern/kern_physio.c (*strategy)(bp);
bp 184 kern/kern_physio.c while ((bp->b_flags & B_DONE) == 0)
bp 185 kern/kern_physio.c tsleep(bp, PRIBIO + 1, "physio", 0);
bp 188 kern/kern_physio.c bp->b_flags |= B_BUSY;
bp 197 kern/kern_physio.c vunmapbuf(bp, todo);
bp 198 kern/kern_physio.c uvm_vsunlock(p, bp->b_data, todo);
bp 202 kern/kern_physio.c if (bp->b_flags & B_ERROR)
bp 203 kern/kern_physio.c error = (bp->b_error ? bp->b_error : EIO);
bp 209 kern/kern_physio.c done = bp->b_bcount - bp->b_resid;
bp 237 kern/kern_physio.c bp->b_flags &= ~(B_BUSY | B_PHYS | B_RAW);
bp 239 kern/kern_physio.c putphysbuf(bp);
bp 245 kern/kern_physio.c if (bp->b_flags & B_WANTED) {
bp 246 kern/kern_physio.c bp->b_flags &= ~B_WANTED;
bp 247 kern/kern_physio.c wakeup(bp);
bp 264 kern/kern_physio.c struct buf *bp;
bp 268 kern/kern_physio.c bp = pool_get(&bufpool, PR_WAITOK);
bp 271 kern/kern_physio.c bzero(bp, sizeof(*bp));
bp 274 kern/kern_physio.c bp->b_vnbufs.le_next = NOLIST;
bp 276 kern/kern_physio.c return (bp);
bp 286 kern/kern_physio.c putphysbuf(struct buf *bp)
bp 291 kern/kern_physio.c if (bp->b_vp)
bp 292 kern/kern_physio.c brelvp(bp);
bp 295 kern/kern_physio.c if (bp->b_flags & B_WANTED)
bp 298 kern/kern_physio.c pool_put(&bufpool, bp);
bp 311 kern/kern_physio.c minphys(struct buf *bp)
bp 314 kern/kern_physio.c if (bp->b_bcount > MAXPHYS)
bp 315 kern/kern_physio.c bp->b_bcount = MAXPHYS;
bp 208 kern/kgdb_stub.c kgdb_send(u_char *bp)
bp 214 kern/kgdb_stub.c printf("kgdb_send: %s\n", bp);
bp 217 kern/kgdb_stub.c p = bp;
bp 233 kern/kgdb_stub.c kgdb_recv(u_char *bp, int maxlen)
bp 240 kern/kgdb_stub.c p = bp;
bp 265 kern/kgdb_stub.c if (bp[2] == ':') {
bp 266 kern/kgdb_stub.c PUTC(bp[0]);
bp 267 kern/kgdb_stub.c PUTC(bp[1]);
bp 269 kern/kgdb_stub.c kgdb_copy(bp + 3, bp, len);
bp 276 kern/kgdb_stub.c printf("kgdb_recv: %s\n", bp);
bp 92 kern/subr_disk.c disksort(struct buf *ap, struct buf *bp)
bp 98 kern/subr_disk.c bp->b_actf = NULL;
bp 99 kern/subr_disk.c ap->b_actf = bp;
bp 108 kern/subr_disk.c if (bp->b_cylinder < bq->b_cylinder) {
bp 123 kern/subr_disk.c if (bp->b_cylinder <
bp 126 kern/subr_disk.c if (bp->b_cylinder ==
bp 128 kern/subr_disk.c bp->b_blkno < bq->b_actf->b_blkno)
bp 154 kern/subr_disk.c bp->b_cylinder < bq->b_actf->b_cylinder ||
bp 155 kern/subr_disk.c (bp->b_cylinder == bq->b_actf->b_cylinder &&
bp 156 kern/subr_disk.c bp->b_blkno < bq->b_actf->b_blkno))
bp 164 kern/subr_disk.c insert: bp->b_actf = bq->b_actf;
bp 165 kern/subr_disk.c bq->b_actf = bp;
bp 368 kern/subr_disk.c readdoslabel(struct buf *bp, void (*strat)(struct buf *),
bp 395 kern/subr_disk.c bp->b_blkno = part_blkno;
bp 396 kern/subr_disk.c bp->b_bcount = lp->d_secsize;
bp 397 kern/subr_disk.c bp->b_flags = B_BUSY | B_READ;
bp 398 kern/subr_disk.c (*strat)(bp);
bp 399 kern/subr_disk.c if (biowait(bp)) {
bp 405 kern/subr_disk.c bcopy(bp->b_data + DOSPARTOFF, dp, sizeof(dp));
bp 500 kern/subr_disk.c fattest = ((bp->b_data[0] << 8) & 0xff00) |
bp 501 kern/subr_disk.c (bp->b_data[2] & 0xff);
bp 506 kern/subr_disk.c fattest = ((bp->b_data[12] << 8) & 0xff00) |
bp 507 kern/subr_disk.c (bp->b_data[11] & 0xff);
bp 512 kern/subr_disk.c fattest = ((bp->b_data[510] << 8) & 0xff00) |
bp 513 kern/subr_disk.c (bp->b_data[511] & 0xff);
bp 533 kern/subr_disk.c bp->b_blkno = dospartoff + DOS_LABELSECTOR;
bp 534 kern/subr_disk.c bp->b_bcount = lp->d_secsize;
bp 535 kern/subr_disk.c bp->b_flags = B_BUSY | B_READ;
bp 536 kern/subr_disk.c (*strat)(bp);
bp 537 kern/subr_disk.c if (biowait(bp))
bp 541 kern/subr_disk.c return checkdisklabel(bp->b_data, lp);
bp 603 kern/subr_disk.c bounds_check_with_label(struct buf *bp, struct disklabel *lp, int wlabel)
bp 606 kern/subr_disk.c struct partition *p = &lp->d_partitions[DISKPART(bp->b_dev)];
bp 607 kern/subr_disk.c daddr64_t sz = howmany(bp->b_bcount, DEV_BSIZE);
bp 614 kern/subr_disk.c if (bp->b_blkno + sz > blockpersec(DL_GETPSIZE(p), lp)) {
bp 615 kern/subr_disk.c sz = blockpersec(DL_GETPSIZE(p), lp) - bp->b_blkno;
bp 618 kern/subr_disk.c bp->b_resid = bp->b_bcount;
bp 626 kern/subr_disk.c bp->b_bcount = sz << DEV_BSHIFT;
bp 630 kern/subr_disk.c bp->b_cylinder = (bp->b_blkno + blockpersec(DL_GETPOFFSET(p), lp)) /
bp 635 kern/subr_disk.c bp->b_error = EINVAL;
bp 636 kern/subr_disk.c bp->b_flags |= B_ERROR;
bp 655 kern/subr_disk.c diskerr(struct buf *bp, char *dname, char *what, int pri, int blkdone,
bp 658 kern/subr_disk.c int unit = DISKUNIT(bp->b_dev), part = DISKPART(bp->b_dev);
bp 670 kern/subr_disk.c bp->b_flags & B_READ ? "read" : "writ");
bp 671 kern/subr_disk.c sn = bp->b_blkno;
bp 672 kern/subr_disk.c if (bp->b_bcount <= DEV_BSIZE)
bp 679 kern/subr_disk.c (*pr)("%lld-%lld", bp->b_blkno,
bp 680 kern/subr_disk.c bp->b_blkno + (bp->b_bcount - 1) / DEV_BSIZE);
bp 682 kern/subr_disk.c if (lp && (blkdone >= 0 || bp->b_bcount <= lp->d_secsize)) {
bp 933 kern/subr_disk.c bufq_default_add(struct bufq *bq, struct buf *bp)
bp 936 kern/subr_disk.c struct proc *p = bp->b_proc;
bp 946 kern/subr_disk.c disksort(head, bp);
bp 953 kern/subr_disk.c struct buf *bp, *head;
bp 958 kern/subr_disk.c if ((bp = head->b_actf))
bp 961 kern/subr_disk.c if (bp == NULL)
bp 963 kern/subr_disk.c head->b_actf = bp->b_actf;
bp 964 kern/subr_disk.c return (bp);
bp 75 kern/vfs_bio.c #define binshash(bp, dp) LIST_INSERT_HEAD(dp, bp, b_hash)
bp 76 kern/vfs_bio.c #define bremhash(bp) LIST_REMOVE(bp, b_hash)
bp 105 kern/vfs_bio.c #define binsheadfree(bp, dp) TAILQ_INSERT_HEAD(dp, bp, b_freelist)
bp 106 kern/vfs_bio.c #define binstailfree(bp, dp) TAILQ_INSERT_TAIL(dp, bp, b_freelist)
bp 164 kern/vfs_bio.c bremfree(struct buf *bp)
bp 176 kern/vfs_bio.c if (TAILQ_NEXT(bp, b_freelist) == NULL) {
bp 178 kern/vfs_bio.c if (dp->tqh_last == &TAILQ_NEXT(bp, b_freelist))
bp 183 kern/vfs_bio.c numfreepages -= btoc(bp->b_bufsize);
bp 184 kern/vfs_bio.c if (!ISSET(bp->b_flags, B_DELWRI)) {
bp 185 kern/vfs_bio.c int qs = bp->b_bufsize;
bp 187 kern/vfs_bio.c numcleanpages -= btoc(bp->b_bufsize);
bp 188 kern/vfs_bio.c bqpages[queue] -= btoc(bp->b_bufsize);
bp 190 kern/vfs_bio.c numdirtypages -= btoc(bp->b_bufsize);
bp 191 kern/vfs_bio.c TAILQ_REMOVE(dp, bp, b_freelist);
bp 195 kern/vfs_bio.c buf_init(struct buf *bp, int size)
bp 202 kern/vfs_bio.c bzero((char *)bp, sizeof *bp);
bp 203 kern/vfs_bio.c bp->b_vnbufs.le_next = NOLIST;
bp 204 kern/vfs_bio.c bp->b_freelist.tqe_next = NOLIST;
bp 205 kern/vfs_bio.c bp->b_synctime = time_uptime + 300;
bp 206 kern/vfs_bio.c bp->b_dev = NODEV;
bp 208 kern/vfs_bio.c LIST_INIT(&bp->b_dep);
bp 224 kern/vfs_bio.c struct buf *bp;
bp 228 kern/vfs_bio.c bp = pool_get(&bufpool, PR_NOWAIT);
bp 231 kern/vfs_bio.c if (bp == NULL)
bp 234 kern/vfs_bio.c bzero((char *)bp, sizeof *bp);
bp 235 kern/vfs_bio.c bp->b_vnbufs.le_next = NOLIST;
bp 236 kern/vfs_bio.c bp->b_freelist.tqe_next = NOLIST;
bp 237 kern/vfs_bio.c bp->b_synctime = time_uptime + 300;
bp 238 kern/vfs_bio.c bp->b_dev = NODEV;
bp 239 kern/vfs_bio.c bp->b_bufsize = 0;
bp 240 kern/vfs_bio.c bp->b_data = NULL;
bp 241 kern/vfs_bio.c bp->b_flags = B_BUSY;
bp 242 kern/vfs_bio.c bp->b_dev = NODEV;
bp 243 kern/vfs_bio.c bp->b_blkno = bp->b_lblkno = lblkno;
bp 244 kern/vfs_bio.c bp->b_iodone = NULL;
bp 245 kern/vfs_bio.c bp->b_error = 0;
bp 246 kern/vfs_bio.c bp->b_resid = 0;
bp 247 kern/vfs_bio.c bp->b_bcount = 0;
bp 248 kern/vfs_bio.c bp->b_dirtyoff = bp->b_dirtyend = 0;
bp 249 kern/vfs_bio.c bp->b_validoff = bp->b_validend = 0;
bp 251 kern/vfs_bio.c LIST_INIT(&bp->b_dep);
bp 254 kern/vfs_bio.c LIST_INSERT_HEAD(&bufhead, bp, b_list);
bp 255 kern/vfs_bio.c bgetvp(vp, bp);
bp 258 kern/vfs_bio.c return (bp);
bp 265 kern/vfs_bio.c struct buf *bp;
bp 282 kern/vfs_bio.c bp = pool_get(&bufpool, PR_WAITOK);
bp 286 kern/vfs_bio.c pool_put(&bufpool, bp);
bp 289 kern/vfs_bio.c buf_init(bp, qs);
bp 290 kern/vfs_bio.c bp->b_flags = B_INVAL;
bp 291 kern/vfs_bio.c bp->b_bufsize = qs;
bp 292 kern/vfs_bio.c bp->b_data = data;
bp 294 kern/vfs_bio.c binsheadfree(bp, dp);
bp 295 kern/vfs_bio.c binshash(bp, &invalhash);
bp 296 kern/vfs_bio.c LIST_INSERT_HEAD(&bufhead, bp, b_list);
bp 298 kern/vfs_bio.c return (bp);
bp 302 kern/vfs_bio.c buf_put(struct buf *bp)
bp 306 kern/vfs_bio.c if (bp->b_data != NULL)
bp 307 kern/vfs_bio.c KASSERT(bp->b_bufsize > 0);
bp 310 kern/vfs_bio.c if (bp->b_freelist.tqe_next != NOLIST &&
bp 311 kern/vfs_bio.c bp->b_freelist.tqe_next != (void *)-1)
bp 314 kern/vfs_bio.c if (bp->b_vnbufs.le_next != NOLIST &&
bp 315 kern/vfs_bio.c bp->b_vnbufs.le_next != (void *)-1)
bp 319 kern/vfs_bio.c if (!LIST_EMPTY(&bp->b_dep))
bp 322 kern/vfs_bio.c LIST_REMOVE(bp, b_list);
bp 324 kern/vfs_bio.c if (bp->b_data != NULL) {
bp 325 kern/vfs_bio.c bremhash(bp);
bp 326 kern/vfs_bio.c numbufpages -= btoc(bp->b_bufsize);
bp 327 kern/vfs_bio.c uvm_km_free(buf_map, (vaddr_t)bp->b_data, bp->b_bufsize);
bp 330 kern/vfs_bio.c pool_put(&bufpool, bp);
bp 379 kern/vfs_bio.c struct buf *bp;
bp 381 kern/vfs_bio.c bp = getblk(vp, blkno, size, 0, 0);
bp 388 kern/vfs_bio.c if (!ISSET(bp->b_flags, (B_DONE | B_DELWRI))) {
bp 389 kern/vfs_bio.c SET(bp->b_flags, B_READ | async);
bp 390 kern/vfs_bio.c VOP_STRATEGY(bp);
bp 395 kern/vfs_bio.c brelse(bp);
bp 398 kern/vfs_bio.c return (bp);
bp 409 kern/vfs_bio.c struct buf *bp;
bp 412 kern/vfs_bio.c bp = *bpp = bio_doread(vp, blkno, size, 0);
bp 415 kern/vfs_bio.c return (biowait(bp));
bp 426 kern/vfs_bio.c struct buf *bp;
bp 429 kern/vfs_bio.c bp = *bpp = bio_doread(vp, blkno, size, 0);
bp 444 kern/vfs_bio.c return (biowait(bp));
bp 451 kern/vfs_bio.c bread_cluster_callback(struct buf *bp)
bp 456 kern/vfs_bio.c xbpp = (struct buf **)bp->b_saveaddr;
bp 459 kern/vfs_bio.c if (ISSET(bp->b_flags, B_ERROR))
bp 465 kern/vfs_bio.c bp->b_data = NULL;
bp 466 kern/vfs_bio.c buf_put(bp);
bp 472 kern/vfs_bio.c struct buf *bp, **xbpp;
bp 519 kern/vfs_bio.c bp = getnewbuf(howmany * size, 0, 0, NULL);
bp 520 kern/vfs_bio.c if (bp == NULL) {
bp 536 kern/vfs_bio.c xbpp[i]->b_data = bp->b_data + (i * size);
bp 539 kern/vfs_bio.c bp->b_blkno = sblkno;
bp 540 kern/vfs_bio.c bp->b_lblkno = blkno + 1;
bp 541 kern/vfs_bio.c SET(bp->b_flags, B_READ | B_ASYNC | B_CALL);
bp 542 kern/vfs_bio.c bp->b_saveaddr = (void *)xbpp;
bp 543 kern/vfs_bio.c bp->b_iodone = bread_cluster_callback;
bp 544 kern/vfs_bio.c bp->b_vp = vp;
bp 545 kern/vfs_bio.c spill = bp->b_bufsize - bp->b_bcount;
bp 547 kern/vfs_bio.c uvm_km_free(buf_map, (vaddr_t) bp->b_data + bp->b_bcount,
bp 551 kern/vfs_bio.c VOP_STRATEGY(bp);
bp 561 kern/vfs_bio.c bwrite(struct buf *bp)
bp 567 kern/vfs_bio.c vp = bp->b_vp;
bp 580 kern/vfs_bio.c async = ISSET(bp->b_flags, B_ASYNC);
bp 582 kern/vfs_bio.c bdwrite(bp);
bp 598 kern/vfs_bio.c wasdelayed = ISSET(bp->b_flags, B_DELWRI);
bp 599 kern/vfs_bio.c CLR(bp->b_flags, (B_READ | B_DONE | B_ERROR | B_DELWRI));
bp 610 kern/vfs_bio.c reassignbuf(bp);
bp 616 kern/vfs_bio.c bp->b_vp->v_numoutput++;
bp 618 kern/vfs_bio.c SET(bp->b_flags, B_WRITEINPROG);
bp 619 kern/vfs_bio.c VOP_STRATEGY(bp);
bp 627 kern/vfs_bio.c rv = biowait(bp);
bp 630 kern/vfs_bio.c brelse(bp);
bp 650 kern/vfs_bio.c bdwrite(struct buf *bp)
bp 661 kern/vfs_bio.c if (!ISSET(bp->b_flags, B_DELWRI)) {
bp 662 kern/vfs_bio.c SET(bp->b_flags, B_DELWRI);
bp 663 kern/vfs_bio.c bp->b_synctime = time_uptime + 35;
bp 665 kern/vfs_bio.c reassignbuf(bp);
bp 673 kern/vfs_bio.c if (bp->b_synctime < time_uptime) {
bp 674 kern/vfs_bio.c bawrite(bp);
bp 680 kern/vfs_bio.c if (major(bp->b_dev) < nblkdev &&
bp 681 kern/vfs_bio.c bdevsw[major(bp->b_dev)].d_type == D_TAPE) {
bp 682 kern/vfs_bio.c bawrite(bp);
bp 687 kern/vfs_bio.c CLR(bp->b_flags, B_NEEDCOMMIT);
bp 688 kern/vfs_bio.c SET(bp->b_flags, B_DONE);
bp 689 kern/vfs_bio.c brelse(bp);
bp 696 kern/vfs_bio.c bawrite(struct buf *bp)
bp 699 kern/vfs_bio.c SET(bp->b_flags, B_ASYNC);
bp 700 kern/vfs_bio.c VOP_BWRITE(bp);
bp 707 kern/vfs_bio.c buf_dirty(struct buf *bp)
bp 711 kern/vfs_bio.c if (ISSET(bp->b_flags, B_DELWRI) == 0) {
bp 712 kern/vfs_bio.c SET(bp->b_flags, B_DELWRI);
bp 713 kern/vfs_bio.c bp->b_synctime = time_uptime + 35;
bp 714 kern/vfs_bio.c reassignbuf(bp);
bp 722 kern/vfs_bio.c buf_undirty(struct buf *bp)
bp 726 kern/vfs_bio.c if (ISSET(bp->b_flags, B_DELWRI)) {
bp 727 kern/vfs_bio.c CLR(bp->b_flags, B_DELWRI);
bp 728 kern/vfs_bio.c reassignbuf(bp);
bp 737 kern/vfs_bio.c brelse(struct buf *bp)
bp 745 kern/vfs_bio.c if (bp->b_data != NULL)
bp 746 kern/vfs_bio.c KASSERT(bp->b_bufsize > 0);
bp 753 kern/vfs_bio.c if (ISSET(bp->b_flags, (B_NOCACHE|B_ERROR)))
bp 754 kern/vfs_bio.c SET(bp->b_flags, B_INVAL);
bp 756 kern/vfs_bio.c if (ISSET(bp->b_flags, B_INVAL)) {
bp 763 kern/vfs_bio.c if (LIST_FIRST(&bp->b_dep) != NULL)
bp 764 kern/vfs_bio.c buf_deallocate(bp);
bp 766 kern/vfs_bio.c if (ISSET(bp->b_flags, B_DELWRI)) {
bp 767 kern/vfs_bio.c CLR(bp->b_flags, B_DELWRI);
bp 770 kern/vfs_bio.c if (bp->b_vp)
bp 771 kern/vfs_bio.c brelvp(bp);
bp 777 kern/vfs_bio.c if (bp->b_data == NULL) {
bp 778 kern/vfs_bio.c buf_put(bp);
bp 783 kern/vfs_bio.c qs = bp->b_bufsize;
bp 785 kern/vfs_bio.c numcleanpages += btoc(bp->b_bufsize);
bp 786 kern/vfs_bio.c bqpages[queue] += btoc(bp->b_bufsize);
bp 789 kern/vfs_bio.c binsheadfree(bp, &bufqueues[queue]);
bp 796 kern/vfs_bio.c numfreepages += btoc(bp->b_bufsize);
bp 797 kern/vfs_bio.c qs = bp->b_bufsize;
bp 800 kern/vfs_bio.c if (!ISSET(bp->b_flags, B_DELWRI)) {
bp 801 kern/vfs_bio.c numcleanpages += btoc(bp->b_bufsize);
bp 802 kern/vfs_bio.c bqpages[queue] += btoc(bp->b_bufsize);
bp 807 kern/vfs_bio.c numdirtypages += btoc(bp->b_bufsize);
bp 810 kern/vfs_bio.c if (ISSET(bp->b_flags, B_AGE)) {
bp 811 kern/vfs_bio.c binsheadfree(bp, bufq);
bp 812 kern/vfs_bio.c bp->b_synctime = time_uptime + 30;
bp 814 kern/vfs_bio.c binstailfree(bp, bufq);
bp 815 kern/vfs_bio.c bp->b_synctime = time_uptime + 300;
bp 820 kern/vfs_bio.c CLR(bp->b_flags, (B_AGE | B_ASYNC | B_BUSY | B_NOCACHE | B_DEFERRED));
bp 829 kern/vfs_bio.c if (ISSET(bp->b_flags, B_WANTED)) {
bp 830 kern/vfs_bio.c CLR(bp->b_flags, B_WANTED);
bp 831 kern/vfs_bio.c wakeup(bp);
bp 844 kern/vfs_bio.c struct buf *bp;
bp 847 kern/vfs_bio.c LIST_FOREACH(bp, BUFHASH(vp, blkno), b_hash) {
bp 848 kern/vfs_bio.c if (bp->b_lblkno == blkno && bp->b_vp == vp &&
bp 849 kern/vfs_bio.c !ISSET(bp->b_flags, B_INVAL))
bp 850 kern/vfs_bio.c return (bp);
bp 868 kern/vfs_bio.c struct buf *bp, *nb = NULL;
bp 883 kern/vfs_bio.c LIST_FOREACH(bp, BUFHASH(vp, blkno), b_hash) {
bp 884 kern/vfs_bio.c if (bp->b_lblkno != blkno || bp->b_vp != vp)
bp 888 kern/vfs_bio.c if (ISSET(bp->b_flags, B_BUSY)) {
bp 895 kern/vfs_bio.c SET(bp->b_flags, B_WANTED);
bp 896 kern/vfs_bio.c error = tsleep(bp, slpflag | (PRIBIO + 1), "getblk",
bp 904 kern/vfs_bio.c if (!ISSET(bp->b_flags, B_INVAL)) {
bp 905 kern/vfs_bio.c SET(bp->b_flags, (B_BUSY | B_CACHE));
bp 906 kern/vfs_bio.c bremfree(bp);
bp 912 kern/vfs_bio.c if (nb && bp) {
bp 918 kern/vfs_bio.c if (bp == NULL && nb == NULL) {
bp 927 kern/vfs_bio.c bp = nb;
bp 928 kern/vfs_bio.c binshash(bp, bh);
bp 929 kern/vfs_bio.c bp->b_blkno = bp->b_lblkno = blkno;
bp 931 kern/vfs_bio.c bgetvp(vp, bp);
bp 934 kern/vfs_bio.c return (bp);
bp 943 kern/vfs_bio.c struct buf *bp;
bp 945 kern/vfs_bio.c while ((bp = getnewbuf(size, 0, 0, NULL)) == NULL)
bp 947 kern/vfs_bio.c SET(bp->b_flags, B_INVAL);
bp 948 kern/vfs_bio.c binshash(bp, &invalhash);
bp 950 kern/vfs_bio.c return (bp);
bp 959 kern/vfs_bio.c struct buf *bp;
bp 977 kern/vfs_bio.c bp = buf_get(qs); /* XXX use qs instead and no need in buf_get? */
bp 978 kern/vfs_bio.c if (bp == NULL) {
bp 984 kern/vfs_bio.c bp = TAILQ_FIRST(&bufqueues[queue]);
bp 986 kern/vfs_bio.c } while (bp == NULL && queue < BQUEUES);
bp 988 kern/vfs_bio.c if (bp == NULL) {
bp 998 kern/vfs_bio.c && (bp = TAILQ_FIRST(&bufqueues[q]))
bp 1001 kern/vfs_bio.c bremfree(bp);
bp 1002 kern/vfs_bio.c if (LIST_FIRST(&bp->b_dep) != NULL)
bp 1003 kern/vfs_bio.c buf_deallocate(bp);
bp 1005 kern/vfs_bio.c if (ISSET(bp->b_flags, B_DELWRI)) {
bp 1006 kern/vfs_bio.c CLR(bp->b_flags, B_DELWRI);
bp 1009 kern/vfs_bio.c if (bp->b_vp)
bp 1010 kern/vfs_bio.c brelvp(bp);
bp 1012 kern/vfs_bio.c buf_put(bp);
bp 1018 kern/vfs_bio.c if (bp == NULL) {
bp 1033 kern/vfs_bio.c bremfree(bp);
bp 1035 kern/vfs_bio.c SET(bp->b_flags, B_BUSY);
bp 1038 kern/vfs_bio.c if (ISSET(bp->b_flags, B_DELWRI))
bp 1043 kern/vfs_bio.c if (bp->b_vp)
bp 1044 kern/vfs_bio.c brelvp(bp);
bp 1050 kern/vfs_bio.c if (LIST_FIRST(&bp->b_dep) != NULL)
bp 1055 kern/vfs_bio.c bp->b_flags = B_BUSY;
bp 1056 kern/vfs_bio.c bp->b_dev = NODEV;
bp 1057 kern/vfs_bio.c bp->b_blkno = bp->b_lblkno = 0;
bp 1058 kern/vfs_bio.c bp->b_iodone = NULL;
bp 1059 kern/vfs_bio.c bp->b_error = 0;
bp 1060 kern/vfs_bio.c bp->b_resid = 0;
bp 1061 kern/vfs_bio.c bp->b_bcount = size;
bp 1062 kern/vfs_bio.c bp->b_dirtyoff = bp->b_dirtyend = 0;
bp 1063 kern/vfs_bio.c bp->b_validoff = bp->b_validend = 0;
bp 1065 kern/vfs_bio.c bremhash(bp);
bp 1066 kern/vfs_bio.c return (bp);
bp 1076 kern/vfs_bio.c struct buf *bp;
bp 1089 kern/vfs_bio.c while ((bp = TAILQ_FIRST(&bufqueues[BQ_DIRTY]))) {
bp 1095 kern/vfs_bio.c bremfree(bp);
bp 1096 kern/vfs_bio.c SET(bp->b_flags, B_BUSY);
bp 1099 kern/vfs_bio.c if (ISSET(bp->b_flags, B_INVAL)) {
bp 1100 kern/vfs_bio.c brelse(bp);
bp 1105 kern/vfs_bio.c if (!ISSET(bp->b_flags, B_DELWRI))
bp 1108 kern/vfs_bio.c if (LIST_FIRST(&bp->b_dep) != NULL &&
bp 1109 kern/vfs_bio.c !ISSET(bp->b_flags, B_DEFERRED) &&
bp 1110 kern/vfs_bio.c buf_countdeps(bp, 0, 0)) {
bp 1111 kern/vfs_bio.c SET(bp->b_flags, B_DEFERRED);
bp 1113 kern/vfs_bio.c numfreepages += btoc(bp->b_bufsize);
bp 1114 kern/vfs_bio.c numdirtypages += btoc(bp->b_bufsize);
bp 1115 kern/vfs_bio.c binstailfree(bp, &bufqueues[BQ_DIRTY]);
bp 1116 kern/vfs_bio.c CLR(bp->b_flags, B_BUSY);
bp 1120 kern/vfs_bio.c bawrite(bp);
bp 1138 kern/vfs_bio.c biowait(struct buf *bp)
bp 1143 kern/vfs_bio.c while (!ISSET(bp->b_flags, B_DONE))
bp 1144 kern/vfs_bio.c tsleep(bp, PRIBIO + 1, "biowait", 0);
bp 1148 kern/vfs_bio.c if (ISSET(bp->b_flags, B_EINTR)) {
bp 1149 kern/vfs_bio.c CLR(bp->b_flags, B_EINTR);
bp 1153 kern/vfs_bio.c if (ISSET(bp->b_flags, B_ERROR))
bp 1154 kern/vfs_bio.c return (bp->b_error ? bp->b_error : EIO);
bp 1178 kern/vfs_bio.c biodone(struct buf *bp)
bp 1182 kern/vfs_bio.c if (ISSET(bp->b_flags, B_DONE))
bp 1184 kern/vfs_bio.c SET(bp->b_flags, B_DONE); /* note that it's done */
bp 1186 kern/vfs_bio.c if (LIST_FIRST(&bp->b_dep) != NULL)
bp 1187 kern/vfs_bio.c buf_complete(bp);
bp 1189 kern/vfs_bio.c if (!ISSET(bp->b_flags, B_READ)) {
bp 1190 kern/vfs_bio.c CLR(bp->b_flags, B_WRITEINPROG);
bp 1191 kern/vfs_bio.c vwakeup(bp->b_vp);
bp 1194 kern/vfs_bio.c if (ISSET(bp->b_flags, B_CALL)) { /* if necessary, call out */
bp 1195 kern/vfs_bio.c CLR(bp->b_flags, B_CALL); /* but note callout done */
bp 1196 kern/vfs_bio.c (*bp->b_iodone)(bp);
bp 1198 kern/vfs_bio.c if (ISSET(bp->b_flags, B_ASYNC)) {/* if async, release it */
bp 1199 kern/vfs_bio.c brelse(bp);
bp 1201 kern/vfs_bio.c CLR(bp->b_flags, B_WANTED);
bp 1202 kern/vfs_bio.c wakeup(bp);
bp 1223 kern/vfs_bio.c struct buf *bp;
bp 1237 kern/vfs_bio.c TAILQ_FOREACH(bp, dp, b_freelist) {
bp 1238 kern/vfs_bio.c counts[bp->b_bufsize/PAGE_SIZE]++;
bp 1240 kern/vfs_bio.c pages += btoc(bp->b_bufsize);
bp 273 kern/vfs_cache.c char *bp;
bp 300 kern/vfs_cache.c bp = *bpp;
bp 301 kern/vfs_cache.c bp -= ncp->nc_nlen;
bp 302 kern/vfs_cache.c if (bp <= bufp) {
bp 306 kern/vfs_cache.c memcpy(bp, ncp->nc_name, ncp->nc_nlen);
bp 307 kern/vfs_cache.c *bpp = bp;
bp 62 kern/vfs_cluster.c cluster_write(struct buf *bp, struct cluster_info *ci, u_quad_t filesize)
bp 68 kern/vfs_cluster.c vp = bp->b_vp;
bp 69 kern/vfs_cluster.c lbn = bp->b_lblkno;
bp 76 kern/vfs_cluster.c (bp->b_blkno != ci->ci_lasta + btodb(bp->b_bcount))) {
bp 89 kern/vfs_cluster.c if (((u_quad_t)(lbn + 1)) * bp->b_bcount != filesize ||
bp 91 kern/vfs_cluster.c cluster_wbuild(vp, NULL, bp->b_bcount,
bp 97 kern/vfs_cluster.c buflist = cluster_collectbufs(vp, ci, bp);
bp 108 kern/vfs_cluster.c cluster_wbuild(vp, NULL, bp->b_bcount,
bp 119 kern/vfs_cluster.c ci->ci_lasta = bp->b_blkno;
bp 129 kern/vfs_cluster.c if ((u_quad_t)(lbn + 1) * (u_quad_t)bp->b_bcount != filesize &&
bp 130 kern/vfs_cluster.c (VOP_BMAP(vp, lbn, NULL, &bp->b_blkno, &maxclen) ||
bp 131 kern/vfs_cluster.c bp->b_blkno == -1)) {
bp 132 kern/vfs_cluster.c bawrite(bp);
bp 134 kern/vfs_cluster.c ci->ci_lasta = bp->b_blkno;
bp 142 kern/vfs_cluster.c bawrite(bp);
bp 145 kern/vfs_cluster.c bdwrite(bp);
bp 151 kern/vfs_cluster.c cluster_wbuild(vp, bp, bp->b_bcount, ci->ci_cstart,
bp 160 kern/vfs_cluster.c bdwrite(bp);
bp 162 kern/vfs_cluster.c ci->ci_lasta = bp->b_blkno;
bp 174 kern/vfs_cluster.c struct buf *bp;
bp 192 kern/vfs_cluster.c bp = getblk(vp, start_lbn, size, 0, 0);
bp 198 kern/vfs_cluster.c if ((bp->b_flags & B_DELWRI) == 0)
bp 199 kern/vfs_cluster.c brelse(bp);
bp 201 kern/vfs_cluster.c bawrite(bp);
bp 206 kern/vfs_cluster.c bp = getblk(vp, start_lbn, size, 0, 0);
bp 207 kern/vfs_cluster.c if (!(bp->b_flags & B_DELWRI)) {
bp 210 kern/vfs_cluster.c brelse(bp);
bp 216 kern/vfs_cluster.c bawrite(bp);
bp 177 kern/vfs_getcwd.c char *bp = *bpp;
bp 178 kern/vfs_getcwd.c bp -= dp->d_namlen;
bp 180 kern/vfs_getcwd.c if (bp <= bufp) {
bp 185 kern/vfs_getcwd.c bcopy(dp->d_name, bp, dp->d_namlen);
bp 187 kern/vfs_getcwd.c *bpp = bp;
bp 280 kern/vfs_getcwd.c char *bp = NULL;
bp 300 kern/vfs_getcwd.c bp = *bpp;
bp 303 kern/vfs_getcwd.c if (bp)
bp 304 kern/vfs_getcwd.c *(--bp) = '/';
bp 354 kern/vfs_getcwd.c error = vfs_getcwd_getcache(&lvp, &uvp, &bp, bufp);
bp 358 kern/vfs_getcwd.c error = vfs_getcwd_scandir(&lvp, &uvp, &bp, bufp, p);
bp 367 kern/vfs_getcwd.c if (bufp && (bp <= bufp)) {
bp 372 kern/vfs_getcwd.c if (bp)
bp 373 kern/vfs_getcwd.c *(--bp) = '/';
bp 384 kern/vfs_getcwd.c *bpp = bp;
bp 419 kern/vfs_getcwd.c char *path, *bp, *bend;
bp 428 kern/vfs_getcwd.c bp = &path[len];
bp 429 kern/vfs_getcwd.c bend = bp;
bp 430 kern/vfs_getcwd.c *(--bp) = '\0';
bp 437 kern/vfs_getcwd.c error = vfs_getcwd_common(p->p_fd->fd_cdir, NULL, &bp, path, len/2,
bp 443 kern/vfs_getcwd.c lenused = bend - bp;
bp 447 kern/vfs_getcwd.c error = copyout(bp, SCARG(uap, buf), lenused);
bp 85 kern/vfs_subr.c #define bufinsvn(bp, dp) LIST_INSERT_HEAD(dp, bp, b_vnbufs)
bp 86 kern/vfs_subr.c #define bufremvn(bp) { \
bp 87 kern/vfs_subr.c LIST_REMOVE(bp, b_vnbufs); \
bp 88 kern/vfs_subr.c LIST_NEXT(bp, b_vnbufs) = NOLIST; \
bp 1318 kern/vfs_subr.c char *bp = where, *savebp;
bp 1334 kern/vfs_subr.c savebp = bp;
bp 1346 kern/vfs_subr.c bp = savebp;
bp 1350 kern/vfs_subr.c if (bp + sizeof(struct e_vnode) > ewhere) {
bp 1351 kern/vfs_subr.c *sizep = bp - where;
bp 1356 kern/vfs_subr.c &((struct e_vnode *)bp)->vptr,
bp 1359 kern/vfs_subr.c &((struct e_vnode *)bp)->vnode,
bp 1364 kern/vfs_subr.c bp += sizeof(struct e_vnode);
bp 1371 kern/vfs_subr.c *sizep = bp - where;
bp 1683 kern/vfs_subr.c struct buf *bp;
bp 1694 kern/vfs_subr.c LIST_FOREACH(bp, &bufhead, b_list) {
bp 1695 kern/vfs_subr.c if ((bp->b_flags & (B_BUSY|B_INVAL|B_READ)) == B_BUSY)
bp 1702 kern/vfs_subr.c if (bp->b_flags & B_DELWRI) {
bp 1704 kern/vfs_subr.c bremfree(bp);
bp 1705 kern/vfs_subr.c bp->b_flags |= B_BUSY;
bp 1708 kern/vfs_subr.c bawrite(bp);
bp 1823 kern/vfs_subr.c struct buf *bp;
bp 1861 kern/vfs_subr.c for (bp = blist; bp; bp = nbp) {
bp 1862 kern/vfs_subr.c nbp = LIST_NEXT(bp, b_vnbufs);
bp 1863 kern/vfs_subr.c if (flags & V_SAVEMETA && bp->b_lblkno < 0)
bp 1865 kern/vfs_subr.c if (bp->b_flags & B_BUSY) {
bp 1866 kern/vfs_subr.c bp->b_flags |= B_WANTED;
bp 1867 kern/vfs_subr.c error = tsleep(bp, slpflag | (PRIBIO + 1),
bp 1875 kern/vfs_subr.c bremfree(bp);
bp 1876 kern/vfs_subr.c bp->b_flags |= B_BUSY;
bp 1882 kern/vfs_subr.c if ((bp->b_flags & B_DELWRI) && (flags & V_SAVE)) {
bp 1884 kern/vfs_subr.c (void) VOP_BWRITE(bp);
bp 1887 kern/vfs_subr.c bp->b_flags |= B_INVAL;
bp 1888 kern/vfs_subr.c brelse(bp);
bp 1901 kern/vfs_subr.c struct buf *bp, *nbp;
bp 1906 kern/vfs_subr.c for (bp = LIST_FIRST(&vp->v_dirtyblkhd);
bp 1907 kern/vfs_subr.c bp != LIST_END(&vp->v_dirtyblkhd); bp = nbp) {
bp 1908 kern/vfs_subr.c nbp = LIST_NEXT(bp, b_vnbufs);
bp 1909 kern/vfs_subr.c if ((bp->b_flags & B_BUSY))
bp 1911 kern/vfs_subr.c if ((bp->b_flags & B_DELWRI) == 0)
bp 1913 kern/vfs_subr.c bremfree(bp);
bp 1914 kern/vfs_subr.c bp->b_flags |= B_BUSY;
bp 1920 kern/vfs_subr.c if (bp->b_vp == vp || sync == 0)
bp 1921 kern/vfs_subr.c (void) bawrite(bp);
bp 1923 kern/vfs_subr.c (void) bwrite(bp);
bp 1947 kern/vfs_subr.c bgetvp(struct vnode *vp, struct buf *bp)
bp 1952 kern/vfs_subr.c if (bp->b_vp)
bp 1955 kern/vfs_subr.c bp->b_vp = vp;
bp 1957 kern/vfs_subr.c bp->b_dev = vp->v_rdev;
bp 1959 kern/vfs_subr.c bp->b_dev = NODEV;
bp 1963 kern/vfs_subr.c bufinsvn(bp, &vp->v_cleanblkhd);
bp 1972 kern/vfs_subr.c brelvp(struct buf *bp)
bp 1978 kern/vfs_subr.c if ((vp = bp->b_vp) == (struct vnode *) 0)
bp 1983 kern/vfs_subr.c if (LIST_NEXT(bp, b_vnbufs) != NOLIST)
bp 1984 kern/vfs_subr.c bufremvn(bp);
bp 1990 kern/vfs_subr.c bp->b_vp = (struct vnode *) 0;
bp 2019 kern/vfs_subr.c buf_replacevnode(struct buf *bp, struct vnode *newvp)
bp 2021 kern/vfs_subr.c struct vnode *oldvp = bp->b_vp;
bp 2026 kern/vfs_subr.c brelvp(bp);
bp 2028 kern/vfs_subr.c if ((bp->b_flags & (B_READ | B_DONE)) == 0) {
bp 2033 kern/vfs_subr.c bgetvp(newvp, bp);
bp 2034 kern/vfs_subr.c bufremvn(bp);
bp 2045 kern/vfs_subr.c reassignbuf(struct buf *bp)
bp 2049 kern/vfs_subr.c struct vnode *vp = bp->b_vp;
bp 2056 kern/vfs_subr.c if (LIST_NEXT(bp, b_vnbufs) != NOLIST)
bp 2057 kern/vfs_subr.c bufremvn(bp);
bp 2063 kern/vfs_subr.c if ((bp->b_flags & B_DELWRI) == 0) {
bp 2089 kern/vfs_subr.c bufinsvn(bp, listheadp);
bp 2176 kern/vfs_subr.c vfs_buf_print(struct buf *bp, int full, int (*pr)(const char *, ...))
bp 2181 kern/vfs_subr.c bp->b_vp, (int64_t)bp->b_lblkno, (int64_t)bp->b_blkno, bp->b_dev,
bp 2182 kern/vfs_subr.c bp->b_proc, bp->b_error, bp->b_flags, B_BITS);
bp 2186 kern/vfs_subr.c bp->b_bufsize, bp->b_bcount, (long)bp->b_resid, bp->b_synctime,
bp 2187 kern/vfs_subr.c bp->b_data, bp->b_saveaddr, LIST_FIRST(&bp->b_dep), bp->b_iodone);
bp 2190 kern/vfs_subr.c bp->b_dirtyoff, bp->b_dirtyend, bp->b_validoff, bp->b_validend);
bp 2194 kern/vfs_subr.c softdep_print(bp, full, pr);
bp 2218 kern/vfs_subr.c struct buf *bp;
bp 2221 kern/vfs_subr.c LIST_FOREACH(bp, &vp->v_cleanblkhd, b_vnbufs) {
bp 2222 kern/vfs_subr.c (*pr)(" bp %p\n", bp);
bp 2223 kern/vfs_subr.c vfs_buf_print(bp, full, pr);
bp 2227 kern/vfs_subr.c LIST_FOREACH(bp, &vp->v_dirtyblkhd, b_vnbufs) {
bp 2228 kern/vfs_subr.c (*pr)(" bp %p\n", bp);
bp 2229 kern/vfs_subr.c vfs_buf_print(bp, full, pr);
bp 1082 kern/vnode_if.c int VOP_STRATEGY(struct buf *bp)
bp 1086 kern/vnode_if.c a.a_bp = bp;
bp 1087 kern/vnode_if.c return (VCALL(bp->b_vp, VOFFSET(vop_strategy), &a));
bp 1105 kern/vnode_if.c int VOP_BWRITE(struct buf *bp)
bp 1109 kern/vnode_if.c a.a_bp = bp;
bp 1110 kern/vnode_if.c return (VCALL(bp->b_vp, VOFFSET(vop_bwrite), &a));
bp 71 lib/libsa/bootp.c struct bootp *bp;
bp 97 lib/libsa/bootp.c bp = &wbuf.wbootp;
bp 98 lib/libsa/bootp.c bzero(bp, sizeof(*bp));
bp 100 lib/libsa/bootp.c bp->bp_op = BOOTREQUEST;
bp 101 lib/libsa/bootp.c bp->bp_htype = HTYPE_ETHERNET; /* 10Mb Ethernet (48 bits) */
bp 102 lib/libsa/bootp.c bp->bp_hlen = 6;
bp 103 lib/libsa/bootp.c bp->bp_xid = htonl(d->xid);
bp 104 lib/libsa/bootp.c MACPY(d->myea, bp->bp_chaddr);
bp 105 lib/libsa/bootp.c bzero(bp->bp_file, sizeof(bp->bp_file));
bp 106 lib/libsa/bootp.c bcopy(vm_rfc1048, bp->bp_vend, sizeof(vm_rfc1048));
bp 114 lib/libsa/bootp.c bootpsend, bp, sizeof(*bp),
bp 125 lib/libsa/bootp.c struct bootp *bp;
bp 132 lib/libsa/bootp.c bp = pkt;
bp 133 lib/libsa/bootp.c bp->bp_secs = htons((u_short)(getsecs() - bot));
bp 148 lib/libsa/bootp.c struct bootp *bp;
bp 159 lib/libsa/bootp.c bp = (struct bootp *)pkt;
bp 164 lib/libsa/bootp.c (unsigned)bp, n);
bp 166 lib/libsa/bootp.c if (bp->bp_xid != htonl(d->xid)) {
bp 170 lib/libsa/bootp.c d->xid, ntohl(bp->bp_xid));
bp 182 lib/libsa/bootp.c myip = d->myip = bp->bp_yiaddr;
bp 199 lib/libsa/bootp.c if (bp->bp_siaddr.s_addr != 0)
bp 200 lib/libsa/bootp.c rootip = bp->bp_siaddr;
bp 201 lib/libsa/bootp.c if (bp->bp_file[0] != '\0') {
bp 202 lib/libsa/bootp.c strncpy(bootfile, (char *)bp->bp_file, sizeof(bootfile));
bp 207 lib/libsa/bootp.c if (bcmp(vm_cmu, bp->bp_vend, sizeof(vm_cmu)) == 0)
bp 208 lib/libsa/bootp.c vend_cmu(bp->bp_vend);
bp 209 lib/libsa/bootp.c else if (bcmp(vm_rfc1048, bp->bp_vend, sizeof(vm_rfc1048)) == 0)
bp 210 lib/libsa/bootp.c vend_rfc1048(bp->bp_vend, sizeof(bp->bp_vend));
bp 212 lib/libsa/bootp.c printf("bootprecv: unknown vendor 0x%lx\n", (long)bp->bp_vend);
bp 220 miscfs/specfs/spec_vnops.c struct buf *bp;
bp 269 miscfs/specfs/spec_vnops.c 1, NOCRED, &bp);
bp 271 miscfs/specfs/spec_vnops.c error = bread(vp, bn, bsize, NOCRED, &bp);
bp 273 miscfs/specfs/spec_vnops.c n = min(n, bsize - bp->b_resid);
bp 275 miscfs/specfs/spec_vnops.c brelse(bp);
bp 278 miscfs/specfs/spec_vnops.c error = uiomove((char *)bp->b_data + on, n, uio);
bp 279 miscfs/specfs/spec_vnops.c brelse(bp);
bp 309 miscfs/specfs/spec_vnops.c struct buf *bp;
bp 355 miscfs/specfs/spec_vnops.c error = bread(vp, bn, bsize, NOCRED, &bp);
bp 356 miscfs/specfs/spec_vnops.c n = min(n, bsize - bp->b_resid);
bp 358 miscfs/specfs/spec_vnops.c brelse(bp);
bp 361 miscfs/specfs/spec_vnops.c error = uiomove((char *)bp->b_data + on, n, uio);
bp 363 miscfs/specfs/spec_vnops.c bawrite(bp);
bp 365 miscfs/specfs/spec_vnops.c bdwrite(bp);
bp 443 miscfs/specfs/spec_vnops.c struct buf *bp;
bp 454 miscfs/specfs/spec_vnops.c for (bp = LIST_FIRST(&vp->v_dirtyblkhd);
bp 455 miscfs/specfs/spec_vnops.c bp != LIST_END(&vp->v_dirtyblkhd); bp = nbp) {
bp 456 miscfs/specfs/spec_vnops.c nbp = LIST_NEXT(bp, b_vnbufs);
bp 457 miscfs/specfs/spec_vnops.c if ((bp->b_flags & B_BUSY))
bp 459 miscfs/specfs/spec_vnops.c if ((bp->b_flags & B_DELWRI) == 0)
bp 461 miscfs/specfs/spec_vnops.c bremfree(bp);
bp 462 miscfs/specfs/spec_vnops.c bp->b_flags |= B_BUSY;
bp 464 miscfs/specfs/spec_vnops.c bawrite(bp);
bp 486 miscfs/specfs/spec_vnops.c struct buf *bp = ap->a_bp;
bp 487 miscfs/specfs/spec_vnops.c int maj = major(bp->b_dev);
bp 489 miscfs/specfs/spec_vnops.c if (LIST_FIRST(&bp->b_dep) != NULL)
bp 490 miscfs/specfs/spec_vnops.c buf_start(bp);
bp 492 miscfs/specfs/spec_vnops.c (*bdevsw[maj].d_strategy)(bp);
bp 184 msdosfs/msdosfs_denode.c struct buf *bp;
bp 301 msdosfs/msdosfs_denode.c error = readep(pmp, dirclust, diroffset, &bp, &direntptr);
bp 305 msdosfs/msdosfs_denode.c brelse(bp);
bp 342 msdosfs/msdosfs_denode.c struct buf *bp;
bp 358 msdosfs/msdosfs_denode.c error = readde(dep, &bp, &dirp);
bp 363 msdosfs/msdosfs_denode.c return (bwrite(bp));
bp 365 msdosfs/msdosfs_denode.c bdwrite(bp);
bp 389 msdosfs/msdosfs_denode.c struct buf *bp;
bp 450 msdosfs/msdosfs_denode.c NOCRED, &bp);
bp 454 msdosfs/msdosfs_denode.c NOCRED, &bp);
bp 457 msdosfs/msdosfs_denode.c brelse(bp);
bp 467 msdosfs/msdosfs_denode.c bzero(bp->b_data + boff, pmp->pm_bpcluster - boff);
bp 469 msdosfs/msdosfs_denode.c bwrite(bp);
bp 471 msdosfs/msdosfs_denode.c bdwrite(bp);
bp 151 msdosfs/msdosfs_fat.c struct buf *bp = NULL;
bp 224 msdosfs/msdosfs_fat.c if (bp)
bp 225 msdosfs/msdosfs_fat.c brelse(bp);
bp 226 msdosfs/msdosfs_fat.c error = bread(pmp->pm_devvp, bn, bsize, NOCRED, &bp);
bp 228 msdosfs/msdosfs_fat.c brelse(bp);
bp 235 msdosfs/msdosfs_fat.c if (bp)
bp 236 msdosfs/msdosfs_fat.c brelse(bp);
bp 240 msdosfs/msdosfs_fat.c cn = getulong(&bp->b_data[bo]);
bp 242 msdosfs/msdosfs_fat.c cn = getushort(&bp->b_data[bo]);
bp 258 msdosfs/msdosfs_fat.c if (bp)
bp 259 msdosfs/msdosfs_fat.c brelse(bp);
bp 271 msdosfs/msdosfs_fat.c if (bp)
bp 272 msdosfs/msdosfs_fat.c brelse(bp);
bp 335 msdosfs/msdosfs_fat.c updatefats(pmp, bp, fatbn)
bp 337 msdosfs/msdosfs_fat.c struct buf *bp;
bp 344 msdosfs/msdosfs_fat.c printf("updatefats(pmp %08, buf %x, fatbn %ld)\n", pmp, bp, fatbn);
bp 400 msdosfs/msdosfs_fat.c bpn = getblk(pmp->pm_devvp, fatbn, bp->b_bcount, 0, 0);
bp 401 msdosfs/msdosfs_fat.c bcopy(bp->b_data, bpn->b_data, bp->b_bcount);
bp 413 msdosfs/msdosfs_fat.c bwrite(bp);
bp 415 msdosfs/msdosfs_fat.c bdwrite(bp);
bp 515 msdosfs/msdosfs_fat.c struct buf *bp;
bp 549 msdosfs/msdosfs_fat.c if ((error = bread(pmp->pm_devvp, bn, bsize, NOCRED, &bp)) != 0) {
bp 550 msdosfs/msdosfs_fat.c brelse(bp);
bp 556 msdosfs/msdosfs_fat.c readcn = getulong(&bp->b_data[bo]);
bp 558 msdosfs/msdosfs_fat.c readcn = getushort(&bp->b_data[bo]);
bp 570 msdosfs/msdosfs_fat.c readcn = getushort(&bp->b_data[bo]);
bp 578 msdosfs/msdosfs_fat.c putushort(&bp->b_data[bo], readcn);
bp 581 msdosfs/msdosfs_fat.c putushort(&bp->b_data[bo], newcontents);
bp 588 msdosfs/msdosfs_fat.c readcn = getulong(&bp->b_data[bo]);
bp 591 msdosfs/msdosfs_fat.c putulong(&bp->b_data[bo], readcn);
bp 594 msdosfs/msdosfs_fat.c updatefats(pmp, bp, bn);
bp 595 msdosfs/msdosfs_fat.c bp = NULL;
bp 598 msdosfs/msdosfs_fat.c if (bp)
bp 599 msdosfs/msdosfs_fat.c brelse(bp);
bp 620 msdosfs/msdosfs_fat.c struct buf *bp;
bp 635 msdosfs/msdosfs_fat.c error = bread(pmp->pm_devvp, bn, bsize, NOCRED, &bp);
bp 637 msdosfs/msdosfs_fat.c brelse(bp);
bp 645 msdosfs/msdosfs_fat.c readcn = getushort(&bp->b_data[bo]);
bp 653 msdosfs/msdosfs_fat.c putushort(&bp->b_data[bo], readcn);
bp 659 msdosfs/msdosfs_fat.c putushort(&bp->b_data[bo], newc);
bp 663 msdosfs/msdosfs_fat.c readcn = getulong(&bp->b_data[bo]);
bp 666 msdosfs/msdosfs_fat.c putulong(&bp->b_data[bo], readcn);
bp 673 msdosfs/msdosfs_fat.c updatefats(pmp, bp, bn);
bp 866 msdosfs/msdosfs_fat.c struct buf *bp = NULL;
bp 874 msdosfs/msdosfs_fat.c if (bp)
bp 875 msdosfs/msdosfs_fat.c updatefats(pmp, bp, lbn);
bp 876 msdosfs/msdosfs_fat.c error = bread(pmp->pm_devvp, bn, bsize, NOCRED, &bp);
bp 878 msdosfs/msdosfs_fat.c brelse(bp);
bp 886 msdosfs/msdosfs_fat.c readcn = getushort(&bp->b_data[bo]);
bp 896 msdosfs/msdosfs_fat.c putushort(&bp->b_data[bo], readcn);
bp 899 msdosfs/msdosfs_fat.c cluster = getushort(&bp->b_data[bo]);
bp 900 msdosfs/msdosfs_fat.c putushort(&bp->b_data[bo], MSDOSFSFREE);
bp 903 msdosfs/msdosfs_fat.c cluster = getulong(&bp->b_data[bo]);
bp 904 msdosfs/msdosfs_fat.c putulong(&bp->b_data[bo],
bp 912 msdosfs/msdosfs_fat.c if (bp)
bp 913 msdosfs/msdosfs_fat.c updatefats(pmp, bp, bn);
bp 925 msdosfs/msdosfs_fat.c struct buf *bp = NULL;
bp 946 msdosfs/msdosfs_fat.c if (!bo || !bp) {
bp 948 msdosfs/msdosfs_fat.c if (bp)
bp 949 msdosfs/msdosfs_fat.c brelse(bp);
bp 951 msdosfs/msdosfs_fat.c error = bread(pmp->pm_devvp, bn, bsize, NOCRED, &bp);
bp 953 msdosfs/msdosfs_fat.c brelse(bp);
bp 958 msdosfs/msdosfs_fat.c readcn = getulong(&bp->b_data[bo]);
bp 960 msdosfs/msdosfs_fat.c readcn = getushort(&bp->b_data[bo]);
bp 968 msdosfs/msdosfs_fat.c brelse(bp);
bp 999 msdosfs/msdosfs_fat.c struct buf *bp;
bp 1079 msdosfs/msdosfs_fat.c bp = getblk(pmp->pm_devvp, cntobn(pmp, cn++),
bp 1082 msdosfs/msdosfs_fat.c bp = getblk(DETOV(dep), de_cn2bn(pmp, frcn++),
bp 1088 msdosfs/msdosfs_fat.c de_bn2cn(pmp, bp->b_lblkno),
bp 1089 msdosfs/msdosfs_fat.c &bp->b_blkno, 0, 0))
bp 1090 msdosfs/msdosfs_fat.c bp->b_blkno = -1;
bp 1091 msdosfs/msdosfs_fat.c if (bp->b_blkno == -1)
bp 1094 msdosfs/msdosfs_fat.c clrbuf(bp);
bp 1096 msdosfs/msdosfs_fat.c *bpp = bp;
bp 1099 msdosfs/msdosfs_fat.c bdwrite(bp);
bp 106 msdosfs/msdosfs_lookup.c struct buf *bp = 0;
bp 235 msdosfs/msdosfs_lookup.c error = bread(pmp->pm_devvp, bn, blsize, NOCRED, &bp);
bp 237 msdosfs/msdosfs_lookup.c brelse(bp);
bp 243 msdosfs/msdosfs_lookup.c dep = (struct direntry *)(bp->b_data + blkoff);
bp 265 msdosfs/msdosfs_lookup.c brelse(bp);
bp 340 msdosfs/msdosfs_lookup.c brelse(bp);
bp 448 msdosfs/msdosfs_lookup.c brelse(bp);
bp 606 msdosfs/msdosfs_lookup.c struct buf *bp;
bp 650 msdosfs/msdosfs_lookup.c if ((error = bread(pmp->pm_devvp, bn, blsize, NOCRED, &bp)) != 0) {
bp 651 msdosfs/msdosfs_lookup.c brelse(bp);
bp 654 msdosfs/msdosfs_lookup.c ndep = bptoep(pmp, bp, ddep->de_fndoffset);
bp 669 msdosfs/msdosfs_lookup.c if ((error = bwrite(bp)) != 0)
bp 681 msdosfs/msdosfs_lookup.c NOCRED, &bp);
bp 683 msdosfs/msdosfs_lookup.c brelse(bp);
bp 686 msdosfs/msdosfs_lookup.c ndep = bptoep(pmp, bp, ddep->de_fndoffset);
bp 696 msdosfs/msdosfs_lookup.c if ((error = bwrite(bp)) != 0)
bp 730 msdosfs/msdosfs_lookup.c struct buf *bp;
bp 745 msdosfs/msdosfs_lookup.c error = bread(pmp->pm_devvp, bn, blsize, NOCRED, &bp);
bp 747 msdosfs/msdosfs_lookup.c brelse(bp);
bp 750 msdosfs/msdosfs_lookup.c for (dentp = (struct direntry *)bp->b_data;
bp 751 msdosfs/msdosfs_lookup.c (char *)dentp < bp->b_data + blsize;
bp 763 msdosfs/msdosfs_lookup.c brelse(bp);
bp 772 msdosfs/msdosfs_lookup.c brelse(bp);
bp 781 msdosfs/msdosfs_lookup.c brelse(bp);
bp 808 msdosfs/msdosfs_lookup.c struct buf *bp = NULL;
bp 838 msdosfs/msdosfs_lookup.c pmp->pm_bpcluster, NOCRED, &bp);
bp 842 msdosfs/msdosfs_lookup.c ep = (struct direntry *) bp->b_data + 1;
bp 867 msdosfs/msdosfs_lookup.c brelse(bp);
bp 868 msdosfs/msdosfs_lookup.c bp = NULL;
bp 874 msdosfs/msdosfs_lookup.c if (bp)
bp 875 msdosfs/msdosfs_lookup.c brelse(bp);
bp 947 msdosfs/msdosfs_lookup.c struct buf *bp;
bp 965 msdosfs/msdosfs_lookup.c error = bread(pmp->pm_devvp, bn, blsize, NOCRED, &bp);
bp 967 msdosfs/msdosfs_lookup.c brelse(bp);
bp 970 msdosfs/msdosfs_lookup.c ep = bptoep(pmp, bp, offset);
bp 978 msdosfs/msdosfs_lookup.c brelse(bp);
bp 996 msdosfs/msdosfs_lookup.c if ((error = bwrite(bp)) != 0)
bp 1019 msdosfs/msdosfs_lookup.c struct buf *bp;
bp 1038 msdosfs/msdosfs_lookup.c error = bread(pmp->pm_devvp, bn, blsize, NOCRED, &bp);
bp 1040 msdosfs/msdosfs_lookup.c brelse(bp);
bp 1043 msdosfs/msdosfs_lookup.c for (dentp = (struct direntry *)bp->b_data;
bp 1044 msdosfs/msdosfs_lookup.c (char *)dentp < bp->b_data + blsize;
bp 1050 msdosfs/msdosfs_lookup.c brelse(bp);
bp 1063 msdosfs/msdosfs_lookup.c brelse(bp);
bp 1082 msdosfs/msdosfs_lookup.c struct buf *bp;
bp 1091 msdosfs/msdosfs_lookup.c if (bread(pmp->pm_devvp, bn, blsize, NOCRED, &bp)) {
bp 1092 msdosfs/msdosfs_lookup.c brelse(bp);
bp 1095 msdosfs/msdosfs_lookup.c for (dentp = (struct direntry *)bp->b_data;
bp 1096 msdosfs/msdosfs_lookup.c (char *)dentp < bp->b_data + blsize;
bp 1102 msdosfs/msdosfs_lookup.c brelse(bp);
bp 1113 msdosfs/msdosfs_lookup.c brelse(bp);
bp 1117 msdosfs/msdosfs_lookup.c brelse(bp);
bp 258 msdosfs/msdosfs_vfsops.c struct buf *bp;
bp 290 msdosfs/msdosfs_vfsops.c bp = NULL; /* both used in error_exit */
bp 297 msdosfs/msdosfs_vfsops.c if ((error = bread(devvp, 0, 2048, NOCRED, &bp)) != 0)
bp 299 msdosfs/msdosfs_vfsops.c bp->b_flags |= B_AGE;
bp 300 msdosfs/msdosfs_vfsops.c bsp = (union bootsector *)bp->b_data;
bp 465 msdosfs/msdosfs_vfsops.c brelse(bp);
bp 466 msdosfs/msdosfs_vfsops.c bp = NULL;
bp 475 msdosfs/msdosfs_vfsops.c NOCRED, &bp)) != 0)
bp 477 msdosfs/msdosfs_vfsops.c fp = (struct fsinfo *)bp->b_data;
bp 485 msdosfs/msdosfs_vfsops.c brelse(bp);
bp 486 msdosfs/msdosfs_vfsops.c bp = NULL;
bp 556 msdosfs/msdosfs_vfsops.c if (bp)
bp 557 msdosfs/msdosfs_vfsops.c brelse(bp);
bp 438 msdosfs/msdosfs_vnops.c struct buf *bp;
bp 482 msdosfs/msdosfs_vnops.c error = bread(pmp->pm_devvp, lbn, blsize, NOCRED, &bp);
bp 490 msdosfs/msdosfs_vnops.c &pmp->pm_bpcluster, 1, NOCRED, &bp);
bp 493 msdosfs/msdosfs_vnops.c pmp->pm_bpcluster, NOCRED, &bp);
bp 496 msdosfs/msdosfs_vnops.c n = min(n, pmp->pm_bpcluster - bp->b_resid);
bp 498 msdosfs/msdosfs_vnops.c brelse(bp);
bp 501 msdosfs/msdosfs_vnops.c error = uiomove(bp->b_data + on, (int) n, uio);
bp 502 msdosfs/msdosfs_vnops.c brelse(bp);
bp 524 msdosfs/msdosfs_vnops.c struct buf *bp;
bp 619 msdosfs/msdosfs_vnops.c bp = getblk(thisvp, bn, pmp->pm_bpcluster, 0, 0);
bp 620 msdosfs/msdosfs_vnops.c clrbuf(bp);
bp 625 msdosfs/msdosfs_vnops.c if (bp->b_blkno == bp->b_lblkno) {
bp 627 msdosfs/msdosfs_vnops.c de_bn2cn(pmp, bp->b_lblkno),
bp 628 msdosfs/msdosfs_vnops.c &bp->b_blkno, 0, 0);
bp 630 msdosfs/msdosfs_vnops.c bp->b_blkno = -1;
bp 632 msdosfs/msdosfs_vnops.c if (bp->b_blkno == -1) {
bp 633 msdosfs/msdosfs_vnops.c brelse(bp);
bp 643 msdosfs/msdosfs_vnops.c NOCRED, &bp);
bp 645 msdosfs/msdosfs_vnops.c brelse(bp);
bp 665 msdosfs/msdosfs_vnops.c error = uiomove(bp->b_data + croffset, n, uio);
bp 675 msdosfs/msdosfs_vnops.c (void) bwrite(bp);
bp 677 msdosfs/msdosfs_vnops.c bawrite(bp);
bp 679 msdosfs/msdosfs_vnops.c bdwrite(bp);
bp 869 msdosfs/msdosfs_vnops.c struct buf *bp;
bp 1120 msdosfs/msdosfs_vnops.c NOCRED, &bp);
bp 1123 msdosfs/msdosfs_vnops.c brelse(bp);
bp 1126 msdosfs/msdosfs_vnops.c dotdotp = (struct direntry *)bp->b_data;
bp 1136 msdosfs/msdosfs_vnops.c if ((error = bwrite(bp)) != 0) {
bp 1198 msdosfs/msdosfs_vnops.c struct buf *bp;
bp 1232 msdosfs/msdosfs_vnops.c bp = getblk(pmp->pm_devvp, bn, pmp->pm_bpcluster, 0, 0);
bp 1233 msdosfs/msdosfs_vnops.c bzero(bp->b_data, pmp->pm_bpcluster);
bp 1234 msdosfs/msdosfs_vnops.c bcopy(&dosdirtemplate, bp->b_data, sizeof dosdirtemplate);
bp 1235 msdosfs/msdosfs_vnops.c denp = (struct direntry *)bp->b_data;
bp 1258 msdosfs/msdosfs_vnops.c if ((error = bwrite(bp)) != 0)
bp 1388 msdosfs/msdosfs_vnops.c struct buf *bp;
bp 1502 msdosfs/msdosfs_vnops.c error = bread(pmp->pm_devvp, bn, blsize, NOCRED, &bp);
bp 1504 msdosfs/msdosfs_vnops.c brelse(bp);
bp 1507 msdosfs/msdosfs_vnops.c n = min(n, blsize - bp->b_resid);
bp 1513 msdosfs/msdosfs_vnops.c for (dentp = (struct direntry *)(bp->b_data + on);
bp 1514 msdosfs/msdosfs_vnops.c (char *)dentp < bp->b_data + on + n;
bp 1524 msdosfs/msdosfs_vnops.c brelse(bp);
bp 1586 msdosfs/msdosfs_vnops.c (struct direntry *)bp->b_data;
bp 1604 msdosfs/msdosfs_vnops.c brelse(bp);
bp 1614 msdosfs/msdosfs_vnops.c brelse(bp);
bp 1620 msdosfs/msdosfs_vnops.c brelse(bp);
bp 1625 msdosfs/msdosfs_vnops.c brelse(bp);
bp 1722 msdosfs/msdosfs_vnops.c struct buf *bp = ap->a_bp;
bp 1723 msdosfs/msdosfs_vnops.c struct denode *dep = VTODE(bp->b_vp);
bp 1728 msdosfs/msdosfs_vnops.c if (bp->b_vp->v_type == VBLK || bp->b_vp->v_type == VCHR)
bp 1736 msdosfs/msdosfs_vnops.c if (bp->b_blkno == bp->b_lblkno) {
bp 1737 msdosfs/msdosfs_vnops.c error = pcbmap(dep, de_bn2cn(dep->de_pmp, bp->b_lblkno),
bp 1738 msdosfs/msdosfs_vnops.c &bp->b_blkno, 0, 0);
bp 1740 msdosfs/msdosfs_vnops.c bp->b_blkno = -1;
bp 1741 msdosfs/msdosfs_vnops.c if (bp->b_blkno == -1)
bp 1742 msdosfs/msdosfs_vnops.c clrbuf(bp);
bp 1744 msdosfs/msdosfs_vnops.c if (bp->b_blkno == -1) {
bp 1746 msdosfs/msdosfs_vnops.c biodone(bp);
bp 1757 msdosfs/msdosfs_vnops.c bp->b_dev = vp->v_rdev;
bp 133 msdosfs/msdosfsmount.h #define bptoep(pmp, bp, dirofs) \
bp 134 msdosfs/msdosfsmount.h ((struct direntry *)(((bp)->b_data) \
bp 235 net/bpf.c bpf_attachd(struct bpf_d *d, struct bpf_if *bp)
bp 242 net/bpf.c d->bd_bif = bp;
bp 243 net/bpf.c d->bd_next = bp->bif_dlist;
bp 244 net/bpf.c bp->bif_dlist = d;
bp 246 net/bpf.c *bp->bif_driverp = bp;
bp 256 net/bpf.c struct bpf_if *bp;
bp 258 net/bpf.c bp = d->bd_bif;
bp 267 net/bpf.c error = ifpromisc(bp->bif_ifp, 0);
bp 277 net/bpf.c p = &bp->bif_dlist;
bp 284 net/bpf.c if (bp->bif_dlist == 0)
bp 944 net/bpf.c struct bpf_if *bp, *candidate = NULL;
bp 950 net/bpf.c for (bp = bpf_iflist; bp != 0; bp = bp->bif_next) {
bp 951 net/bpf.c struct ifnet *ifp = bp->bif_ifp;
bp 960 net/bpf.c if (candidate == NULL || candidate->bif_dlt > bp->bif_dlt)
bp 961 net/bpf.c candidate = bp;
bp 1097 net/bpf.c struct bpf_if *bp;
bp 1107 net/bpf.c bp = (struct bpf_if *)arg;
bp 1108 net/bpf.c for (d = bp->bif_dlist; d != 0; d = d->bd_next) {
bp 1154 net/bpf.c struct bpf_if *bp = (struct bpf_if *)arg;
bp 1166 net/bpf.c for (d = bp->bif_dlist; d != 0; d = d->bd_next) {
bp 1370 net/bpf.c struct bpf_if *bp;
bp 1371 net/bpf.c bp = (struct bpf_if *)malloc(sizeof(*bp), M_DEVBUF, M_DONTWAIT);
bp 1373 net/bpf.c if (bp == 0)
bp 1376 net/bpf.c bp->bif_dlist = 0;
bp 1377 net/bpf.c bp->bif_driverp = (struct bpf_if **)driverp;
bp 1378 net/bpf.c bp->bif_ifp = ifp;
bp 1379 net/bpf.c bp->bif_dlt = dlt;
bp 1381 net/bpf.c bp->bif_next = bpf_iflist;
bp 1382 net/bpf.c bpf_iflist = bp;
bp 1384 net/bpf.c *bp->bif_driverp = NULL;
bp 1392 net/bpf.c bp->bif_hdrlen = BPF_WORDALIGN(hdrlen + SIZEOF_BPF_HDR) - hdrlen;
bp 1399 net/bpf.c struct bpf_if *bp, *nbp, **pbp = &bpf_iflist;
bp 1403 net/bpf.c for (bp = bpf_iflist; bp; bp = nbp) {
bp 1404 net/bpf.c nbp= bp->bif_next;
bp 1405 net/bpf.c if (bp->bif_ifp == ifp) {
bp 1413 net/bpf.c for (bd = bp->bif_dlist; bd; bd = bp->bif_dlist) {
bp 1428 net/bpf.c free(bp, M_DEVBUF);
bp 1430 net/bpf.c pbp = &bp->bif_next;
bp 1511 net/bpf.c struct bpf_if *bp;
bp 1516 net/bpf.c for (bp = bpf_iflist; bp != NULL; bp = bp->bif_next) {
bp 1517 net/bpf.c if (bp->bif_ifp != ifp)
bp 1522 net/bpf.c error = copyout(&bp->bif_dlt,
bp 1542 net/bpf.c struct bpf_if *bp;
bp 1547 net/bpf.c for (bp = bpf_iflist; bp != NULL; bp = bp->bif_next) {
bp 1548 net/bpf.c if (bp->bif_ifp == ifp && bp->bif_dlt == dlt)
bp 1551 net/bpf.c if (bp == NULL)
bp 1555 net/bpf.c bpf_attachd(d, bp);
bp 301 net/bridgestp.c bstp_transmit(struct bstp_state *bs, struct bstp_port *bp)
bp 303 net/bridgestp.c if ((bs->bs_ifflags & IFF_RUNNING) == 0 || bp == NULL)
bp 310 net/bridgestp.c if (bp->bp_hello_timer.active == 0) {
bp 312 net/bridgestp.c bstp_hello_timer_expiry(bs, bp);
bp 315 net/bridgestp.c if (bp->bp_txcount > bs->bs_txholdcount)
bp 319 net/bridgestp.c if (bp->bp_protover == BSTP_PROTO_RSTP) {
bp 320 net/bridgestp.c bstp_transmit_bpdu(bs, bp);
bp 321 net/bridgestp.c bp->bp_tc_ack = 0;
bp 323 net/bridgestp.c switch (bp->bp_role) {
bp 325 net/bridgestp.c bstp_transmit_bpdu(bs, bp);
bp 326 net/bridgestp.c bp->bp_tc_ack = 0;
bp 330 net/bridgestp.c bstp_transmit_tcn(bs, bp);
bp 334 net/bridgestp.c bstp_timer_start(&bp->bp_hello_timer, bp->bp_desg_htime);
bp 335 net/bridgestp.c bp->bp_flags &= ~BSTP_PORT_NEWINFO;
bp 339 net/bridgestp.c bstp_transmit_bpdu(struct bstp_state *bs, struct bstp_port *bp)
bp 343 net/bridgestp.c bpdu.cbu_rootpri = htons(bp->bp_desg_pv.pv_root_id >> 48);
bp 344 net/bridgestp.c PV2ADDR(bp->bp_desg_pv.pv_root_id, bpdu.cbu_rootaddr);
bp 346 net/bridgestp.c bpdu.cbu_rootpathcost = htonl(bp->bp_desg_pv.pv_cost);
bp 348 net/bridgestp.c bpdu.cbu_bridgepri = htons(bp->bp_desg_pv.pv_dbridge_id >> 48);
bp 349 net/bridgestp.c PV2ADDR(bp->bp_desg_pv.pv_dbridge_id, bpdu.cbu_bridgeaddr);
bp 351 net/bridgestp.c bpdu.cbu_portid = htons(bp->bp_port_id);
bp 352 net/bridgestp.c bpdu.cbu_messageage = htons(bp->bp_desg_msg_age);
bp 353 net/bridgestp.c bpdu.cbu_maxage = htons(bp->bp_desg_max_age);
bp 354 net/bridgestp.c bpdu.cbu_hellotime = htons(bp->bp_desg_htime);
bp 355 net/bridgestp.c bpdu.cbu_forwarddelay = htons(bp->bp_desg_fdelay);
bp 357 net/bridgestp.c bpdu.cbu_flags = bstp_pdu_flags(bp);
bp 359 net/bridgestp.c switch (bp->bp_protover) {
bp 368 net/bridgestp.c bstp_send_bpdu(bs, bp, &bpdu);
bp 372 net/bridgestp.c bstp_transmit_tcn(struct bstp_state *bs, struct bstp_port *bp)
bp 375 net/bridgestp.c struct ifnet *ifp = bp->bp_ifp;
bp 403 net/bridgestp.c bp->bp_txcount++;
bp 411 net/bridgestp.c bstp_decode_bpdu(struct bstp_port *bp, struct bstp_cbpdu *cpdu,
bp 440 net/bridgestp.c cu->cu_pv.pv_port_id = bp->bp_port_id;
bp 483 net/bridgestp.c bstp_send_bpdu(struct bstp_state *bs, struct bstp_port *bp,
bp 486 net/bridgestp.c struct ifnet *ifp = bp->bp_ifp;
bp 536 net/bridgestp.c bp->bp_txcount++;
bp 545 net/bridgestp.c bstp_pdu_flags(struct bstp_port *bp)
bp 549 net/bridgestp.c if (bp->bp_proposing && bp->bp_state != BSTP_IFSTATE_FORWARDING)
bp 552 net/bridgestp.c if (bp->bp_agree)
bp 555 net/bridgestp.c if (bp->bp_tc_timer.active)
bp 558 net/bridgestp.c if (bp->bp_tc_ack)
bp 561 net/bridgestp.c switch (bp->bp_state) {
bp 570 net/bridgestp.c switch (bp->bp_role) {
bp 584 net/bridgestp.c switch (bp->bp_protover) {
bp 596 net/bridgestp.c bstp_input(struct bstp_state *bs, struct bstp_port *bp,
bp 602 net/bridgestp.c if (bs == NULL || bp == NULL || bp->bp_active == 0)
bp 628 net/bridgestp.c if (tpdu.tbu_protover != bp->bp_protover) {
bp 633 net/bridgestp.c if (bp->bp_flags & BSTP_PORT_CANMIGRATE)
bp 634 net/bridgestp.c bstp_set_port_proto(bp, tpdu.tbu_protover);
bp 640 net/bridgestp.c bp->bp_operedge = 0;
bp 641 net/bridgestp.c bstp_timer_start(&bp->bp_edge_delay_timer,
bp 646 net/bridgestp.c bstp_received_stp(bs, bp, &m, &tpdu);
bp 649 net/bridgestp.c bstp_received_rstp(bs, bp, &m, &tpdu);
bp 659 net/bridgestp.c bstp_received_stp(struct bstp_state *bs, struct bstp_port *bp,
bp 663 net/bridgestp.c struct bstp_config_unit *cu = &bp->bp_msg_cu;
bp 669 net/bridgestp.c bstp_received_tcn(bs, bp, &tu);
bp 677 net/bridgestp.c bstp_decode_bpdu(bp, &cpdu, cu);
bp 678 net/bridgestp.c bstp_received_bpdu(bs, bp, cu);
bp 684 net/bridgestp.c bstp_received_rstp(struct bstp_state *bs, struct bstp_port *bp,
bp 688 net/bridgestp.c struct bstp_config_unit *cu = &bp->bp_msg_cu;
bp 698 net/bridgestp.c bstp_decode_bpdu(bp, &cpdu, cu);
bp 699 net/bridgestp.c bstp_received_bpdu(bs, bp, cu);
bp 703 net/bridgestp.c bstp_received_tcn(struct bstp_state *bs, struct bstp_port *bp,
bp 706 net/bridgestp.c bp->bp_rcvdtcn = 1;
bp 707 net/bridgestp.c bstp_update_tc(bp);
bp 711 net/bridgestp.c bstp_received_bpdu(struct bstp_state *bs, struct bstp_port *bp,
bp 717 net/bridgestp.c switch (bp->bp_infois) {
bp 723 net/bridgestp.c type = bstp_pdu_rcvtype(bp, cu);
bp 728 net/bridgestp.c bp->bp_agreed = 0;
bp 729 net/bridgestp.c bp->bp_proposing = 0;
bp 732 net/bridgestp.c bp->bp_proposed = 1;
bp 734 net/bridgestp.c bp->bp_rcvdtc = 1;
bp 736 net/bridgestp.c bp->bp_rcvdtca = 1;
bp 738 net/bridgestp.c if (bp->bp_agree &&
bp 739 net/bridgestp.c !bstp_pdu_bettersame(bp, BSTP_INFO_RECIEVED))
bp 740 net/bridgestp.c bp->bp_agree = 0;
bp 743 net/bridgestp.c bp->bp_port_pv = cu->cu_pv;
bp 744 net/bridgestp.c bp->bp_port_msg_age = cu->cu_message_age;
bp 745 net/bridgestp.c bp->bp_port_max_age = cu->cu_max_age;
bp 746 net/bridgestp.c bp->bp_port_fdelay = cu->cu_forward_delay;
bp 747 net/bridgestp.c bp->bp_port_htime =
bp 752 net/bridgestp.c bstp_set_timer_msgage(bp);
bp 754 net/bridgestp.c bp->bp_infois = BSTP_INFO_RECIEVED;
bp 760 net/bridgestp.c bp->bp_proposed = 1;
bp 762 net/bridgestp.c bp->bp_rcvdtc = 1;
bp 764 net/bridgestp.c bp->bp_rcvdtca = 1;
bp 767 net/bridgestp.c bstp_set_timer_msgage(bp);
bp 772 net/bridgestp.c bp->bp_agreed = 1;
bp 773 net/bridgestp.c bp->bp_proposing = 0;
bp 782 net/bridgestp.c if (cu->cu_agree && bp->bp_ptp_link) {
bp 783 net/bridgestp.c bp->bp_agreed = 1;
bp 784 net/bridgestp.c bp->bp_proposing = 0;
bp 786 net/bridgestp.c bp->bp_agreed = 0;
bp 789 net/bridgestp.c bp->bp_rcvdtc = 1;
bp 791 net/bridgestp.c bp->bp_rcvdtca = 1;
bp 799 net/bridgestp.c bstp_update_state(bs, bp);
bp 803 net/bridgestp.c bstp_pdu_rcvtype(struct bstp_port *bp, struct bstp_config_unit *cu)
bp 812 net/bridgestp.c if (bstp_info_superior(&bp->bp_port_pv, &cu->cu_pv))
bp 815 net/bridgestp.c else if (bstp_info_cmp(&bp->bp_port_pv, &cu->cu_pv) ==
bp 817 net/bridgestp.c if (bp->bp_port_msg_age != cu->cu_message_age ||
bp 818 net/bridgestp.c bp->bp_port_max_age != cu->cu_max_age ||
bp 819 net/bridgestp.c bp->bp_port_fdelay != cu->cu_forward_delay ||
bp 820 net/bridgestp.c bp->bp_port_htime != cu->cu_hello_time)
bp 835 net/bridgestp.c if (bstp_info_cmp(&bp->bp_port_pv, &cu->cu_pv) <= INFO_SAME)
bp 848 net/bridgestp.c bstp_pdu_bettersame(struct bstp_port *bp, int newinfo)
bp 851 net/bridgestp.c bp->bp_infois == BSTP_INFO_RECIEVED &&
bp 852 net/bridgestp.c bstp_info_cmp(&bp->bp_port_pv, &bp->bp_msg_cu.cu_pv) >= INFO_SAME)
bp 856 net/bridgestp.c bp->bp_infois == BSTP_INFO_MINE &&
bp 857 net/bridgestp.c bstp_info_cmp(&bp->bp_port_pv, &bp->bp_desg_pv) >= INFO_SAME)
bp 910 net/bridgestp.c struct bstp_port *bp, *rbp = NULL;
bp 922 net/bridgestp.c LIST_FOREACH(bp, &bs->bs_bplist, bp_next) {
bp 923 net/bridgestp.c if (bp->bp_infois != BSTP_INFO_RECIEVED)
bp 926 net/bridgestp.c pv = bp->bp_port_pv;
bp 927 net/bridgestp.c pv.pv_cost += bp->bp_path_cost;
bp 939 net/bridgestp.c bs->bs_root_msg_age = bp->bp_port_msg_age +
bp 941 net/bridgestp.c bs->bs_root_max_age = bp->bp_port_max_age;
bp 942 net/bridgestp.c bs->bs_root_fdelay = bp->bp_port_fdelay;
bp 943 net/bridgestp.c bs->bs_root_htime = bp->bp_port_htime;
bp 944 net/bridgestp.c rbp = bp;
bp 948 net/bridgestp.c LIST_FOREACH(bp, &bs->bs_bplist, bp_next) {
bp 950 net/bridgestp.c bp->bp_desg_pv.pv_root_id = bs->bs_root_pv.pv_root_id;
bp 951 net/bridgestp.c bp->bp_desg_pv.pv_cost = bs->bs_root_pv.pv_cost;
bp 952 net/bridgestp.c bp->bp_desg_pv.pv_dbridge_id = bs->bs_bridge_pv.pv_dbridge_id;
bp 953 net/bridgestp.c bp->bp_desg_pv.pv_dport_id = bp->bp_port_id;
bp 954 net/bridgestp.c bp->bp_desg_pv.pv_port_id = bp->bp_port_id;
bp 957 net/bridgestp.c bp->bp_desg_msg_age = bs->bs_root_msg_age;
bp 958 net/bridgestp.c bp->bp_desg_max_age = bs->bs_root_max_age;
bp 959 net/bridgestp.c bp->bp_desg_fdelay = bs->bs_root_fdelay;
bp 960 net/bridgestp.c bp->bp_desg_htime = bs->bs_bridge_htime;
bp 963 net/bridgestp.c switch (bp->bp_infois) {
bp 965 net/bridgestp.c bstp_set_port_role(bp, BSTP_ROLE_DISABLED);
bp 969 net/bridgestp.c bstp_set_port_role(bp, BSTP_ROLE_DESIGNATED);
bp 970 net/bridgestp.c bstp_update_info(bp);
bp 974 net/bridgestp.c bstp_set_port_role(bp, BSTP_ROLE_DESIGNATED);
bp 976 net/bridgestp.c if (bstp_info_cmp(&bp->bp_port_pv,
bp 977 net/bridgestp.c &bp->bp_desg_pv) != INFO_SAME ||
bp 979 net/bridgestp.c (bp->bp_port_msg_age != rbp->bp_port_msg_age ||
bp 980 net/bridgestp.c bp->bp_port_max_age != rbp->bp_port_max_age ||
bp 981 net/bridgestp.c bp->bp_port_fdelay != rbp->bp_port_fdelay ||
bp 982 net/bridgestp.c bp->bp_port_htime != rbp->bp_port_htime)))
bp 983 net/bridgestp.c bstp_update_info(bp);
bp 987 net/bridgestp.c if (bp == rbp) {
bp 992 net/bridgestp.c bstp_set_port_role(bp, BSTP_ROLE_ROOT);
bp 993 net/bridgestp.c bs->bs_root_port = bp;
bp 994 net/bridgestp.c } else if (bstp_info_cmp(&bp->bp_port_pv,
bp 995 net/bridgestp.c &bp->bp_desg_pv) == INFO_BETTER) {
bp 1000 net/bridgestp.c bstp_set_port_role(bp, BSTP_ROLE_DESIGNATED);
bp 1001 net/bridgestp.c bstp_update_info(bp);
bp 1004 net/bridgestp.c bp->bp_port_pv.pv_dbridge_id,
bp 1010 net/bridgestp.c bstp_set_port_role(bp,
bp 1017 net/bridgestp.c bstp_set_port_role(bp,
bp 1027 net/bridgestp.c bstp_update_state(struct bstp_state *bs, struct bstp_port *bp)
bp 1036 net/bridgestp.c if (!(bp->bp_synced ||
bp 1037 net/bridgestp.c bp->bp_role == BSTP_ROLE_ROOT)) {
bp 1045 net/bridgestp.c bstp_update_roles(bs, bp);
bp 1046 net/bridgestp.c bstp_update_tc(bp);
bp 1050 net/bridgestp.c bstp_update_roles(struct bstp_state *bs, struct bstp_port *bp)
bp 1052 net/bridgestp.c switch (bp->bp_role) {
bp 1055 net/bridgestp.c if (bp->bp_sync || !bp->bp_synced || bp->bp_reroot) {
bp 1056 net/bridgestp.c bp->bp_sync = 0;
bp 1057 net/bridgestp.c bp->bp_synced = 1;
bp 1058 net/bridgestp.c bp->bp_reroot = 0;
bp 1064 net/bridgestp.c if ((bs->bs_allsynced && !bp->bp_agree) ||
bp 1065 net/bridgestp.c (bp->bp_proposed && bp->bp_agree)) {
bp 1066 net/bridgestp.c bp->bp_proposed = 0;
bp 1067 net/bridgestp.c bp->bp_agree = 1;
bp 1068 net/bridgestp.c bp->bp_flags |= BSTP_PORT_NEWINFO;
bp 1070 net/bridgestp.c bp->bp_ifp->if_xname);
bp 1073 net/bridgestp.c if (bp->bp_proposed && !bp->bp_agree) {
bp 1075 net/bridgestp.c bp->bp_proposed = 0;
bp 1077 net/bridgestp.c bp->bp_ifp->if_xname);
bp 1081 net/bridgestp.c if (bp->bp_sync || !bp->bp_synced || bp->bp_reroot) {
bp 1082 net/bridgestp.c bp->bp_sync = 0;
bp 1083 net/bridgestp.c bp->bp_synced = 1;
bp 1084 net/bridgestp.c bp->bp_reroot = 0;
bp 1085 net/bridgestp.c DPRINTF("%s -> ALTERNATE_PORT\n", bp->bp_ifp->if_xname);
bp 1090 net/bridgestp.c if (bp->bp_state != BSTP_IFSTATE_FORWARDING && !bp->bp_reroot) {
bp 1092 net/bridgestp.c DPRINTF("%s -> ROOT_REROOT\n", bp->bp_ifp->if_xname);
bp 1095 net/bridgestp.c if ((bs->bs_allsynced && !bp->bp_agree) ||
bp 1096 net/bridgestp.c (bp->bp_proposed && bp->bp_agree)) {
bp 1097 net/bridgestp.c bp->bp_proposed = 0;
bp 1098 net/bridgestp.c bp->bp_sync = 0;
bp 1099 net/bridgestp.c bp->bp_agree = 1;
bp 1100 net/bridgestp.c bp->bp_flags |= BSTP_PORT_NEWINFO;
bp 1101 net/bridgestp.c DPRINTF("%s -> ROOT_AGREED\n", bp->bp_ifp->if_xname);
bp 1104 net/bridgestp.c if (bp->bp_proposed && !bp->bp_agree) {
bp 1106 net/bridgestp.c bp->bp_proposed = 0;
bp 1107 net/bridgestp.c DPRINTF("%s -> ROOT_PROPOSED\n", bp->bp_ifp->if_xname);
bp 1110 net/bridgestp.c if (bp->bp_state != BSTP_IFSTATE_FORWARDING &&
bp 1111 net/bridgestp.c (bp->bp_forward_delay_timer.active == 0 ||
bp 1112 net/bridgestp.c (bstp_rerooted(bs, bp) &&
bp 1113 net/bridgestp.c bp->bp_recent_backup_timer.active == 0 &&
bp 1114 net/bridgestp.c bp->bp_protover == BSTP_PROTO_RSTP))) {
bp 1115 net/bridgestp.c switch (bp->bp_state) {
bp 1117 net/bridgestp.c bstp_set_port_state(bp, BSTP_IFSTATE_LEARNING);
bp 1120 net/bridgestp.c bstp_set_port_state(bp,
bp 1126 net/bridgestp.c if (bp->bp_state == BSTP_IFSTATE_FORWARDING && bp->bp_reroot) {
bp 1127 net/bridgestp.c bp->bp_reroot = 0;
bp 1128 net/bridgestp.c DPRINTF("%s -> ROOT_REROOTED\n", bp->bp_ifp->if_xname);
bp 1133 net/bridgestp.c if (bp->bp_recent_root_timer.active == 0 && bp->bp_reroot) {
bp 1134 net/bridgestp.c bp->bp_reroot = 0;
bp 1136 net/bridgestp.c bp->bp_ifp->if_xname);
bp 1139 net/bridgestp.c if ((bp->bp_state == BSTP_IFSTATE_DISCARDING &&
bp 1140 net/bridgestp.c !bp->bp_synced) || (bp->bp_agreed && !bp->bp_synced) ||
bp 1141 net/bridgestp.c (bp->bp_operedge && !bp->bp_synced) ||
bp 1142 net/bridgestp.c (bp->bp_sync && bp->bp_synced)) {
bp 1143 net/bridgestp.c bstp_timer_stop(&bp->bp_recent_root_timer);
bp 1144 net/bridgestp.c bp->bp_synced = 1;
bp 1145 net/bridgestp.c bp->bp_sync = 0;
bp 1147 net/bridgestp.c bp->bp_ifp->if_xname);
bp 1150 net/bridgestp.c if (bp->bp_state != BSTP_IFSTATE_FORWARDING &&
bp 1151 net/bridgestp.c !bp->bp_agreed && !bp->bp_proposing &&
bp 1152 net/bridgestp.c !bp->bp_operedge) {
bp 1153 net/bridgestp.c bp->bp_proposing = 1;
bp 1154 net/bridgestp.c bp->bp_flags |= BSTP_PORT_NEWINFO;
bp 1155 net/bridgestp.c bstp_timer_start(&bp->bp_edge_delay_timer,
bp 1156 net/bridgestp.c (bp->bp_ptp_link ? BSTP_DEFAULT_MIGRATE_DELAY :
bp 1157 net/bridgestp.c bp->bp_desg_max_age));
bp 1159 net/bridgestp.c bp->bp_ifp->if_xname);
bp 1162 net/bridgestp.c if (bp->bp_state != BSTP_IFSTATE_FORWARDING &&
bp 1163 net/bridgestp.c (bp->bp_forward_delay_timer.active == 0 || bp->bp_agreed ||
bp 1164 net/bridgestp.c bp->bp_operedge) &&
bp 1165 net/bridgestp.c (bp->bp_recent_root_timer.active == 0 || !bp->bp_reroot) &&
bp 1166 net/bridgestp.c !bp->bp_sync) {
bp 1167 net/bridgestp.c if (bp->bp_agreed)
bp 1168 net/bridgestp.c DPRINTF("%s -> AGREED\n", bp->bp_ifp->if_xname);
bp 1173 net/bridgestp.c if (bp->bp_agreed || bp->bp_operedge ||
bp 1174 net/bridgestp.c bp->bp_state == BSTP_IFSTATE_LEARNING) {
bp 1175 net/bridgestp.c bstp_set_port_state(bp,
bp 1177 net/bridgestp.c bp->bp_agreed = bp->bp_protover;
bp 1178 net/bridgestp.c } else if (bp->bp_state == BSTP_IFSTATE_DISCARDING)
bp 1179 net/bridgestp.c bstp_set_port_state(bp, BSTP_IFSTATE_LEARNING);
bp 1182 net/bridgestp.c if (((bp->bp_sync && !bp->bp_synced) ||
bp 1183 net/bridgestp.c (bp->bp_reroot && bp->bp_recent_root_timer.active) ||
bp 1184 net/bridgestp.c (bp->bp_flags & BSTP_PORT_DISPUTED)) && !bp->bp_operedge &&
bp 1185 net/bridgestp.c bp->bp_state != BSTP_IFSTATE_DISCARDING) {
bp 1186 net/bridgestp.c bstp_set_port_state(bp, BSTP_IFSTATE_DISCARDING);
bp 1187 net/bridgestp.c bp->bp_flags &= ~BSTP_PORT_DISPUTED;
bp 1188 net/bridgestp.c bstp_timer_start(&bp->bp_forward_delay_timer,
bp 1189 net/bridgestp.c bp->bp_protover == BSTP_PROTO_RSTP ?
bp 1190 net/bridgestp.c bp->bp_desg_htime : bp->bp_desg_fdelay);
bp 1192 net/bridgestp.c bp->bp_ifp->if_xname);
bp 1197 net/bridgestp.c if (bp->bp_flags & BSTP_PORT_NEWINFO)
bp 1198 net/bridgestp.c bstp_transmit(bs, bp);
bp 1202 net/bridgestp.c bstp_update_tc(struct bstp_port *bp)
bp 1204 net/bridgestp.c switch (bp->bp_tcstate) {
bp 1206 net/bridgestp.c if ((bp->bp_role != BSTP_ROLE_DESIGNATED &&
bp 1207 net/bridgestp.c bp->bp_role != BSTP_ROLE_ROOT) || bp->bp_operedge)
bp 1208 net/bridgestp.c bstp_set_port_tc(bp, BSTP_TCSTATE_LEARNING);
bp 1210 net/bridgestp.c if (bp->bp_rcvdtcn)
bp 1211 net/bridgestp.c bstp_set_port_tc(bp, BSTP_TCSTATE_TCN);
bp 1212 net/bridgestp.c if (bp->bp_rcvdtc)
bp 1213 net/bridgestp.c bstp_set_port_tc(bp, BSTP_TCSTATE_TC);
bp 1215 net/bridgestp.c if (bp->bp_tc_prop && !bp->bp_operedge)
bp 1216 net/bridgestp.c bstp_set_port_tc(bp, BSTP_TCSTATE_PROPAG);
bp 1218 net/bridgestp.c if (bp->bp_rcvdtca)
bp 1219 net/bridgestp.c bstp_set_port_tc(bp, BSTP_TCSTATE_ACK);
bp 1223 net/bridgestp.c if ((bp->bp_state == BSTP_IFSTATE_LEARNING ||
bp 1224 net/bridgestp.c bp->bp_state == BSTP_IFSTATE_FORWARDING) &&
bp 1225 net/bridgestp.c bp->bp_fdbflush == 0)
bp 1226 net/bridgestp.c bstp_set_port_tc(bp, BSTP_TCSTATE_LEARNING);
bp 1230 net/bridgestp.c if (bp->bp_rcvdtc || bp->bp_rcvdtcn || bp->bp_rcvdtca ||
bp 1231 net/bridgestp.c bp->bp_tc_prop)
bp 1232 net/bridgestp.c bstp_set_port_tc(bp, BSTP_TCSTATE_LEARNING);
bp 1233 net/bridgestp.c else if (bp->bp_role != BSTP_ROLE_DESIGNATED &&
bp 1234 net/bridgestp.c bp->bp_role != BSTP_ROLE_ROOT &&
bp 1235 net/bridgestp.c bp->bp_state == BSTP_IFSTATE_DISCARDING)
bp 1236 net/bridgestp.c bstp_set_port_tc(bp, BSTP_TCSTATE_INACTIVE);
bp 1238 net/bridgestp.c if ((bp->bp_role == BSTP_ROLE_DESIGNATED ||
bp 1239 net/bridgestp.c bp->bp_role == BSTP_ROLE_ROOT) &&
bp 1240 net/bridgestp.c bp->bp_state == BSTP_IFSTATE_FORWARDING &&
bp 1241 net/bridgestp.c !bp->bp_operedge)
bp 1242 net/bridgestp.c bstp_set_port_tc(bp, BSTP_TCSTATE_DETECTED);
bp 1252 net/bridgestp.c bp->bp_ifp->if_xname);
bp 1259 net/bridgestp.c bstp_update_info(struct bstp_port *bp)
bp 1261 net/bridgestp.c struct bstp_state *bs = bp->bp_bs;
bp 1263 net/bridgestp.c bp->bp_proposing = 0;
bp 1264 net/bridgestp.c bp->bp_proposed = 0;
bp 1266 net/bridgestp.c if (bp->bp_agreed && !bstp_pdu_bettersame(bp, BSTP_INFO_MINE))
bp 1267 net/bridgestp.c bp->bp_agreed = 0;
bp 1269 net/bridgestp.c if (bp->bp_synced && !bp->bp_agreed) {
bp 1270 net/bridgestp.c bp->bp_synced = 0;
bp 1275 net/bridgestp.c bp->bp_port_pv = bp->bp_desg_pv;
bp 1276 net/bridgestp.c bp->bp_port_msg_age = bp->bp_desg_msg_age;
bp 1277 net/bridgestp.c bp->bp_port_max_age = bp->bp_desg_max_age;
bp 1278 net/bridgestp.c bp->bp_port_fdelay = bp->bp_desg_fdelay;
bp 1279 net/bridgestp.c bp->bp_port_htime = bp->bp_desg_htime;
bp 1280 net/bridgestp.c bp->bp_infois = BSTP_INFO_MINE;
bp 1283 net/bridgestp.c bp->bp_flags |= BSTP_PORT_NEWINFO;
bp 1288 net/bridgestp.c bstp_set_other_tcprop(struct bstp_port *bp)
bp 1290 net/bridgestp.c struct bstp_state *bs = bp->bp_bs;
bp 1294 net/bridgestp.c if (bp2 == bp)
bp 1303 net/bridgestp.c struct bstp_port *bp;
bp 1305 net/bridgestp.c LIST_FOREACH(bp, &bs->bs_bplist, bp_next)
bp 1306 net/bridgestp.c bp->bp_reroot = 1;
bp 1312 net/bridgestp.c struct bstp_port *bp;
bp 1314 net/bridgestp.c LIST_FOREACH(bp, &bs->bs_bplist, bp_next) {
bp 1315 net/bridgestp.c bp->bp_sync = 1;
bp 1316 net/bridgestp.c bp->bp_synced = 0; /* Not explicit in spec */
bp 1323 net/bridgestp.c bstp_set_port_state(struct bstp_port *bp, int state)
bp 1325 net/bridgestp.c if (bp->bp_state == state)
bp 1328 net/bridgestp.c bp->bp_state = state;
bp 1330 net/bridgestp.c switch (bp->bp_state) {
bp 1333 net/bridgestp.c bp->bp_ifp->if_xname);
bp 1338 net/bridgestp.c bp->bp_ifp->if_xname);
bp 1340 net/bridgestp.c bstp_timer_start(&bp->bp_forward_delay_timer,
bp 1341 net/bridgestp.c bp->bp_protover == BSTP_PROTO_RSTP ?
bp 1342 net/bridgestp.c bp->bp_desg_htime : bp->bp_desg_fdelay);
bp 1347 net/bridgestp.c bp->bp_ifp->if_xname);
bp 1349 net/bridgestp.c bstp_timer_stop(&bp->bp_forward_delay_timer);
bp 1351 net/bridgestp.c bp->bp_forward_transitions++;
bp 1357 net/bridgestp.c bstp_set_port_role(struct bstp_port *bp, int role)
bp 1359 net/bridgestp.c struct bstp_state *bs = bp->bp_bs;
bp 1361 net/bridgestp.c if (bp->bp_role == role)
bp 1365 net/bridgestp.c switch (bp->bp_role) {
bp 1367 net/bridgestp.c bstp_timer_start(&bp->bp_forward_delay_timer,
bp 1368 net/bridgestp.c bp->bp_desg_max_age);
bp 1372 net/bridgestp.c bstp_timer_start(&bp->bp_recent_backup_timer,
bp 1373 net/bridgestp.c bp->bp_desg_htime * 2);
bp 1376 net/bridgestp.c bstp_timer_start(&bp->bp_forward_delay_timer,
bp 1377 net/bridgestp.c bp->bp_desg_fdelay);
bp 1378 net/bridgestp.c bp->bp_sync = 0;
bp 1379 net/bridgestp.c bp->bp_synced = 1;
bp 1380 net/bridgestp.c bp->bp_reroot = 0;
bp 1384 net/bridgestp.c bstp_timer_start(&bp->bp_recent_root_timer,
bp 1389 net/bridgestp.c bp->bp_role = role;
bp 1391 net/bridgestp.c bp->bp_proposing = 0;
bp 1395 net/bridgestp.c switch (bp->bp_role) {
bp 1400 net/bridgestp.c bp->bp_ifp->if_xname);
bp 1401 net/bridgestp.c bstp_set_port_state(bp, BSTP_IFSTATE_DISCARDING);
bp 1402 net/bridgestp.c bstp_timer_stop(&bp->bp_recent_root_timer);
bp 1403 net/bridgestp.c bstp_timer_latch(&bp->bp_forward_delay_timer);
bp 1404 net/bridgestp.c bp->bp_sync = 0;
bp 1405 net/bridgestp.c bp->bp_synced = 1;
bp 1406 net/bridgestp.c bp->bp_reroot = 0;
bp 1411 net/bridgestp.c bp->bp_ifp->if_xname);
bp 1412 net/bridgestp.c bstp_set_port_state(bp, BSTP_IFSTATE_DISCARDING);
bp 1413 net/bridgestp.c bstp_timer_latch(&bp->bp_recent_root_timer);
bp 1414 net/bridgestp.c bp->bp_proposing = 0;
bp 1419 net/bridgestp.c bp->bp_ifp->if_xname);
bp 1420 net/bridgestp.c bstp_timer_start(&bp->bp_hello_timer,
bp 1421 net/bridgestp.c bp->bp_desg_htime);
bp 1422 net/bridgestp.c bp->bp_agree = 0;
bp 1427 net/bridgestp.c bstp_update_tc(bp);
bp 1431 net/bridgestp.c bstp_set_port_proto(struct bstp_port *bp, int proto)
bp 1433 net/bridgestp.c struct bstp_state *bs = bp->bp_bs;
bp 1439 net/bridgestp.c bstp_timer_stop(&bp->bp_migrate_delay_timer);
bp 1441 net/bridgestp.c bp->bp_operedge = 0;
bp 1445 net/bridgestp.c bstp_timer_start(&bp->bp_migrate_delay_timer,
bp 1454 net/bridgestp.c bp->bp_protover = proto;
bp 1455 net/bridgestp.c bp->bp_flags &= ~BSTP_PORT_CANMIGRATE;
bp 1459 net/bridgestp.c bstp_set_port_tc(struct bstp_port *bp, int state)
bp 1461 net/bridgestp.c struct bstp_state *bs = bp->bp_bs;
bp 1463 net/bridgestp.c bp->bp_tcstate = state;
bp 1466 net/bridgestp.c switch (bp->bp_tcstate) {
bp 1468 net/bridgestp.c DPRINTF("%s -> TC_ACTIVE\n", bp->bp_ifp->if_xname);
bp 1473 net/bridgestp.c bstp_timer_stop(&bp->bp_tc_timer);
bp 1475 net/bridgestp.c bp->bp_fdbflush = 1;
bp 1476 net/bridgestp.c bstp_notify_rtage(bp->bp_ifp, 0);
bp 1477 net/bridgestp.c bp->bp_tc_ack = 0;
bp 1478 net/bridgestp.c DPRINTF("%s -> TC_INACTIVE\n", bp->bp_ifp->if_xname);
bp 1482 net/bridgestp.c bp->bp_rcvdtc = 0;
bp 1483 net/bridgestp.c bp->bp_rcvdtcn = 0;
bp 1484 net/bridgestp.c bp->bp_rcvdtca = 0;
bp 1485 net/bridgestp.c bp->bp_tc_prop = 0;
bp 1486 net/bridgestp.c DPRINTF("%s -> TC_LEARNING\n", bp->bp_ifp->if_xname);
bp 1490 net/bridgestp.c bstp_set_timer_tc(bp);
bp 1491 net/bridgestp.c bstp_set_other_tcprop(bp);
bp 1493 net/bridgestp.c bp->bp_flags |= BSTP_PORT_NEWINFO;
bp 1494 net/bridgestp.c bstp_transmit(bs, bp);
bp 1496 net/bridgestp.c DPRINTF("%s -> TC_DETECTED\n", bp->bp_ifp->if_xname);
bp 1497 net/bridgestp.c bp->bp_tcstate = BSTP_TCSTATE_ACTIVE; /* UCT */
bp 1501 net/bridgestp.c bstp_set_timer_tc(bp);
bp 1502 net/bridgestp.c DPRINTF("%s -> TC_TCN\n", bp->bp_ifp->if_xname);
bp 1505 net/bridgestp.c bp->bp_rcvdtc = 0;
bp 1506 net/bridgestp.c bp->bp_rcvdtcn = 0;
bp 1507 net/bridgestp.c if (bp->bp_role == BSTP_ROLE_DESIGNATED)
bp 1508 net/bridgestp.c bp->bp_tc_ack = 1;
bp 1510 net/bridgestp.c bstp_set_other_tcprop(bp);
bp 1511 net/bridgestp.c DPRINTF("%s -> TC_TC\n", bp->bp_ifp->if_xname);
bp 1512 net/bridgestp.c bp->bp_tcstate = BSTP_TCSTATE_ACTIVE; /* UCT */
bp 1517 net/bridgestp.c bp->bp_fdbflush = 1;
bp 1518 net/bridgestp.c bstp_notify_rtage(bp->bp_ifp, 0);
bp 1519 net/bridgestp.c bp->bp_tc_prop = 0;
bp 1520 net/bridgestp.c bstp_set_timer_tc(bp);
bp 1521 net/bridgestp.c DPRINTF("%s -> TC_PROPAG\n", bp->bp_ifp->if_xname);
bp 1522 net/bridgestp.c bp->bp_tcstate = BSTP_TCSTATE_ACTIVE; /* UCT */
bp 1526 net/bridgestp.c bstp_timer_stop(&bp->bp_tc_timer);
bp 1527 net/bridgestp.c bp->bp_rcvdtca = 0;
bp 1528 net/bridgestp.c DPRINTF("%s -> TC_ACK\n", bp->bp_ifp->if_xname);
bp 1529 net/bridgestp.c bp->bp_tcstate = BSTP_TCSTATE_ACTIVE; /* UCT */
bp 1535 net/bridgestp.c bstp_set_timer_tc(struct bstp_port *bp)
bp 1537 net/bridgestp.c struct bstp_state *bs = bp->bp_bs;
bp 1539 net/bridgestp.c if (bp->bp_tc_timer.active)
bp 1542 net/bridgestp.c switch (bp->bp_protover) {
bp 1544 net/bridgestp.c bstp_timer_start(&bp->bp_tc_timer,
bp 1545 net/bridgestp.c bp->bp_desg_htime + BSTP_TICK_VAL);
bp 1546 net/bridgestp.c bp->bp_flags |= BSTP_PORT_NEWINFO;
bp 1549 net/bridgestp.c bstp_timer_start(&bp->bp_tc_timer,
bp 1556 net/bridgestp.c bstp_set_timer_msgage(struct bstp_port *bp)
bp 1558 net/bridgestp.c if (bp->bp_port_msg_age + BSTP_MESSAGE_AGE_INCR <=
bp 1559 net/bridgestp.c bp->bp_port_max_age) {
bp 1560 net/bridgestp.c bstp_timer_start(&bp->bp_message_age_timer,
bp 1561 net/bridgestp.c bp->bp_port_htime * 3);
bp 1564 net/bridgestp.c bstp_timer_start(&bp->bp_message_age_timer, 0);
bp 1568 net/bridgestp.c bstp_rerooted(struct bstp_state *bs, struct bstp_port *bp)
bp 1574 net/bridgestp.c if (bp2 == bp)
bp 1588 net/bridgestp.c bstp_calc_path_cost(struct bstp_port *bp)
bp 1590 net/bridgestp.c struct ifnet *ifp = bp->bp_ifp;
bp 1594 net/bridgestp.c if (bp->bp_flags & BSTP_PORT_ADMCOST)
bp 1595 net/bridgestp.c return bp->bp_path_cost;
bp 1607 net/bridgestp.c if (bp->bp_protover == BSTP_PROTO_STP && path_cost > 65535)
bp 1616 net/bridgestp.c struct bstp_port *bp = (struct bstp_port *)arg;
bp 1621 net/bridgestp.c switch (bp->bp_protover) {
bp 1624 net/bridgestp.c age = bp->bp_desg_fdelay / BSTP_TICK_VAL;
bp 1631 net/bridgestp.c if (bp->bp_active == 1)
bp 1632 net/bridgestp.c bridge_rtagenode(bp->bp_ifp, age);
bp 1635 net/bridgestp.c bp->bp_fdbflush = 0;
bp 1644 net/bridgestp.c struct bstp_port *bp;
bp 1661 net/bridgestp.c if ((bp = p->bif_stp) == NULL)
bp 1663 net/bridgestp.c if ((bs = bp->bp_bs) == NULL)
bp 1667 net/bridgestp.c bstp_ifupdstatus(bs, bp);
bp 1668 net/bridgestp.c bstp_update_state(bs, bp);
bp 1674 net/bridgestp.c bstp_ifupdstatus(struct bstp_state *bs, struct bstp_port *bp)
bp 1676 net/bridgestp.c struct ifnet *ifp = bp->bp_ifp;
bp 1681 net/bridgestp.c bp->bp_path_cost = bstp_calc_path_cost(bp);
bp 1685 net/bridgestp.c if (bp->bp_flags & BSTP_PORT_AUTOPTP) {
bp 1687 net/bridgestp.c bp->bp_ptp_link = ifp->if_link_state ==
bp 1691 net/bridgestp.c if (bp->bp_infois == BSTP_INFO_DISABLED)
bp 1692 net/bridgestp.c bstp_enable_port(bs, bp);
bp 1694 net/bridgestp.c if (bp->bp_infois != BSTP_INFO_DISABLED)
bp 1695 net/bridgestp.c bstp_disable_port(bs, bp);
bp 1700 net/bridgestp.c bstp_enable_port(struct bstp_state *bs, struct bstp_port *bp)
bp 1702 net/bridgestp.c bp->bp_infois = BSTP_INFO_AGED;
bp 1707 net/bridgestp.c bstp_disable_port(struct bstp_state *bs, struct bstp_port *bp)
bp 1709 net/bridgestp.c bp->bp_infois = BSTP_INFO_DISABLED;
bp 1710 net/bridgestp.c bstp_set_port_state(bp, BSTP_IFSTATE_DISCARDING);
bp 1718 net/bridgestp.c struct bstp_port *bp;
bp 1729 net/bridgestp.c LIST_FOREACH(bp, &bs->bs_bplist, bp_next)
bp 1730 net/bridgestp.c bstp_ifupdstatus(bs, bp);
bp 1734 net/bridgestp.c LIST_FOREACH(bp, &bs->bs_bplist, bp_next) {
bp 1736 net/bridgestp.c bstp_timer_expired(&bp->bp_tc_timer);
bp 1737 net/bridgestp.c bstp_timer_expired(&bp->bp_recent_root_timer);
bp 1738 net/bridgestp.c bstp_timer_expired(&bp->bp_forward_delay_timer);
bp 1739 net/bridgestp.c bstp_timer_expired(&bp->bp_recent_backup_timer);
bp 1741 net/bridgestp.c if (bstp_timer_expired(&bp->bp_hello_timer))
bp 1742 net/bridgestp.c bstp_hello_timer_expiry(bs, bp);
bp 1744 net/bridgestp.c if (bstp_timer_expired(&bp->bp_message_age_timer))
bp 1745 net/bridgestp.c bstp_message_age_expiry(bs, bp);
bp 1747 net/bridgestp.c if (bstp_timer_expired(&bp->bp_migrate_delay_timer))
bp 1748 net/bridgestp.c bstp_migrate_delay_expiry(bs, bp);
bp 1750 net/bridgestp.c if (bstp_timer_expired(&bp->bp_edge_delay_timer))
bp 1751 net/bridgestp.c bstp_edge_delay_expiry(bs, bp);
bp 1754 net/bridgestp.c bstp_update_state(bs, bp);
bp 1756 net/bridgestp.c if (bp->bp_txcount > 0)
bp 1757 net/bridgestp.c bp->bp_txcount--;
bp 1803 net/bridgestp.c bstp_hello_timer_expiry(struct bstp_state *bs, struct bstp_port *bp)
bp 1805 net/bridgestp.c if ((bp->bp_flags & BSTP_PORT_NEWINFO) ||
bp 1806 net/bridgestp.c bp->bp_role == BSTP_ROLE_DESIGNATED ||
bp 1807 net/bridgestp.c (bp->bp_role == BSTP_ROLE_ROOT &&
bp 1808 net/bridgestp.c bp->bp_tc_timer.active == 1)) {
bp 1809 net/bridgestp.c bstp_timer_start(&bp->bp_hello_timer, bp->bp_desg_htime);
bp 1810 net/bridgestp.c bp->bp_flags |= BSTP_PORT_NEWINFO;
bp 1811 net/bridgestp.c bstp_transmit(bs, bp);
bp 1816 net/bridgestp.c bstp_message_age_expiry(struct bstp_state *bs, struct bstp_port *bp)
bp 1818 net/bridgestp.c if (bp->bp_infois == BSTP_INFO_RECIEVED) {
bp 1819 net/bridgestp.c bp->bp_infois = BSTP_INFO_AGED;
bp 1821 net/bridgestp.c DPRINTF("aged info on %s\n", bp->bp_ifp->if_xname);
bp 1826 net/bridgestp.c bstp_migrate_delay_expiry(struct bstp_state *bs, struct bstp_port *bp)
bp 1828 net/bridgestp.c bp->bp_flags |= BSTP_PORT_CANMIGRATE;
bp 1832 net/bridgestp.c bstp_edge_delay_expiry(struct bstp_state *bs, struct bstp_port *bp)
bp 1834 net/bridgestp.c if ((bp->bp_flags & BSTP_PORT_AUTOEDGE) &&
bp 1835 net/bridgestp.c bp->bp_protover == BSTP_PROTO_RSTP && bp->bp_proposing &&
bp 1836 net/bridgestp.c bp->bp_role == BSTP_ROLE_DESIGNATED)
bp 1837 net/bridgestp.c bp->bp_operedge = 1;
bp 1873 net/bridgestp.c struct bstp_port *bp;
bp 1926 net/bridgestp.c LIST_FOREACH(bp, &bs->bs_bplist, bp_next) {
bp 1927 net/bridgestp.c bp->bp_port_id = (bp->bp_priority << 8) |
bp 1928 net/bridgestp.c (bp->bp_ifp->if_index & 0xfff);
bp 1929 net/bridgestp.c bstp_ifupdstatus(bs, bp);
bp 1985 net/bridgestp.c struct bstp_port *bp;
bp 1987 net/bridgestp.c LIST_FOREACH(bp, &bs->bs_bplist, bp_next)
bp 1988 net/bridgestp.c bstp_set_port_state(bp, BSTP_IFSTATE_DISCARDING);
bp 1998 net/bridgestp.c struct bstp_port *bp;
bp 2008 net/bridgestp.c bp = (struct bstp_port *)malloc(sizeof(*bp), M_DEVBUF, M_NOWAIT);
bp 2009 net/bridgestp.c if (bp == NULL)
bp 2011 net/bridgestp.c bzero(bp, sizeof(*bp));
bp 2013 net/bridgestp.c bp->bp_ifp = ifp;
bp 2014 net/bridgestp.c bp->bp_bs = bs;
bp 2015 net/bridgestp.c bp->bp_priority = BSTP_DEFAULT_PORT_PRIORITY;
bp 2016 net/bridgestp.c bp->bp_txcount = 0;
bp 2019 net/bridgestp.c bp->bp_infois = BSTP_INFO_DISABLED;
bp 2020 net/bridgestp.c bp->bp_flags = BSTP_PORT_AUTOEDGE | BSTP_PORT_AUTOPTP;
bp 2021 net/bridgestp.c bstp_set_port_state(bp, BSTP_IFSTATE_DISCARDING);
bp 2022 net/bridgestp.c bstp_set_port_proto(bp, bs->bs_protover);
bp 2023 net/bridgestp.c bstp_set_port_role(bp, BSTP_ROLE_DISABLED);
bp 2024 net/bridgestp.c bstp_set_port_tc(bp, BSTP_TCSTATE_INACTIVE);
bp 2025 net/bridgestp.c bp->bp_path_cost = bstp_calc_path_cost(bp);
bp 2027 net/bridgestp.c LIST_INSERT_HEAD(&bs->bs_bplist, bp, bp_next);
bp 2029 net/bridgestp.c bp->bp_active = 1;
bp 2030 net/bridgestp.c bp->bp_flags |= BSTP_PORT_NEWINFO;
bp 2032 net/bridgestp.c bstp_update_roles(bs, bp);
bp 2036 net/bridgestp.c bp->bp_lhcookie = hook_establish(ifp->if_linkstatehooks, 1,
bp 2039 net/bridgestp.c return (bp);
bp 2043 net/bridgestp.c bstp_delete(struct bstp_port *bp)
bp 2045 net/bridgestp.c struct bstp_state *bs = bp->bp_bs;
bp 2046 net/bridgestp.c struct ifnet *ifp = bp->bp_ifp;
bp 2048 net/bridgestp.c if (!bp->bp_active)
bp 2052 net/bridgestp.c hook_disestablish(ifp->if_linkstatehooks, bp->bp_lhcookie);
bp 2054 net/bridgestp.c LIST_REMOVE(bp, bp_next);
bp 2055 net/bridgestp.c bp->bp_bs = NULL;
bp 2056 net/bridgestp.c bp->bp_active = 0;
bp 2057 net/bridgestp.c free(bp, M_DEVBUF);
bp 2062 net/bridgestp.c bstp_getstate(struct bstp_state *bs, struct bstp_port *bp)
bp 2064 net/bridgestp.c u_int8_t state = bp->bp_state;
bp 2073 net/bridgestp.c if (bp->bp_role == BSTP_ROLE_DISABLED)
bp 2075 net/bridgestp.c else if (bp->bp_role == BSTP_ROLE_ALTERNATE ||
bp 2076 net/bridgestp.c bp->bp_role == BSTP_ROLE_BACKUP)
bp 2085 net/bridgestp.c bstp_ifsflags(struct bstp_port *bp, u_int flags)
bp 2091 net/bridgestp.c bs = bp->bp_bs;
bp 2097 net/bridgestp.c if ((bp->bp_flags & BSTP_PORT_AUTOEDGE) == 0) {
bp 2098 net/bridgestp.c bp->bp_flags |= BSTP_PORT_AUTOEDGE;
bp 2101 net/bridgestp.c if (bp->bp_edge_delay_timer.active == 0)
bp 2102 net/bridgestp.c bstp_edge_delay_expiry(bs, bp);
bp 2105 net/bridgestp.c bp->bp_flags &= ~BSTP_PORT_AUTOEDGE;
bp 2108 net/bridgestp.c bp->bp_operedge = 1;
bp 2110 net/bridgestp.c bp->bp_operedge = 0;
bp 2116 net/bridgestp.c if ((bp->bp_flags & BSTP_PORT_AUTOPTP) == 0) {
bp 2117 net/bridgestp.c bp->bp_flags |= BSTP_PORT_AUTOPTP;
bp 2119 net/bridgestp.c bstp_ifupdstatus(bs, bp);
bp 2122 net/bridgestp.c bp->bp_flags &= ~BSTP_PORT_AUTOPTP;
bp 2125 net/bridgestp.c bp->bp_ptp_link = 1;
bp 2127 net/bridgestp.c bp->bp_ptp_link = 0;
bp 2139 net/bridgestp.c struct bstp_port *bp;
bp 2166 net/bridgestp.c bp = p->bif_stp;
bp 2252 net/bridgestp.c LIST_FOREACH(bp, &bs->bs_bplist, bp_next)
bp 2253 net/bridgestp.c bp->bp_txcount = 0;
bp 2262 net/bridgestp.c bp->bp_priority = val;
bp 2272 net/bridgestp.c bp->bp_flags &= ~BSTP_PORT_ADMCOST;
bp 2273 net/bridgestp.c bp->bp_path_cost = bstp_calc_path_cost(bp);
bp 2275 net/bridgestp.c bp->bp_path_cost = val;
bp 2276 net/bridgestp.c bp->bp_flags |= BSTP_PORT_ADMCOST;
bp 2289 net/bridgestp.c LIST_FOREACH(bp, &bs->bs_bplist, bp_next) {
bp 2291 net/bridgestp.c bp->bp_infois = BSTP_INFO_DISABLED;
bp 2292 net/bridgestp.c bp->bp_txcount = 0;
bp 2293 net/bridgestp.c bstp_set_port_proto(bp, bs->bs_protover);
bp 2294 net/bridgestp.c bstp_set_port_role(bp, BSTP_ROLE_DISABLED);
bp 2295 net/bridgestp.c bstp_set_port_tc(bp, BSTP_TCSTATE_INACTIVE);
bp 2296 net/bridgestp.c bstp_timer_stop(&bp->bp_recent_backup_timer);
bp 296 net/if_bridge.c struct bstp_port *bp;
bp 488 net/if_bridge.c bp = p->bif_stp;
bp 489 net/if_bridge.c req->ifbr_state = bstp_getstate(bs, bp);
bp 490 net/if_bridge.c req->ifbr_priority = bp->bp_priority;
bp 491 net/if_bridge.c req->ifbr_path_cost = bp->bp_path_cost;
bp 492 net/if_bridge.c req->ifbr_proto = bp->bp_protover;
bp 493 net/if_bridge.c req->ifbr_role = bp->bp_role;
bp 494 net/if_bridge.c req->ifbr_stpflags = bp->bp_flags;
bp 495 net/if_bridge.c req->ifbr_fwd_trans = bp->bp_forward_transitions;
bp 496 net/if_bridge.c req->ifbr_desg_bridge = bp->bp_desg_pv.pv_dbridge_id;
bp 497 net/if_bridge.c req->ifbr_desg_port = bp->bp_desg_pv.pv_dport_id;
bp 498 net/if_bridge.c req->ifbr_root_bridge = bp->bp_desg_pv.pv_root_id;
bp 499 net/if_bridge.c req->ifbr_root_cost = bp->bp_desg_pv.pv_cost;
bp 500 net/if_bridge.c req->ifbr_root_port = bp->bp_desg_pv.pv_port_id;
bp 503 net/if_bridge.c if (bp->bp_operedge)
bp 505 net/if_bridge.c if (bp->bp_flags & BSTP_PORT_AUTOEDGE)
bp 507 net/if_bridge.c if (bp->bp_ptp_link)
bp 509 net/if_bridge.c if (bp->bp_flags & BSTP_PORT_AUTOPTP)
bp 688 net/if_bridge.c if ((bp = bs->bs_root_port) == NULL)
bp 691 net/if_bridge.c brop->ifbop_root_port = bp->bp_ifp->if_index;
bp 791 net/if_bridge.c struct bstp_port *bp;
bp 821 net/if_bridge.c bp = p->bif_stp;
bp 822 net/if_bridge.c breq->ifbr_state = bstp_getstate(sc->sc_stp, bp);
bp 823 net/if_bridge.c breq->ifbr_priority = bp->bp_priority;
bp 824 net/if_bridge.c breq->ifbr_path_cost = bp->bp_path_cost;
bp 825 net/if_bridge.c breq->ifbr_proto = bp->bp_protover;
bp 826 net/if_bridge.c breq->ifbr_role = bp->bp_role;
bp 827 net/if_bridge.c breq->ifbr_stpflags = bp->bp_flags;
bp 828 net/if_bridge.c breq->ifbr_fwd_trans = bp->bp_forward_transitions;
bp 836 net/if_bridge.c if (bp->bp_operedge)
bp 838 net/if_bridge.c if (bp->bp_flags & BSTP_PORT_AUTOEDGE)
bp 840 net/if_bridge.c if (bp->bp_ptp_link)
bp 842 net/if_bridge.c if (bp->bp_flags & BSTP_PORT_AUTOPTP)
bp 419 net/if_ppp.c struct bpf_program *bp, *nbp;
bp 598 net/if_ppp.c bp = (cmd == PPPIOCSPASS)? &sc->sc_pass_filt: &sc->sc_active_filt;
bp 599 net/if_ppp.c oldcode = bp->bf_insns;
bp 601 net/if_ppp.c bp->bf_len = nbp->bf_len;
bp 602 net/if_ppp.c bp->bf_insns = newcode;
bp 1572 net/if_ppp.c char *bp = buf;
bp 1581 net/if_ppp.c if (bp > buf + sizeof(buf) - 4)
bp 1583 net/if_ppp.c *bp++ = digits[*rptr >> 4]; /* convert byte to ascii hex */
bp 1584 net/if_ppp.c *bp++ = digits[*rptr++ & 0xf];
bp 1588 net/if_ppp.c if (bp > buf + sizeof(buf) - 3)
bp 1590 net/if_ppp.c *bp++ = '|';
bp 1592 net/if_ppp.c *bp++ = ' ';
bp 1596 net/if_ppp.c *bp++ = '>';
bp 1597 net/if_ppp.c *bp = 0;
bp 620 net/if_sl.c u_char *bp = cp;
bp 631 net/if_sl.c if (cp > bp) {
bp 637 net/if_sl.c if (b_to_q((u_char *)bp, cp - bp,
bp 639 net/if_sl.c if (b_to_q((char *)bp, cp - bp,
bp 643 net/if_sl.c sc->sc_if.if_obytes += cp - bp;
bp 1078 net/ppp_tty.c char *bp = buf;
bp 1082 net/ppp_tty.c if (bp >= buf + sizeof(buf) - 3) {
bp 1083 net/ppp_tty.c *bp++ = '>';
bp 1086 net/ppp_tty.c *bp++ = digits[*b >> 4]; /* convert byte to ascii hex */
bp 1087 net/ppp_tty.c *bp++ = digits[*b++ & 0xf];
bp 1088 net/ppp_tty.c *bp++ = ' ';
bp 1091 net/ppp_tty.c *bp = 0;
bp 491 net/slcompress.c u_int16_t *bp;
bp 606 net/slcompress.c bp = (u_int16_t *) &cs->cs_ip;
bp 609 net/slcompress.c changes += *bp++;
bp 604 netinet/tcp_output.c u_int8_t *bp = (u_int8_t *)(opt + optlen);
bp 607 netinet/tcp_output.c *(bp++) = TCPOPT_SIGNATURE;
bp 608 netinet/tcp_output.c *(bp++) = TCPOLEN_SIGNATURE;
bp 615 netinet/tcp_output.c *(bp++) = 0;
bp 622 netinet/tcp_output.c *bp++ = TCPOPT_NOP;
bp 623 netinet/tcp_output.c *bp++ = TCPOPT_EOL;
bp 76 nfs/nfs_bio.c struct buf *bp = NULL, *rabp;
bp 181 nfs/nfs_bio.c if ((bp = incore(vp, bn)) &&
bp 182 nfs/nfs_bio.c (bp->b_flags & (B_BUSY | B_WRITEINPROG)) ==
bp 187 nfs/nfs_bio.c bp = nfs_getcacheblk(vp, bn, biosize, p);
bp 188 nfs/nfs_bio.c if (!bp)
bp 191 nfs/nfs_bio.c if ((bp->b_flags & (B_DONE | B_DELWRI)) == 0) {
bp 192 nfs/nfs_bio.c bp->b_flags |= B_READ;
bp 194 nfs/nfs_bio.c error = nfs_doio(bp, p);
bp 196 nfs/nfs_bio.c brelse(bp);
bp 206 nfs/nfs_bio.c if (on < bp->b_validoff || (on + n) > bp->b_validend) {
bp 208 nfs/nfs_bio.c bp = nfs_getcacheblk(vp, bn, biosize, p);
bp 209 nfs/nfs_bio.c if (!bp)
bp 213 nfs/nfs_bio.c bp->b_flags |= B_INVAFTERWRITE;
bp 214 nfs/nfs_bio.c if (bp->b_dirtyend > 0) {
bp 215 nfs/nfs_bio.c if ((bp->b_flags & B_DELWRI) == 0)
bp 217 nfs/nfs_bio.c if (VOP_BWRITE(bp) == EINTR)
bp 220 nfs/nfs_bio.c brelse(bp);
bp 224 nfs/nfs_bio.c diff = (on >= bp->b_validend) ? 0 : (bp->b_validend - on);
bp 230 nfs/nfs_bio.c bp = nfs_getcacheblk(vp, 0, NFS_MAXPATHLEN, p);
bp 231 nfs/nfs_bio.c if (!bp)
bp 233 nfs/nfs_bio.c if ((bp->b_flags & B_DONE) == 0) {
bp 234 nfs/nfs_bio.c bp->b_flags |= B_READ;
bp 235 nfs/nfs_bio.c error = nfs_doio(bp, p);
bp 237 nfs/nfs_bio.c brelse(bp);
bp 241 nfs/nfs_bio.c n = min(uio->uio_resid, NFS_MAXPATHLEN - bp->b_resid);
bp 252 nfs/nfs_bio.c baddr = bp->b_data;
bp 265 nfs/nfs_bio.c brelse(bp);
bp 285 nfs/nfs_bio.c struct buf *bp;
bp 361 nfs/nfs_bio.c bp = nfs_getcacheblk(vp, bn, biosize, p);
bp 362 nfs/nfs_bio.c if (!bp)
bp 377 nfs/nfs_bio.c if (bp->b_dirtyend > 0 &&
bp 378 nfs/nfs_bio.c (on > bp->b_dirtyend || (on + n) < bp->b_dirtyoff)) {
bp 379 nfs/nfs_bio.c bp->b_proc = p;
bp 380 nfs/nfs_bio.c if (VOP_BWRITE(bp) == EINTR)
bp 385 nfs/nfs_bio.c error = uiomove((char *)bp->b_data + on, n, uio);
bp 387 nfs/nfs_bio.c bp->b_flags |= B_ERROR;
bp 388 nfs/nfs_bio.c brelse(bp);
bp 391 nfs/nfs_bio.c if (bp->b_dirtyend > 0) {
bp 392 nfs/nfs_bio.c bp->b_dirtyoff = min(on, bp->b_dirtyoff);
bp 393 nfs/nfs_bio.c bp->b_dirtyend = max((on + n), bp->b_dirtyend);
bp 395 nfs/nfs_bio.c bp->b_dirtyoff = on;
bp 396 nfs/nfs_bio.c bp->b_dirtyend = on + n;
bp 398 nfs/nfs_bio.c if (bp->b_validend == 0 || bp->b_validend < bp->b_dirtyoff ||
bp 399 nfs/nfs_bio.c bp->b_validoff > bp->b_dirtyend) {
bp 400 nfs/nfs_bio.c bp->b_validoff = bp->b_dirtyoff;
bp 401 nfs/nfs_bio.c bp->b_validend = bp->b_dirtyend;
bp 403 nfs/nfs_bio.c bp->b_validoff = min(bp->b_validoff, bp->b_dirtyoff);
bp 404 nfs/nfs_bio.c bp->b_validend = max(bp->b_validend, bp->b_dirtyend);
bp 416 nfs/nfs_bio.c if (bp->b_flags & B_NEEDCOMMIT) {
bp 417 nfs/nfs_bio.c bp->b_flags &= ~B_NEEDCOMMIT;
bp 418 nfs/nfs_bio.c nfs_del_tobecommitted_range(vp, bp);
bp 420 nfs/nfs_bio.c nfs_del_committed_range(vp, bp);
bp 423 nfs/nfs_bio.c bp->b_flags &= ~B_NEEDCOMMIT;
bp 429 nfs/nfs_bio.c bp->b_proc = p;
bp 430 nfs/nfs_bio.c error = VOP_BWRITE(bp);
bp 434 nfs/nfs_bio.c bp->b_proc = (struct proc *)0;
bp 435 nfs/nfs_bio.c bp->b_flags |= B_ASYNC;
bp 436 nfs/nfs_bio.c (void)nfs_writebp(bp, 0);
bp 438 nfs/nfs_bio.c bdwrite(bp);
bp 463 nfs/nfs_bio.c struct buf *bp;
bp 467 nfs/nfs_bio.c bp = getblk(vp, bn, size, PCATCH, 0);
bp 468 nfs/nfs_bio.c while (bp == (struct buf *)0) {
bp 471 nfs/nfs_bio.c bp = getblk(vp, bn, size, 0, 2 * hz);
bp 474 nfs/nfs_bio.c bp = getblk(vp, bn, size, 0, 0);
bp 475 nfs/nfs_bio.c return (bp);
bp 544 nfs/nfs_bio.c nfs_asyncio(bp)
bp 545 nfs/nfs_bio.c struct buf *bp;
bp 553 nfs/nfs_bio.c if ((bp->b_flags & B_READ) == 0) {
bp 554 nfs/nfs_bio.c bp->b_flags |= B_WRITEINPROG;
bp 557 nfs/nfs_bio.c TAILQ_INSERT_TAIL(&nfs_bufq, bp, b_freelist);
bp 568 nfs/nfs_bio.c if (bp->b_flags & (B_READ | B_WRITEINPROG | B_NOCACHE))
bp 578 nfs/nfs_bio.c buf_dirty(bp);
bp 579 nfs/nfs_bio.c biodone(bp);
bp 589 nfs/nfs_bio.c nfs_doio(bp, p)
bp 590 nfs/nfs_bio.c struct buf *bp;
bp 601 nfs/nfs_bio.c vp = bp->b_vp;
bp 613 nfs/nfs_bio.c if (bp->b_flags & B_PHYS) {
bp 617 nfs/nfs_bio.c io.iov_len = uiop->uio_resid = bp->b_bcount;
bp 619 nfs/nfs_bio.c io.iov_base = bp->b_data;
bp 620 nfs/nfs_bio.c uiop->uio_offset = ((off_t)bp->b_blkno) << DEV_BSHIFT;
bp 621 nfs/nfs_bio.c if (bp->b_flags & B_READ) {
bp 632 nfs/nfs_bio.c bp->b_flags |= B_ERROR;
bp 633 nfs/nfs_bio.c bp->b_error = error;
bp 635 nfs/nfs_bio.c } else if (bp->b_flags & B_READ) {
bp 636 nfs/nfs_bio.c io.iov_len = uiop->uio_resid = bp->b_bcount;
bp 637 nfs/nfs_bio.c io.iov_base = bp->b_data;
bp 641 nfs/nfs_bio.c uiop->uio_offset = ((off_t)bp->b_blkno) << DEV_BSHIFT;
bp 645 nfs/nfs_bio.c bp->b_validoff = 0;
bp 653 nfs/nfs_bio.c diff = bp->b_bcount - uiop->uio_resid;
bp 654 nfs/nfs_bio.c len = np->n_size - ((((off_t)bp->b_blkno) << DEV_BSHIFT)
bp 658 nfs/nfs_bio.c bzero((char *)bp->b_data + diff, len);
bp 659 nfs/nfs_bio.c bp->b_validend = diff + len;
bp 661 nfs/nfs_bio.c bp->b_validend = diff;
bp 663 nfs/nfs_bio.c bp->b_validend = bp->b_bcount;
bp 681 nfs/nfs_bio.c bp->b_flags |= B_ERROR;
bp 682 nfs/nfs_bio.c bp->b_error = error;
bp 685 nfs/nfs_bio.c io.iov_len = uiop->uio_resid = bp->b_dirtyend
bp 686 nfs/nfs_bio.c - bp->b_dirtyoff;
bp 687 nfs/nfs_bio.c uiop->uio_offset = ((off_t)bp->b_blkno) * DEV_BSIZE
bp 688 nfs/nfs_bio.c + bp->b_dirtyoff;
bp 689 nfs/nfs_bio.c io.iov_base = (char *)bp->b_data + bp->b_dirtyoff;
bp 692 nfs/nfs_bio.c if ((bp->b_flags & (B_ASYNC | B_NEEDCOMMIT | B_NOCACHE)) == B_ASYNC)
bp 696 nfs/nfs_bio.c bp->b_flags |= B_WRITEINPROG;
bp 701 nfs/nfs_bio.c bp->b_flags |= B_NEEDCOMMIT;
bp 702 nfs/nfs_bio.c nfs_add_tobecommitted_range(vp, bp);
bp 704 nfs/nfs_bio.c bp->b_flags &= ~B_NEEDCOMMIT;
bp 705 nfs/nfs_bio.c nfs_del_committed_range(vp, bp);
bp 709 nfs/nfs_bio.c bp->b_flags &= ~B_WRITEINPROG;
bp 723 nfs/nfs_bio.c if (error == EINTR || (!error && (bp->b_flags & B_NEEDCOMMIT))) {
bp 725 nfs/nfs_bio.c buf_dirty(bp);
bp 728 nfs/nfs_bio.c if (!(bp->b_flags & B_ASYNC) && error)
bp 729 nfs/nfs_bio.c bp->b_flags |= B_EINTR;
bp 732 nfs/nfs_bio.c bp->b_flags |= B_ERROR;
bp 733 nfs/nfs_bio.c bp->b_error = np->n_error = error;
bp 736 nfs/nfs_bio.c bp->b_dirtyoff = bp->b_dirtyend = 0;
bp 739 nfs/nfs_bio.c bp->b_resid = uiop->uio_resid;
bp 743 nfs/nfs_bio.c biodone(bp);
bp 2367 nfs/nfs_serv.c char *bp, *be;
bp 2530 nfs/nfs_serv.c bp = bpos;
bp 2531 nfs/nfs_serv.c be = bp + M_TRAILINGSPACE(mp);
bp 2551 nfs/nfs_serv.c bp += NFSX_UNSIGNED;
bp 2555 nfs/nfs_serv.c bp += NFSX_UNSIGNED;
bp 2559 nfs/nfs_serv.c bp += NFSX_UNSIGNED;
bp 2562 nfs/nfs_serv.c bp += NFSX_UNSIGNED;
bp 2569 nfs/nfs_serv.c if ((bp+xfer) > be)
bp 2570 nfs/nfs_serv.c tsiz = be-bp;
bp 2573 nfs/nfs_serv.c bcopy(cp, bp, tsiz);
bp 2574 nfs/nfs_serv.c bp += tsiz;
bp 2581 nfs/nfs_serv.c *bp++ = '\0';
bp 2587 nfs/nfs_serv.c bp += NFSX_UNSIGNED;
bp 2591 nfs/nfs_serv.c bp += NFSX_UNSIGNED;
bp 2601 nfs/nfs_serv.c bp += NFSX_UNSIGNED;
bp 2607 nfs/nfs_serv.c bp += NFSX_UNSIGNED;
bp 2609 nfs/nfs_serv.c if (bp < be)
bp 2610 nfs/nfs_serv.c mp->m_len = bp - mtod(mp, caddr_t);
bp 2612 nfs/nfs_serv.c mp->m_len += bp - bpos;
bp 2629 nfs/nfs_serv.c char *bp, *be;
bp 2795 nfs/nfs_serv.c bp = bpos;
bp 2796 nfs/nfs_serv.c be = bp + M_TRAILINGSPACE(mp);
bp 2862 nfs/nfs_serv.c bp += NFSX_UNSIGNED;
bp 2865 nfs/nfs_serv.c bp += NFSX_UNSIGNED;
bp 2868 nfs/nfs_serv.c bp += NFSX_UNSIGNED;
bp 2871 nfs/nfs_serv.c bp += NFSX_UNSIGNED;
bp 2878 nfs/nfs_serv.c if ((bp + xfer) > be)
bp 2879 nfs/nfs_serv.c tsiz = be - bp;
bp 2882 nfs/nfs_serv.c bcopy(cp, bp, tsiz);
bp 2883 nfs/nfs_serv.c bp += tsiz;
bp 2890 nfs/nfs_serv.c *bp++ = '\0';
bp 2899 nfs/nfs_serv.c if ((bp + xfer) > be)
bp 2900 nfs/nfs_serv.c tsiz = be - bp;
bp 2903 nfs/nfs_serv.c bcopy(cp, bp, tsiz);
bp 2904 nfs/nfs_serv.c bp += tsiz;
bp 2919 nfs/nfs_serv.c bp += NFSX_UNSIGNED;
bp 2925 nfs/nfs_serv.c bp += NFSX_UNSIGNED;
bp 2927 nfs/nfs_serv.c if (bp < be)
bp 2928 nfs/nfs_serv.c mp->m_len = bp - mtod(mp, caddr_t);
bp 2930 nfs/nfs_serv.c mp->m_len += bp - bpos;
bp 1722 nfs/nfs_subs.c struct buf *bp, *nbp;
bp 1731 nfs/nfs_subs.c for (bp = LIST_FIRST(&vp->v_dirtyblkhd); bp != NULL; bp = nbp) {
bp 1732 nfs/nfs_subs.c nbp = LIST_NEXT(bp, b_vnbufs);
bp 1733 nfs/nfs_subs.c if ((bp->b_flags & (B_BUSY | B_DELWRI | B_NEEDCOMMIT))
bp 1735 nfs/nfs_subs.c bp->b_flags &= ~B_NEEDCOMMIT;
bp 1763 nfs/nfs_subs.c nfs_in_committed_range(vp, bp)
bp 1765 nfs/nfs_subs.c struct buf *bp;
bp 1772 nfs/nfs_subs.c lo = (off_t)bp->b_blkno * DEV_BSIZE;
bp 1773 nfs/nfs_subs.c hi = lo + bp->b_dirtyend;
bp 1779 nfs/nfs_subs.c nfs_in_tobecommitted_range(vp, bp)
bp 1781 nfs/nfs_subs.c struct buf *bp;
bp 1788 nfs/nfs_subs.c lo = (off_t)bp->b_blkno * DEV_BSIZE;
bp 1789 nfs/nfs_subs.c hi = lo + bp->b_dirtyend;
bp 1795 nfs/nfs_subs.c nfs_add_committed_range(vp, bp)
bp 1797 nfs/nfs_subs.c struct buf *bp;
bp 1802 nfs/nfs_subs.c lo = (off_t)bp->b_blkno * DEV_BSIZE;
bp 1803 nfs/nfs_subs.c hi = lo + bp->b_dirtyend;
bp 1818 nfs/nfs_subs.c nfs_del_committed_range(vp, bp)
bp 1820 nfs/nfs_subs.c struct buf *bp;
bp 1828 nfs/nfs_subs.c lo = (off_t)bp->b_blkno * DEV_BSIZE;
bp 1829 nfs/nfs_subs.c hi = lo + bp->b_dirtyend;
bp 1851 nfs/nfs_subs.c nfs_add_tobecommitted_range(vp, bp)
bp 1853 nfs/nfs_subs.c struct buf *bp;
bp 1858 nfs/nfs_subs.c lo = (off_t)bp->b_blkno * DEV_BSIZE;
bp 1859 nfs/nfs_subs.c hi = lo + bp->b_dirtyend;
bp 1874 nfs/nfs_subs.c nfs_del_tobecommitted_range(vp, bp)
bp 1876 nfs/nfs_subs.c struct buf *bp;
bp 1884 nfs/nfs_subs.c lo = (off_t)bp->b_blkno * DEV_BSIZE;
bp 1885 nfs/nfs_subs.c hi = lo + bp->b_dirtyend;
bp 697 nfs/nfs_syscalls.c struct buf *bp, *nbp;
bp 724 nfs/nfs_syscalls.c while ((bp = TAILQ_FIRST(&nfs_bufq)) != NULL) {
bp 726 nfs/nfs_syscalls.c TAILQ_REMOVE(&nfs_bufq, bp, b_freelist);
bp 727 nfs/nfs_syscalls.c if (bp->b_flags & B_READ)
bp 728 nfs/nfs_syscalls.c (void) nfs_doio(bp, NULL);
bp 736 nfs/nfs_syscalls.c vp = bp->b_vp;
bp 758 nfs/nfs_syscalls.c (void) nfs_doio(bp, NULL);
bp 759 nfs/nfs_syscalls.c } while ((bp = nbp) != NULL);
bp 2601 nfs/nfs_vnops.c struct buf *bp = ap->a_bp;
bp 2605 nfs/nfs_vnops.c if ((bp->b_flags & (B_PHYS|B_ASYNC)) == (B_PHYS|B_ASYNC))
bp 2607 nfs/nfs_vnops.c if (bp->b_flags & B_ASYNC)
bp 2616 nfs/nfs_vnops.c if ((bp->b_flags & B_ASYNC) == 0 || nfs_asyncio(bp))
bp 2617 nfs/nfs_vnops.c error = nfs_doio(bp, p);
bp 2648 nfs/nfs_vnops.c struct buf *bp;
bp 2675 nfs/nfs_vnops.c for (bp = LIST_FIRST(&vp->v_dirtyblkhd); bp != NULL; bp = nbp) {
bp 2676 nfs/nfs_vnops.c nbp = LIST_NEXT(bp, b_vnbufs);
bp 2679 nfs/nfs_vnops.c if ((bp->b_flags & (B_BUSY | B_DELWRI | B_NEEDCOMMIT))
bp 2682 nfs/nfs_vnops.c bremfree(bp);
bp 2683 nfs/nfs_vnops.c bp->b_flags |= (B_BUSY | B_WRITEINPROG);
bp 2691 nfs/nfs_vnops.c bvec[bvecpos++] = bp;
bp 2692 nfs/nfs_vnops.c toff = ((u_quad_t)bp->b_blkno) * DEV_BSIZE +
bp 2693 nfs/nfs_vnops.c bp->b_dirtyoff;
bp 2696 nfs/nfs_vnops.c toff += (u_quad_t)(bp->b_dirtyend - bp->b_dirtyoff);
bp 2715 nfs/nfs_vnops.c bp = bvec[i];
bp 2716 nfs/nfs_vnops.c bp->b_flags &= ~(B_NEEDCOMMIT | B_WRITEINPROG);
bp 2718 nfs/nfs_vnops.c brelse(bp);
bp 2721 nfs/nfs_vnops.c buf_undirty(bp);
bp 2723 nfs/nfs_vnops.c bp->b_flags |= B_ASYNC;
bp 2724 nfs/nfs_vnops.c bp->b_flags &= ~(B_READ|B_DONE|B_ERROR);
bp 2725 nfs/nfs_vnops.c bp->b_dirtyoff = bp->b_dirtyend = 0;
bp 2726 nfs/nfs_vnops.c biodone(bp);
bp 2737 nfs/nfs_vnops.c for (bp = LIST_FIRST(&vp->v_dirtyblkhd); bp != NULL; bp = nbp) {
bp 2738 nfs/nfs_vnops.c nbp = LIST_NEXT(bp, b_vnbufs);
bp 2739 nfs/nfs_vnops.c if (bp->b_flags & B_BUSY) {
bp 2742 nfs/nfs_vnops.c bp->b_flags |= B_WANTED;
bp 2743 nfs/nfs_vnops.c error = tsleep((caddr_t)bp, slpflag | (PRIBIO + 1),
bp 2756 nfs/nfs_vnops.c if ((bp->b_flags & B_DELWRI) == 0)
bp 2758 nfs/nfs_vnops.c if ((passone || !commit) && (bp->b_flags & B_NEEDCOMMIT))
bp 2760 nfs/nfs_vnops.c bremfree(bp);
bp 2762 nfs/nfs_vnops.c bp->b_flags |= (B_BUSY|B_ASYNC);
bp 2764 nfs/nfs_vnops.c bp->b_flags |= (B_BUSY|B_ASYNC|B_WRITEINPROG|B_NEEDCOMMIT);
bp 2766 nfs/nfs_vnops.c VOP_BWRITE(bp);
bp 2873 nfs/nfs_vnops.c nfs_writebp(bp, force)
bp 2874 nfs/nfs_vnops.c struct buf *bp;
bp 2877 nfs/nfs_vnops.c int oldflags = bp->b_flags, retv = 1;
bp 2885 nfs/nfs_vnops.c if(!(bp->b_flags & B_BUSY))
bp 2888 nfs/nfs_vnops.c vp = bp->b_vp;
bp 2891 nfs/nfs_vnops.c bp->b_flags &= ~(B_READ|B_DONE|B_ERROR);
bp 2894 nfs/nfs_vnops.c buf_undirty(bp);
bp 2899 nfs/nfs_vnops.c bp->b_vp->v_numoutput++;
bp 2908 nfs/nfs_vnops.c off = ((u_quad_t)bp->b_blkno) * DEV_BSIZE + bp->b_dirtyoff;
bp 2909 nfs/nfs_vnops.c cnt = bp->b_dirtyend - bp->b_dirtyoff;
bp 2912 nfs/nfs_vnops.c if (!(bp->b_flags & B_NEEDCOMMIT)) {
bp 2921 nfs/nfs_vnops.c if (!nfs_in_committed_range(vp, bp)) {
bp 2928 nfs/nfs_vnops.c if (nfs_in_tobecommitted_range(vp, bp)) {
bp 2934 nfs/nfs_vnops.c bp->b_flags |= B_WRITEINPROG;
bp 2935 nfs/nfs_vnops.c retv = nfs_commit(bp->b_vp, off, cnt, bp->b_proc);
bp 2936 nfs/nfs_vnops.c bp->b_flags &= ~B_WRITEINPROG;
bp 2942 nfs/nfs_vnops.c nfs_add_committed_range(vp, bp);
bp 2949 nfs/nfs_vnops.c bp->b_dirtyoff = bp->b_dirtyend = 0;
bp 2950 nfs/nfs_vnops.c bp->b_flags &= ~B_NEEDCOMMIT;
bp 2952 nfs/nfs_vnops.c biodone(bp);
bp 2955 nfs/nfs_vnops.c nfs_clearcommit(bp->b_vp->v_mount);
bp 2959 nfs/nfs_vnops.c bp->b_flags |= B_WRITEINPROG;
bp 2960 nfs/nfs_vnops.c VOP_STRATEGY(bp);
bp 2964 nfs/nfs_vnops.c int rtval = biowait(bp);
bp 2968 nfs/nfs_vnops.c brelse(bp);
bp 424 nfs/nfsm_subs.h if (bp >= be) { \
bp 426 nfs/nfsm_subs.h mp->m_len += bp-bpos; \
bp 432 nfs/nfsm_subs.h bp = mtod(mp, caddr_t); \
bp 433 nfs/nfsm_subs.h be = bp+mp->m_len; \
bp 435 nfs/nfsm_subs.h tl = (u_int32_t *)bp
bp 303 ntfs/ntfs.h #define bqrelse(bp) brelse(bp)
bp 311 ntfs/ntfs.h #define bqrelse(bp) brelse(bp)
bp 307 ntfs/ntfs_subr.c struct buf *bp;
bp 316 ntfs/ntfs_subr.c NOCRED, &bp);
bp 319 ntfs/ntfs_subr.c brelse(bp);
bp 322 ntfs/ntfs_subr.c memcpy(mfrp, bp->b_data, ntfs_bntob(ntmp->ntm_bpmftrec));
bp 323 ntfs/ntfs_subr.c bqrelse(bp);
bp 1547 ntfs/ntfs_subr.c struct buf *bp;
bp 1603 ntfs/ntfs_subr.c bp = getblk(ntmp->ntm_devvp, ntfs_cntobn(cn),
bp 1605 ntfs/ntfs_subr.c clrbuf(bp);
bp 1608 ntfs/ntfs_subr.c ntfs_cntob(cl), NOCRED, &bp);
bp 1610 ntfs/ntfs_subr.c brelse(bp);
bp 1615 ntfs/ntfs_subr.c uiomove(bp->b_data + off, tocopy, uio);
bp 1617 ntfs/ntfs_subr.c memcpy(bp->b_data + off, data, tocopy);
bp 1618 ntfs/ntfs_subr.c bawrite(bp);
bp 1660 ntfs/ntfs_subr.c struct buf *bp;
bp 1715 ntfs/ntfs_subr.c NOCRED, &bp);
bp 1717 ntfs/ntfs_subr.c brelse(bp);
bp 1721 ntfs/ntfs_subr.c uiomove(bp->b_data + off,
bp 1724 ntfs/ntfs_subr.c memcpy(data, bp->b_data + off,
bp 1727 ntfs/ntfs_subr.c brelse(bp);
bp 514 ntfs/ntfs_vfsops.c struct buf *bp;
bp 541 ntfs/ntfs_vfsops.c bp = NULL;
bp 543 ntfs/ntfs_vfsops.c error = bread(devvp, BBLOCK, BBSIZE, NOCRED, &bp);
bp 548 ntfs/ntfs_vfsops.c bcopy(bp->b_data, &ntmp->ntm_bootfile, sizeof(struct bootfile));
bp 549 ntfs/ntfs_vfsops.c brelse(bp);
bp 550 ntfs/ntfs_vfsops.c bp = NULL;
bp 699 ntfs/ntfs_vfsops.c if (bp)
bp 700 ntfs/ntfs_vfsops.c brelse(bp);
bp 323 ntfs/ntfs_vnops.c struct buf *bp = ap->a_bp;
bp 324 ntfs/ntfs_vnops.c struct vnode *vp = bp->b_vp;
bp 332 ntfs/ntfs_vnops.c (u_int32_t)bp->b_offset,(u_int32_t)bp->b_blkno,
bp 333 ntfs/ntfs_vnops.c (u_int32_t)bp->b_lblkno));
bp 336 ntfs/ntfs_vnops.c (u_int32_t)bp->b_blkno,
bp 337 ntfs/ntfs_vnops.c (u_int32_t)bp->b_lblkno));
bp 341 ntfs/ntfs_vnops.c (u_int32_t)bp->b_bcount,bp->b_flags));
bp 343 ntfs/ntfs_vnops.c if (bp->b_flags & B_READ) {
bp 346 ntfs/ntfs_vnops.c if (ntfs_cntob(bp->b_blkno) >= fp->f_size) {
bp 347 ntfs/ntfs_vnops.c clrbuf(bp);
bp 350 ntfs/ntfs_vnops.c toread = MIN(bp->b_bcount,
bp 351 ntfs/ntfs_vnops.c fp->f_size - ntfs_cntob(bp->b_blkno));
bp 356 ntfs/ntfs_vnops.c fp->f_attrname, ntfs_cntob(bp->b_blkno),
bp 357 ntfs/ntfs_vnops.c toread, bp->b_data, NULL);
bp 361 ntfs/ntfs_vnops.c bp->b_error = error;
bp 362 ntfs/ntfs_vnops.c bp->b_flags |= B_ERROR;
bp 365 ntfs/ntfs_vnops.c bzero(bp->b_data + toread, bp->b_bcount - toread);
bp 371 ntfs/ntfs_vnops.c if (ntfs_cntob(bp->b_blkno) + bp->b_bcount >= fp->f_size) {
bp 373 ntfs/ntfs_vnops.c bp->b_error = error = EFBIG;
bp 374 ntfs/ntfs_vnops.c bp->b_flags |= B_ERROR;
bp 376 ntfs/ntfs_vnops.c towrite = MIN(bp->b_bcount,
bp 377 ntfs/ntfs_vnops.c fp->f_size - ntfs_cntob(bp->b_blkno));
bp 382 ntfs/ntfs_vnops.c fp->f_attrname, ntfs_cntob(bp->b_blkno),towrite,
bp 383 ntfs/ntfs_vnops.c bp->b_data, &tmp, NULL);
bp 387 ntfs/ntfs_vnops.c bp->b_error = error;
bp 388 ntfs/ntfs_vnops.c bp->b_flags |= B_ERROR;
bp 392 ntfs/ntfs_vnops.c biodone(bp);
bp 452 scsi/cd.c cdstrategy(struct buf *bp)
bp 457 scsi/cd.c if ((cd = cdlookup(DISKUNIT(bp->b_dev))) == NULL) {
bp 458 scsi/cd.c bp->b_error = ENXIO;
bp 463 scsi/cd.c bp->b_bcount, bp->b_blkno));
bp 469 scsi/cd.c bp->b_error = EIO;
bp 475 scsi/cd.c if ((bp->b_bcount % cd->sc_dk.dk_label->d_secsize) != 0) {
bp 476 scsi/cd.c bp->b_error = EINVAL;
bp 482 scsi/cd.c if (bp->b_bcount == 0)
bp 489 scsi/cd.c if (DISKPART(bp->b_dev) != RAW_PART &&
bp 490 scsi/cd.c bounds_check_with_label(bp, cd->sc_dk.dk_label,
bp 499 scsi/cd.c disksort(&cd->buf_queue, bp);
bp 512 scsi/cd.c bp->b_flags |= B_ERROR;
bp 517 scsi/cd.c bp->b_resid = bp->b_bcount;
bp 519 scsi/cd.c biodone(bp);
bp 546 scsi/cd.c struct buf *bp = 0;
bp 576 scsi/cd.c if ((bp = dp->b_actf) == NULL) /* yes, an assign */
bp 578 scsi/cd.c dp->b_actf = bp->b_actf;
bp 586 scsi/cd.c bp->b_error = EIO;
bp 587 scsi/cd.c bp->b_flags |= B_ERROR;
bp 588 scsi/cd.c bp->b_resid = bp->b_bcount;
bp 589 scsi/cd.c biodone(bp);
bp 600 scsi/cd.c bp->b_blkno / (cd->sc_dk.dk_label->d_secsize / DEV_BSIZE);
bp 601 scsi/cd.c p = &cd->sc_dk.dk_label->d_partitions[DISKPART(bp->b_dev)];
bp 603 scsi/cd.c nblks = howmany(bp->b_bcount, cd->sc_dk.dk_label->d_secsize);
bp 617 scsi/cd.c cmd_small.opcode = (bp->b_flags & B_READ) ?
bp 628 scsi/cd.c cmd_big.opcode = (bp->b_flags & B_READ) ?
bp 644 scsi/cd.c (u_char *) bp->b_data, bp->b_bcount, CDRETRIES, 30000, bp,
bp 645 scsi/cd.c SCSI_NOSLEEP | ((bp->b_flags & B_READ) ? SCSI_DATA_IN :
bp 655 scsi/cd.c dp->b_actf = bp;
bp 683 scsi/cd.c if (xs->bp != NULL)
bp 684 scsi/cd.c disk_unbusy(&cd->sc_dk, xs->bp->b_bcount - xs->bp->b_resid,
bp 685 scsi/cd.c (xs->bp->b_flags & B_READ));
bp 689 scsi/cd.c cdminphys(struct buf *bp)
bp 694 scsi/cd.c cd = cdlookup(DISKUNIT(bp->b_dev));
bp 712 scsi/cd.c if (bp->b_bcount > max)
bp 713 scsi/cd.c bp->b_bcount = max;
bp 716 scsi/cd.c (*cd->sc_link->adapter->scsi_minphys)(bp);
bp 2035 scsi/cd.c struct buf *dp, *bp;
bp 2039 scsi/cd.c for (dp = &cd->buf_queue; (bp = dp->b_actf) != NULL; ) {
bp 2040 scsi/cd.c dp->b_actf = bp->b_actf;
bp 2042 scsi/cd.c bp->b_error = ENXIO;
bp 2043 scsi/cd.c bp->b_flags |= B_ERROR;
bp 2044 scsi/cd.c biodone(bp);
bp 183 scsi/scsi_base.c struct buf *bp, int flags)
bp 202 scsi/scsi_base.c xs->bp = bp;
bp 685 scsi/scsi_base.c struct buf *bp;
bp 740 scsi/scsi_base.c bp = xs->bp;
bp 741 scsi/scsi_base.c if (bp != NULL) {
bp 743 scsi/scsi_base.c bp->b_error = error;
bp 744 scsi/scsi_base.c bp->b_flags |= B_ERROR;
bp 745 scsi/scsi_base.c bp->b_resid = bp->b_bcount;
bp 747 scsi/scsi_base.c bp->b_error = 0;
bp 748 scsi/scsi_base.c bp->b_resid = xs->resid;
bp 762 scsi/scsi_base.c if (bp != NULL)
bp 763 scsi/scsi_base.c biodone(bp);
bp 832 scsi/scsi_base.c if (xs->bp)
bp 866 scsi/scsi_base.c struct buf *bp, int flags)
bp 875 scsi/scsi_base.c if (bp != NULL && (flags & SCSI_NOSLEEP) == 0)
bp 880 scsi/scsi_base.c retries, timeout, bp, flags)) == NULL)
bp 1929 scsi/scsi_base.c printf("bp(%p)", xs->bp);
bp 138 scsi/scsi_ioctl.c si_find(struct buf *bp)
bp 145 scsi/scsi_ioctl.c if (bp == &si->si_bp)
bp 164 scsi/scsi_ioctl.c struct buf *bp;
bp 171 scsi/scsi_ioctl.c bp = xs->bp;
bp 172 scsi/scsi_ioctl.c if (bp == NULL) { /* ALL user requests must have a buf */
bp 178 scsi/scsi_ioctl.c si = si_find(bp);
bp 231 scsi/scsi_ioctl.c biodone(bp); /* we're waiting on it in scsi_strategy() */
bp 251 scsi/scsi_ioctl.c scsistrategy(struct buf *bp)
bp 260 scsi/scsi_ioctl.c si = si_find(bp);
bp 274 scsi/scsi_ioctl.c if (bp->b_bcount != screq->datalen) {
bp 303 scsi/scsi_ioctl.c screq->cmdlen, (u_char *)bp->b_data, screq->datalen,
bp 305 scsi/scsi_ioctl.c screq->timeout, bp, flags | SCSI_USER | SCSI_NOSLEEP);
bp 313 scsi/scsi_ioctl.c while ((bp->b_flags & B_DONE) == 0)
bp 314 scsi/scsi_ioctl.c tsleep(bp, PRIBIO, "scistr", 0);
bp 321 scsi/scsi_ioctl.c bp->b_flags |= B_ERROR;
bp 322 scsi/scsi_ioctl.c bp->b_error = error;
bp 324 scsi/scsi_ioctl.c biodone(bp);
bp 241 scsi/scsiconf.h struct buf *bp; /* If we need to associate with a buf */
bp 338 scsi/scsiconf.h int timeout, struct buf *bp, int flags);
bp 492 scsi/sd.c sdstrategy(struct buf *bp)
bp 497 scsi/sd.c sd = sdlookup(DISKUNIT(bp->b_dev));
bp 499 scsi/sd.c bp->b_error = ENXIO;
bp 504 scsi/sd.c bp->b_bcount, bp->b_blkno));
bp 510 scsi/sd.c bp->b_error = EIO;
bp 512 scsi/sd.c bp->b_error = ENODEV;
bp 518 scsi/sd.c if (bp->b_bcount == 0)
bp 524 scsi/sd.c if ((bp->b_bcount % sd->sc_dk.dk_label->d_secsize) != 0) {
bp 525 scsi/sd.c bp->b_error = EINVAL;
bp 532 scsi/sd.c if (DISKPART(bp->b_dev) != RAW_PART &&
bp 533 scsi/sd.c bounds_check_with_label(bp, sd->sc_dk.dk_label,
bp 542 scsi/sd.c disksort(&sd->buf_queue, bp);
bp 556 scsi/sd.c bp->b_flags |= B_ERROR;
bp 561 scsi/sd.c bp->b_resid = bp->b_bcount;
bp 563 scsi/sd.c biodone(bp);
bp 590 scsi/sd.c struct buf *bp = 0;
bp 624 scsi/sd.c if ((bp = dp->b_actf) == NULL) /* yes, an assign */
bp 626 scsi/sd.c dp->b_actf = bp->b_actf;
bp 634 scsi/sd.c bp->b_error = EIO;
bp 635 scsi/sd.c bp->b_flags |= B_ERROR;
bp 636 scsi/sd.c bp->b_resid = bp->b_bcount;
bp 637 scsi/sd.c biodone(bp);
bp 648 scsi/sd.c bp->b_blkno / (sd->sc_dk.dk_label->d_secsize / DEV_BSIZE);
bp 649 scsi/sd.c p = &sd->sc_dk.dk_label->d_partitions[DISKPART(bp->b_dev)];
bp 651 scsi/sd.c nblks = howmany(bp->b_bcount, sd->sc_dk.dk_label->d_secsize);
bp 665 scsi/sd.c cmd_small.opcode = (bp->b_flags & B_READ) ?
bp 677 scsi/sd.c cmd_big.opcode = (bp->b_flags & B_READ) ?
bp 689 scsi/sd.c cmd_12.opcode = (bp->b_flags & B_READ) ?
bp 700 scsi/sd.c cmd_16.opcode = (bp->b_flags & B_READ) ?
bp 716 scsi/sd.c (u_char *)bp->b_data, bp->b_bcount,
bp 717 scsi/sd.c SDRETRIES, 60000, bp, SCSI_NOSLEEP |
bp 718 scsi/sd.c ((bp->b_flags & B_READ) ? SCSI_DATA_IN : SCSI_DATA_OUT));
bp 725 scsi/sd.c if ((bp->b_flags & B_READ) == 0)
bp 733 scsi/sd.c dp->b_actf = bp;
bp 766 scsi/sd.c if (xs->bp != NULL)
bp 767 scsi/sd.c disk_unbusy(&sd->sc_dk, (xs->bp->b_bcount - xs->bp->b_resid),
bp 768 scsi/sd.c (xs->bp->b_flags & B_READ));
bp 772 scsi/sd.c sdminphys(struct buf *bp)
bp 777 scsi/sd.c sd = sdlookup(DISKUNIT(bp->b_dev));
bp 795 scsi/sd.c if (bp->b_bcount > max)
bp 796 scsi/sd.c bp->b_bcount = max;
bp 799 scsi/sd.c (*sd->sc_link->adapter->scsi_minphys)(bp);
bp 1259 scsi/sd.c xs->bp = NULL;
bp 1488 scsi/sd.c struct buf *dp, *bp;
bp 1492 scsi/sd.c for (dp = &sd->buf_queue; (bp = dp->b_actf) != NULL; ) {
bp 1493 scsi/sd.c dp->b_actf = bp->b_actf;
bp 1495 scsi/sd.c bp->b_error = ENXIO;
bp 1496 scsi/sd.c bp->b_flags |= B_ERROR;
bp 1497 scsi/sd.c biodone(bp);
bp 503 scsi/ss.c ssminphys(bp)
bp 504 scsi/ss.c struct buf *bp;
bp 506 scsi/ss.c struct ss_softc *ss = ss_cd.cd_devs[SSUNIT(bp->b_dev)];
bp 508 scsi/ss.c (ss->sc_link->adapter->scsi_minphys)(bp);
bp 517 scsi/ss.c (ss->special.minphys)(ss, bp);
bp 561 scsi/ss.c ssstrategy(bp)
bp 562 scsi/ss.c struct buf *bp;
bp 564 scsi/ss.c struct ss_softc *ss = ss_cd.cd_devs[SSUNIT(bp->b_dev)];
bp 569 scsi/ss.c bp->b_bcount, bp->b_blkno));
bp 571 scsi/ss.c if (bp->b_bcount > ss->sio.scan_window_size)
bp 572 scsi/ss.c bp->b_bcount = ss->sio.scan_window_size;
bp 577 scsi/ss.c if (bp->b_bcount == 0)
bp 588 scsi/ss.c bp->b_actf = NULL;
bp 589 scsi/ss.c bp->b_actb = dp->b_actb;
bp 590 scsi/ss.c *dp->b_actb = bp;
bp 591 scsi/ss.c dp->b_actb = &bp->b_actf;
bp 607 scsi/ss.c bp->b_resid = bp->b_bcount;
bp 609 scsi/ss.c biodone(bp);
bp 633 scsi/ss.c struct buf *bp, *dp;
bp 654 scsi/ss.c if ((bp = dp->b_actf) == NULL)
bp 656 scsi/ss.c if ((dp = bp->b_actf) != NULL)
bp 657 scsi/ss.c dp->b_actb = bp->b_actb;
bp 659 scsi/ss.c ss->buf_queue.b_actb = bp->b_actb;
bp 660 scsi/ss.c *bp->b_actb = dp;
bp 663 scsi/ss.c (ss->special.read)(ss, bp);
bp 668 scsi/ss.c _lto3b(bp->b_bcount, read_cmd.len);
bp 674 scsi/ss.c &read_cmd, sizeof(read_cmd), (u_char *) bp->b_data,
bp 675 scsi/ss.c bp->b_bcount, 0, 100000, bp, flags | SCSI_NOSLEEP))
bp 981 scsi/ss.c get_buffer_status(ss, bp)
bp 983 scsi/ss.c struct buf *bp;
bp 1004 scsi/ss.c 0, 100000, bp, flags | SCSI_NOSLEEP)) {
bp 1007 scsi/ss.c bp->b_bcount = MIN(_3btol(buf_sz_retn.tgt_send_buf_len), bp->b_bcount);
bp 232 scsi/ss_mustek.c mustek_minphys(ss, bp)
bp 234 scsi/ss_mustek.c struct buf *bp;
bp 241 scsi/ss_mustek.c bp->b_bcount));
bp 242 scsi/ss_mustek.c bp->b_bcount -= bp->b_bcount %
bp 245 scsi/ss_mustek.c bp->b_bcount));
bp 439 scsi/ss_mustek.c mustek_read(ss, bp)
bp 441 scsi/ss_mustek.c struct buf *bp;
bp 453 scsi/ss_mustek.c lines_to_read = bp->b_bcount /
bp 463 scsi/ss_mustek.c (u_char *) bp->b_data, bp->b_bcount, MUSTEK_RETRIES, 10000, bp,
bp 468 scsi/ss_mustek.c ss->sio.scan_window_size -= bp->b_bcount;
bp 282 scsi/ss_scanjet.c scanjet_read(ss, bp)
bp 284 scsi/ss_scanjet.c struct buf *bp;
bp 299 scsi/ss_scanjet.c _lto3b(bp->b_bcount, cmd.len);
bp 305 scsi/ss_scanjet.c (u_char *) bp->b_data, bp->b_bcount, SCANJET_RETRIES, 100000, bp,
bp 309 scsi/ss_scanjet.c if (bp->b_bcount >= ss->sio.scan_window_size)
bp 312 scsi/ss_scanjet.c ss->sio.scan_window_size -= bp->b_bcount;
bp 771 scsi/st.c ststrategy(bp)
bp 772 scsi/st.c struct buf *bp;
bp 774 scsi/st.c struct st_softc *st = st_cd.cd_devs[STUNIT(bp->b_dev)];
bp 779 scsi/st.c bp->b_bcount, bp->b_blkno));
bp 783 scsi/st.c if (bp->b_bcount == 0)
bp 789 scsi/st.c if (bp->b_bcount % st->blksize) {
bp 792 scsi/st.c bp->b_error = EIO;
bp 799 scsi/st.c else if (bp->b_bcount < st->blkmin ||
bp 800 scsi/st.c (st->blkmax && bp->b_bcount > st->blkmax)) {
bp 803 scsi/st.c bp->b_error = EIO;
bp 814 scsi/st.c bp->b_actf = NULL;
bp 815 scsi/st.c bp->b_actb = dp->b_actb;
bp 816 scsi/st.c *dp->b_actb = bp;
bp 817 scsi/st.c dp->b_actb = &bp->b_actf;
bp 829 scsi/st.c bp->b_flags |= B_ERROR;
bp 834 scsi/st.c bp->b_resid = bp->b_bcount;
bp 836 scsi/st.c biodone(bp);
bp 860 scsi/st.c struct buf *bp, *dp;
bp 881 scsi/st.c if ((bp = dp->b_actf) == NULL)
bp 883 scsi/st.c if ((dp = bp->b_actf) != NULL)
bp 884 scsi/st.c dp->b_actb = bp->b_actb;
bp 886 scsi/st.c st->buf_queue.b_actb = bp->b_actb;
bp 887 scsi/st.c *bp->b_actb = dp;
bp 897 scsi/st.c bp->b_flags |= B_ERROR;
bp 898 scsi/st.c bp->b_resid = bp->b_bcount;
bp 899 scsi/st.c bp->b_error = EIO;
bp 900 scsi/st.c biodone(bp);
bp 912 scsi/st.c if ((bp->b_flags & B_READ) == B_WRITE) {
bp 920 scsi/st.c bp->b_flags |= B_ERROR;
bp 921 scsi/st.c bp->b_resid = bp->b_bcount;
bp 922 scsi/st.c bp->b_error = EIO;
bp 923 scsi/st.c biodone(bp);
bp 927 scsi/st.c bp->b_resid = bp->b_bcount;
bp 928 scsi/st.c bp->b_error = 0;
bp 929 scsi/st.c bp->b_flags &= ~B_ERROR;
bp 931 scsi/st.c biodone(bp);
bp 940 scsi/st.c bp->b_resid = bp->b_bcount;
bp 941 scsi/st.c bp->b_error = EIO;
bp 942 scsi/st.c bp->b_flags |= B_ERROR;
bp 944 scsi/st.c biodone(bp);
bp 953 scsi/st.c if ((bp->b_flags & B_READ) == B_WRITE) {
bp 969 scsi/st.c _lto3b(bp->b_bcount / st->blksize, cmd.len);
bp 971 scsi/st.c _lto3b(bp->b_bcount, cmd.len);
bp 985 scsi/st.c sizeof(cmd), (u_char *) bp->b_data, bp->b_bcount, 0,
bp 986 scsi/st.c ST_IO_TIME, bp, flags | SCSI_NOSLEEP);
bp 995 scsi/st.c dp->b_actf = bp;
bp 1813 scsi/st.c struct buf *bp = xs->bp;
bp 1870 scsi/st.c if (bp)
bp 1871 scsi/st.c bp->b_resid = xs->resid;
bp 1879 scsi/st.c if (bp)
bp 1880 scsi/st.c bp->b_resid = xs->resid;
bp 1884 scsi/st.c if (bp)
bp 1885 scsi/st.c bp->b_resid = xs->resid;
bp 1909 scsi/st.c if (bp)
bp 1910 scsi/st.c bp->b_resid = xs->resid;
bp 1923 scsi/st.c if (bp)
bp 1924 scsi/st.c bp->b_resid = bp->b_bcount;
bp 1950 scsi/st.c if (bp)
bp 1951 scsi/st.c bp->b_resid = info;
bp 1969 scsi/st.c if (bp) {
bp 1970 scsi/st.c bp->b_resid = xs->resid;
bp 188 sys/buf.h #define clrbuf(bp) { \
bp 189 sys/buf.h bzero((bp)->b_data, (u_int)(bp)->b_bcount); \
bp 190 sys/buf.h (bp)->b_resid = 0; \
bp 231 sys/buf.h void minphys(struct buf *bp);
bp 232 sys/buf.h int physio(void (*strategy)(struct buf *), struct buf *bp, dev_t dev,
bp 249 sys/buf.h buf_start(struct buf *bp)
bp 252 sys/buf.h (*bioops.io_start)(bp);
bp 256 sys/buf.h buf_complete(struct buf *bp)
bp 259 sys/buf.h (*bioops.io_complete)(bp);
bp 263 sys/buf.h buf_deallocate(struct buf *bp)
bp 266 sys/buf.h (*bioops.io_deallocate)(bp);
bp 270 sys/buf.h buf_movedeps(struct buf *bp, struct buf *bp2)
bp 273 sys/buf.h (*bioops.io_movedeps)(bp, bp2);
bp 277 sys/buf.h buf_countdeps(struct buf *bp, int i, int islocked)
bp 280 sys/buf.h return ((*bioops.io_countdeps)(bp, i, islocked));
bp 90 sys/conf.h void (*d_strategy)(struct buf *bp);
bp 319 ufs/ext2fs/ext2fs_alloc.c struct buf *bp;
bp 327 ufs/ext2fs/ext2fs_alloc.c (int)fs->e2fs_bsize, NOCRED, &bp);
bp 329 ufs/ext2fs/ext2fs_alloc.c brelse(bp);
bp 332 ufs/ext2fs/ext2fs_alloc.c bbp = (char *)bp->b_data;
bp 385 ufs/ext2fs/ext2fs_alloc.c bdwrite(bp);
bp 403 ufs/ext2fs/ext2fs_alloc.c struct buf *bp;
bp 412 ufs/ext2fs/ext2fs_alloc.c (int)fs->e2fs_bsize, NOCRED, &bp);
bp 414 ufs/ext2fs/ext2fs_alloc.c brelse(bp);
bp 417 ufs/ext2fs/ext2fs_alloc.c ibp = (char *)bp->b_data;
bp 456 ufs/ext2fs/ext2fs_alloc.c bdwrite(bp);
bp 471 ufs/ext2fs/ext2fs_alloc.c struct buf *bp;
bp 483 ufs/ext2fs/ext2fs_alloc.c (int)fs->e2fs_bsize, NOCRED, &bp);
bp 485 ufs/ext2fs/ext2fs_alloc.c brelse(bp);
bp 488 ufs/ext2fs/ext2fs_alloc.c bbp = (char *)bp->b_data;
bp 500 ufs/ext2fs/ext2fs_alloc.c bdwrite(bp);
bp 513 ufs/ext2fs/ext2fs_alloc.c struct buf *bp;
bp 523 ufs/ext2fs/ext2fs_alloc.c (int)fs->e2fs_bsize, NOCRED, &bp);
bp 525 ufs/ext2fs/ext2fs_alloc.c brelse(bp);
bp 528 ufs/ext2fs/ext2fs_alloc.c ibp = (char *)bp->b_data;
bp 543 ufs/ext2fs/ext2fs_alloc.c bdwrite(bp);
bp 64 ufs/ext2fs/ext2fs_balloc.c struct buf *bp, *nbp;
bp 85 ufs/ext2fs/ext2fs_balloc.c error = bread(vp, bn, fs->e2fs_bsize, NOCRED, &bp);
bp 87 ufs/ext2fs/ext2fs_balloc.c brelse(bp);
bp 90 ufs/ext2fs/ext2fs_balloc.c *bpp = bp;
bp 106 ufs/ext2fs/ext2fs_balloc.c bp = getblk(vp, bn, fs->e2fs_bsize, 0, 0);
bp 107 ufs/ext2fs/ext2fs_balloc.c bp->b_blkno = fsbtodb(fs, newb);
bp 109 ufs/ext2fs/ext2fs_balloc.c clrbuf(bp);
bp 110 ufs/ext2fs/ext2fs_balloc.c *bpp = bp;
bp 138 ufs/ext2fs/ext2fs_balloc.c bp = getblk(vp, indirs[1].in_lbn, fs->e2fs_bsize, 0, 0);
bp 139 ufs/ext2fs/ext2fs_balloc.c bp->b_blkno = fsbtodb(fs, newb);
bp 140 ufs/ext2fs/ext2fs_balloc.c clrbuf(bp);
bp 145 ufs/ext2fs/ext2fs_balloc.c if ((error = bwrite(bp)) != 0)
bp 157 ufs/ext2fs/ext2fs_balloc.c indirs[i].in_lbn, (int)fs->e2fs_bsize, NOCRED, &bp);
bp 159 ufs/ext2fs/ext2fs_balloc.c brelse(bp);
bp 162 ufs/ext2fs/ext2fs_balloc.c bap = (int32_t *)bp->b_data;
bp 168 ufs/ext2fs/ext2fs_balloc.c brelse(bp);
bp 174 ufs/ext2fs/ext2fs_balloc.c brelse(bp);
bp 188 ufs/ext2fs/ext2fs_balloc.c brelse(bp);
bp 199 ufs/ext2fs/ext2fs_balloc.c bwrite(bp);
bp 201 ufs/ext2fs/ext2fs_balloc.c bdwrite(bp);
bp 211 ufs/ext2fs/ext2fs_balloc.c brelse(bp);
bp 224 ufs/ext2fs/ext2fs_balloc.c bwrite(bp);
bp 226 ufs/ext2fs/ext2fs_balloc.c bdwrite(bp);
bp 235 ufs/ext2fs/ext2fs_balloc.c brelse(bp);
bp 265 ufs/ext2fs/ext2fs_balloc.c (int)fs->e2fs_bsize, NOCRED, &bp);
bp 268 ufs/ext2fs/ext2fs_balloc.c brelse(bp);
bp 270 ufs/ext2fs/ext2fs_balloc.c bap = (int32_t *)bp->b_data;
bp 273 ufs/ext2fs/ext2fs_balloc.c bwrite(bp);
bp 275 ufs/ext2fs/ext2fs_balloc.c bdwrite(bp);
bp 279 ufs/ext2fs/ext2fs_balloc.c bp = getblk(vp, indirs[i].in_lbn, (int)fs->e2fs_bsize,
bp 281 ufs/ext2fs/ext2fs_balloc.c bp->b_flags |= B_INVAL;
bp 282 ufs/ext2fs/ext2fs_balloc.c brelse(bp);
bp 103 ufs/ext2fs/ext2fs_bmap.c struct buf *bp;
bp 162 ufs/ext2fs/ext2fs_bmap.c for (bp = NULL, ++xap; --num; ++xap) {
bp 176 ufs/ext2fs/ext2fs_bmap.c if (bp)
bp 177 ufs/ext2fs/ext2fs_bmap.c brelse(bp);
bp 180 ufs/ext2fs/ext2fs_bmap.c bp = getblk(vp, metalbn, mp->mnt_stat.f_iosize, 0, 0);
bp 181 ufs/ext2fs/ext2fs_bmap.c if (bp->b_flags & (B_DONE | B_DELWRI)) {
bp 189 ufs/ext2fs/ext2fs_bmap.c bp->b_blkno = blkptrtodb(ump, daddr);
bp 190 ufs/ext2fs/ext2fs_bmap.c bp->b_flags |= B_READ;
bp 191 ufs/ext2fs/ext2fs_bmap.c VOP_STRATEGY(bp);
bp 193 ufs/ext2fs/ext2fs_bmap.c if ((error = biowait(bp)) != 0) {
bp 194 ufs/ext2fs/ext2fs_bmap.c brelse(bp);
bp 199 ufs/ext2fs/ext2fs_bmap.c daddr = fs2h32(((int32_t *)bp->b_data)[xap->in_off]);
bp 203 ufs/ext2fs/ext2fs_bmap.c is_sequential(ump, ((int32_t *)bp->b_data)[bn - 1],
bp 204 ufs/ext2fs/ext2fs_bmap.c ((int32_t *)bp->b_data)[bn]);
bp 207 ufs/ext2fs/ext2fs_bmap.c if (bp)
bp 208 ufs/ext2fs/ext2fs_bmap.c brelse(bp);
bp 166 ufs/ext2fs/ext2fs_inode.c struct buf *bp;
bp 183 ufs/ext2fs/ext2fs_inode.c (int)fs->e2fs_bsize, NOCRED, &bp);
bp 185 ufs/ext2fs/ext2fs_inode.c brelse(bp);
bp 189 ufs/ext2fs/ext2fs_inode.c cp = (caddr_t)bp->b_data +
bp 204 ufs/ext2fs/ext2fs_inode.c return (bwrite(bp));
bp 206 ufs/ext2fs/ext2fs_inode.c bdwrite(bp);
bp 226 ufs/ext2fs/ext2fs_inode.c struct buf *bp;
bp 277 ufs/ext2fs/ext2fs_inode.c error = ext2fs_buf_alloc(oip, lbn, offset + 1, cred, &bp,
bp 285 ufs/ext2fs/ext2fs_inode.c bwrite(bp);
bp 287 ufs/ext2fs/ext2fs_inode.c bawrite(bp);
bp 306 ufs/ext2fs/ext2fs_inode.c error = ext2fs_buf_alloc(oip, lbn, offset, cred, &bp,
bp 314 ufs/ext2fs/ext2fs_inode.c bzero(bp->b_data + offset, (u_int)(size - offset));
bp 315 ufs/ext2fs/ext2fs_inode.c bp->b_bcount = size;
bp 317 ufs/ext2fs/ext2fs_inode.c bwrite(bp);
bp 319 ufs/ext2fs/ext2fs_inode.c bawrite(bp);
bp 436 ufs/ext2fs/ext2fs_inode.c struct buf *bp;
bp 466 ufs/ext2fs/ext2fs_inode.c bp = getblk(vp, lbn, (int)fs->e2fs_bsize, 0, 0);
bp 467 ufs/ext2fs/ext2fs_inode.c if (!(bp->b_flags & (B_DONE | B_DELWRI))) {
bp 469 ufs/ext2fs/ext2fs_inode.c bp->b_flags |= B_READ;
bp 470 ufs/ext2fs/ext2fs_inode.c if (bp->b_bcount > bp->b_bufsize)
bp 472 ufs/ext2fs/ext2fs_inode.c bp->b_blkno = dbn;
bp 473 ufs/ext2fs/ext2fs_inode.c VOP_STRATEGY(bp);
bp 474 ufs/ext2fs/ext2fs_inode.c error = biowait(bp);
bp 477 ufs/ext2fs/ext2fs_inode.c brelse(bp);
bp 482 ufs/ext2fs/ext2fs_inode.c bap = (int32_t *)bp->b_data;
bp 488 ufs/ext2fs/ext2fs_inode.c error = bwrite(bp);
bp 533 ufs/ext2fs/ext2fs_inode.c bp->b_flags |= B_INVAL;
bp 534 ufs/ext2fs/ext2fs_inode.c brelse(bp);
bp 254 ufs/ext2fs/ext2fs_lookup.c struct buf *bp; /* a buffer of directory entries */
bp 280 ufs/ext2fs/ext2fs_lookup.c bp = NULL;
bp 342 ufs/ext2fs/ext2fs_lookup.c NULL, &bp)))
bp 356 ufs/ext2fs/ext2fs_lookup.c if (bp != NULL)
bp 357 ufs/ext2fs/ext2fs_lookup.c brelse(bp);
bp 359 ufs/ext2fs/ext2fs_lookup.c NULL, &bp);
bp 381 ufs/ext2fs/ext2fs_lookup.c ((char *)bp->b_data + entryoffsetinblock);
bp 438 ufs/ext2fs/ext2fs_lookup.c brelse(bp);
bp 459 ufs/ext2fs/ext2fs_lookup.c if (bp != NULL)
bp 460 ufs/ext2fs/ext2fs_lookup.c brelse(bp);
bp 539 ufs/ext2fs/ext2fs_lookup.c brelse(bp);
bp 746 ufs/ext2fs/ext2fs_lookup.c struct buf *bp;
bp 817 ufs/ext2fs/ext2fs_lookup.c if ((error = ext2fs_bufatoff(dp, (off_t)dp->i_offset, &dirbuf, &bp))
bp 868 ufs/ext2fs/ext2fs_lookup.c error = VOP_BWRITE(bp);
bp 893 ufs/ext2fs/ext2fs_lookup.c struct buf *bp;
bp 902 ufs/ext2fs/ext2fs_lookup.c &bp);
bp 906 ufs/ext2fs/ext2fs_lookup.c error = VOP_BWRITE(bp);
bp 914 ufs/ext2fs/ext2fs_lookup.c (char **)&ep, &bp);
bp 918 ufs/ext2fs/ext2fs_lookup.c error = VOP_BWRITE(bp);
bp 932 ufs/ext2fs/ext2fs_lookup.c struct buf *bp;
bp 936 ufs/ext2fs/ext2fs_lookup.c error = ext2fs_bufatoff(dp, (off_t)dp->i_offset, (char **)&ep, &bp);
bp 946 ufs/ext2fs/ext2fs_lookup.c error = VOP_BWRITE(bp);
bp 72 ufs/ext2fs/ext2fs_readwrite.c struct buf *bp;
bp 101 ufs/ext2fs/ext2fs_readwrite.c for (error = 0, bp = NULL; uio->uio_resid > 0; bp = NULL) {
bp 115 ufs/ext2fs/ext2fs_readwrite.c error = bread(vp, lbn, size, NOCRED, &bp);
bp 119 ufs/ext2fs/ext2fs_readwrite.c size, &nextlbn, &nextsize, 1, NOCRED, &bp);
bp 121 ufs/ext2fs/ext2fs_readwrite.c error = bread(vp, lbn, size, NOCRED, &bp);
bp 133 ufs/ext2fs/ext2fs_readwrite.c size -= bp->b_resid;
bp 139 ufs/ext2fs/ext2fs_readwrite.c error = uiomove((char *)bp->b_data + blkoffset, xfersize, uio);
bp 142 ufs/ext2fs/ext2fs_readwrite.c brelse(bp);
bp 144 ufs/ext2fs/ext2fs_readwrite.c if (bp != NULL)
bp 145 ufs/ext2fs/ext2fs_readwrite.c brelse(bp);
bp 164 ufs/ext2fs/ext2fs_readwrite.c struct buf *bp;
bp 238 ufs/ext2fs/ext2fs_readwrite.c lbn, blkoffset + xfersize, ap->a_cred, &bp, flags);
bp 249 ufs/ext2fs/ext2fs_readwrite.c size = fs->e2fs_bsize - bp->b_resid;
bp 254 ufs/ext2fs/ext2fs_readwrite.c uiomove((char *)bp->b_data + blkoffset, (int)xfersize, uio);
bp 256 ufs/ext2fs/ext2fs_readwrite.c (void)bwrite(bp);
bp 259 ufs/ext2fs/ext2fs_readwrite.c cluster_write(bp, &ip->i_ci, ext2fs_size(ip));
bp 261 ufs/ext2fs/ext2fs_readwrite.c bawrite(bp);
bp 263 ufs/ext2fs/ext2fs_readwrite.c bdwrite(bp);
bp 84 ufs/ext2fs/ext2fs_subr.c struct buf *bp;
bp 93 ufs/ext2fs/ext2fs_subr.c if ((error = bread(vp, lbn, fs->e2fs_bsize, NOCRED, &bp)) != 0) {
bp 94 ufs/ext2fs/ext2fs_subr.c brelse(bp);
bp 98 ufs/ext2fs/ext2fs_subr.c *res = (char *)bp->b_data + blkoff(fs, offset);
bp 99 ufs/ext2fs/ext2fs_subr.c *bpp = bp;
bp 106 ufs/ext2fs/ext2fs_subr.c ext2fs_checkoverlap(struct buf *bp, struct inode *ip)
bp 112 ufs/ext2fs/ext2fs_subr.c start = bp->b_blkno;
bp 113 ufs/ext2fs/ext2fs_subr.c last = start + btodb(bp->b_bcount) - 1;
bp 115 ufs/ext2fs/ext2fs_subr.c if (ep == bp || (ep->b_flags & B_INVAL) ||
bp 333 ufs/ext2fs/ext2fs_vfsops.c struct buf *bp;
bp 360 ufs/ext2fs/ext2fs_vfsops.c (int)era->fs->e2fs_bsize, NOCRED, &bp);
bp 365 ufs/ext2fs/ext2fs_vfsops.c cp = (caddr_t)bp->b_data +
bp 368 ufs/ext2fs/ext2fs_vfsops.c brelse(bp);
bp 390 ufs/ext2fs/ext2fs_vfsops.c struct buf *bp;
bp 413 ufs/ext2fs/ext2fs_vfsops.c error = bread(devvp, (int32_t)(SBOFF / size), SBSIZE, NOCRED, &bp);
bp 415 ufs/ext2fs/ext2fs_vfsops.c brelse(bp);
bp 418 ufs/ext2fs/ext2fs_vfsops.c newfs = (struct ext2fs *)bp->b_data;
bp 421 ufs/ext2fs/ext2fs_vfsops.c brelse(bp);
bp 451 ufs/ext2fs/ext2fs_vfsops.c fs->e2fs_bsize, NOCRED, &bp);
bp 453 ufs/ext2fs/ext2fs_vfsops.c brelse(bp);
bp 456 ufs/ext2fs/ext2fs_vfsops.c e2fs_cgload((struct ext2_gd*)bp->b_data,
bp 459 ufs/ext2fs/ext2fs_vfsops.c brelse(bp);
bp 479 ufs/ext2fs/ext2fs_vfsops.c struct buf *bp;
bp 511 ufs/ext2fs/ext2fs_vfsops.c bp = NULL;
bp 518 ufs/ext2fs/ext2fs_vfsops.c error = bread(devvp, (SBOFF / DEV_BSIZE), SBSIZE, cred, &bp);
bp 521 ufs/ext2fs/ext2fs_vfsops.c fs = (struct ext2fs *)bp->b_data;
bp 529 ufs/ext2fs/ext2fs_vfsops.c e2fs_sbload((struct ext2fs*)bp->b_data, &ump->um_e2fs->e2fs);
bp 530 ufs/ext2fs/ext2fs_vfsops.c brelse(bp);
bp 531 ufs/ext2fs/ext2fs_vfsops.c bp = NULL;
bp 563 ufs/ext2fs/ext2fs_vfsops.c m_fs->e2fs_bsize, NOCRED, &bp);
bp 568 ufs/ext2fs/ext2fs_vfsops.c e2fs_cgload((struct ext2_gd*)bp->b_data,
bp 572 ufs/ext2fs/ext2fs_vfsops.c brelse(bp);
bp 573 ufs/ext2fs/ext2fs_vfsops.c bp = NULL;
bp 590 ufs/ext2fs/ext2fs_vfsops.c if (bp)
bp 591 ufs/ext2fs/ext2fs_vfsops.c brelse(bp);
bp 814 ufs/ext2fs/ext2fs_vfsops.c struct buf *bp;
bp 863 ufs/ext2fs/ext2fs_vfsops.c (int)fs->e2fs_bsize, NOCRED, &bp);
bp 872 ufs/ext2fs/ext2fs_vfsops.c brelse(bp);
bp 877 ufs/ext2fs/ext2fs_vfsops.c dp = (struct ext2fs_dinode *) bp->b_data + ino_to_fsbo(fs, ino);
bp 880 ufs/ext2fs/ext2fs_vfsops.c brelse(bp);
bp 1008 ufs/ext2fs/ext2fs_vfsops.c struct buf *bp;
bp 1011 ufs/ext2fs/ext2fs_vfsops.c bp = getblk(mp->um_devvp, SBLOCK, SBSIZE, 0, 0);
bp 1012 ufs/ext2fs/ext2fs_vfsops.c e2fs_sbsave(&fs->e2fs, (struct ext2fs *) bp->b_data);
bp 1014 ufs/ext2fs/ext2fs_vfsops.c error = bwrite(bp);
bp 1016 ufs/ext2fs/ext2fs_vfsops.c bawrite(bp);
bp 1024 ufs/ext2fs/ext2fs_vfsops.c struct buf *bp;
bp 1029 ufs/ext2fs/ext2fs_vfsops.c bp = getblk(mp->um_devvp, fsbtodb(fs, ((fs->e2fs_bsize>1024)?0:1)+i+1),
bp 1031 ufs/ext2fs/ext2fs_vfsops.c e2fs_cgsave(&fs->e2fs_gd[i* fs->e2fs_bsize / sizeof(struct ext2_gd)], (struct ext2_gd*)bp->b_data, fs->e2fs_bsize);
bp 1033 ufs/ext2fs/ext2fs_vfsops.c error = bwrite(bp);
bp 1035 ufs/ext2fs/ext2fs_vfsops.c bawrite(bp);
bp 181 ufs/ffs/ffs_alloc.c struct buf *bp = NULL;
bp 216 ufs/ffs/ffs_alloc.c NOCRED, &bp)) != 0)
bp 218 ufs/ffs/ffs_alloc.c bp->b_bcount = osize;
bp 235 ufs/ffs/ffs_alloc.c if (bp->b_blkno != fsbtodb(fs, bno))
bp 238 ufs/ffs/ffs_alloc.c if (nsize > bp->b_bufsize)
bp 241 ufs/ffs/ffs_alloc.c bp->b_bcount = nsize;
bp 242 ufs/ffs/ffs_alloc.c bp->b_flags |= B_DONE;
bp 243 ufs/ffs/ffs_alloc.c bzero(bp->b_data + osize, (u_int)nsize - osize);
bp 244 ufs/ffs/ffs_alloc.c *bpp = bp;
bp 309 ufs/ffs/ffs_alloc.c bp->b_blkno = fsbtodb(fs, bno);
bp 311 ufs/ffs/ffs_alloc.c if (nsize > bp->b_bufsize)
bp 314 ufs/ffs/ffs_alloc.c bp->b_bcount = nsize;
bp 315 ufs/ffs/ffs_alloc.c bp->b_flags |= B_DONE;
bp 316 ufs/ffs/ffs_alloc.c bzero(bp->b_data + osize, (u_int)nsize - osize);
bp 317 ufs/ffs/ffs_alloc.c *bpp = bp;
bp 333 ufs/ffs/ffs_alloc.c if (bp != NULL) {
bp 334 ufs/ffs/ffs_alloc.c brelse(bp);
bp 335 ufs/ffs/ffs_alloc.c bp = NULL;
bp 1191 ufs/ffs/ffs_alloc.c struct buf *bp;
bp 1206 ufs/ffs/ffs_alloc.c (int)fs->fs_cgsize, NOCRED, &bp);
bp 1208 ufs/ffs/ffs_alloc.c brelse(bp);
bp 1211 ufs/ffs/ffs_alloc.c cgp = (struct cg *)bp->b_data;
bp 1213 ufs/ffs/ffs_alloc.c brelse(bp);
bp 1222 ufs/ffs/ffs_alloc.c brelse(bp);
bp 1245 ufs/ffs/ffs_alloc.c softdep_setup_blkmapdep(bp, fs, bprev);
bp 1247 ufs/ffs/ffs_alloc.c bdwrite(bp);
bp 1262 ufs/ffs/ffs_alloc.c struct buf *bp;
bp 1271 ufs/ffs/ffs_alloc.c (int)fs->fs_cgsize, NOCRED, &bp);
bp 1273 ufs/ffs/ffs_alloc.c brelse(bp);
bp 1276 ufs/ffs/ffs_alloc.c cgp = (struct cg *)bp->b_data;
bp 1279 ufs/ffs/ffs_alloc.c brelse(bp);
bp 1287 ufs/ffs/ffs_alloc.c bno = ffs_alloccgblk(ip, bp, bpref);
bp 1288 ufs/ffs/ffs_alloc.c bdwrite(bp);
bp 1306 ufs/ffs/ffs_alloc.c brelse(bp);
bp 1309 ufs/ffs/ffs_alloc.c bno = ffs_alloccgblk(ip, bp, bpref);
bp 1319 ufs/ffs/ffs_alloc.c bdwrite(bp);
bp 1324 ufs/ffs/ffs_alloc.c brelse(bp);
bp 1340 ufs/ffs/ffs_alloc.c softdep_setup_blkmapdep(bp, fs, blkno);
bp 1341 ufs/ffs/ffs_alloc.c bdwrite(bp);
bp 1351 ufs/ffs/ffs_alloc.c ffs_alloccgblk(struct inode *ip, struct buf *bp, daddr_t bpref)
bp 1360 ufs/ffs/ffs_alloc.c cgp = (struct cg *) bp->b_data;
bp 1402 ufs/ffs/ffs_alloc.c softdep_setup_blkmapdep(bp, fs, blkno);
bp 1419 ufs/ffs/ffs_alloc.c struct buf *bp;
bp 1428 ufs/ffs/ffs_alloc.c NOCRED, &bp))
bp 1430 ufs/ffs/ffs_alloc.c cgp = (struct cg *)bp->b_data;
bp 1509 ufs/ffs/ffs_alloc.c if (ffs_alloccgblk(ip, bp, bno + i) != bno + i)
bp 1511 ufs/ffs/ffs_alloc.c bdwrite(bp);
bp 1515 ufs/ffs/ffs_alloc.c brelse(bp);
bp 1525 ufs/ffs/ffs_alloc.c struct buf *bp;
bp 1542 ufs/ffs/ffs_alloc.c (int)fs->fs_cgsize, NOCRED, &bp);
bp 1544 ufs/ffs/ffs_alloc.c brelse(bp);
bp 1548 ufs/ffs/ffs_alloc.c cgp = (struct cg *)bp->b_data;
bp 1550 ufs/ffs/ffs_alloc.c brelse(bp);
bp 1652 ufs/ffs/ffs_alloc.c softdep_setup_inomapdep(bp, ip, cg * fs->fs_ipg + ipref);
bp 1669 ufs/ffs/ffs_alloc.c bdwrite(bp);
bp 1692 ufs/ffs/ffs_alloc.c struct buf *bp;
bp 1710 ufs/ffs/ffs_alloc.c (int)fs->fs_cgsize, NOCRED, &bp);
bp 1712 ufs/ffs/ffs_alloc.c brelse(bp);
bp 1715 ufs/ffs/ffs_alloc.c cgp = (struct cg *)bp->b_data;
bp 1717 ufs/ffs/ffs_alloc.c brelse(bp);
bp 1791 ufs/ffs/ffs_alloc.c bdwrite(bp);
bp 1816 ufs/ffs/ffs_alloc.c struct buf *bp;
bp 1825 ufs/ffs/ffs_alloc.c (int)fs->fs_cgsize, NOCRED, &bp);
bp 1827 ufs/ffs/ffs_alloc.c brelse(bp);
bp 1830 ufs/ffs/ffs_alloc.c cgp = (struct cg *)bp->b_data;
bp 1832 ufs/ffs/ffs_alloc.c brelse(bp);
bp 1857 ufs/ffs/ffs_alloc.c bdwrite(bp);
bp 1871 ufs/ffs/ffs_alloc.c struct buf *bp;
bp 1883 ufs/ffs/ffs_alloc.c (int)fs->fs_cgsize, NOCRED, &bp);
bp 1885 ufs/ffs/ffs_alloc.c brelse(bp);
bp 1889 ufs/ffs/ffs_alloc.c cgp = (struct cg *)bp->b_data;
bp 1891 ufs/ffs/ffs_alloc.c brelse(bp);
bp 1906 ufs/ffs/ffs_alloc.c brelse(bp);
bp 79 ufs/ffs/ffs_balloc.c struct buf *bp, *nbp;
bp 251 ufs/ffs/ffs_balloc.c bp = getblk(vp, indirs[1].in_lbn, fs->fs_bsize, 0, 0);
bp 252 ufs/ffs/ffs_balloc.c bp->b_blkno = fsbtodb(fs, nb);
bp 253 ufs/ffs/ffs_balloc.c clrbuf(bp);
bp 257 ufs/ffs/ffs_balloc.c newb, 0, fs->fs_bsize, 0, bp);
bp 258 ufs/ffs/ffs_balloc.c bdwrite(bp);
bp 264 ufs/ffs/ffs_balloc.c if ((error = bwrite(bp)) != 0)
bp 277 ufs/ffs/ffs_balloc.c indirs[i].in_lbn, (int)fs->fs_bsize, NOCRED, &bp);
bp 279 ufs/ffs/ffs_balloc.c brelse(bp);
bp 282 ufs/ffs/ffs_balloc.c bap = (daddr_t *)bp->b_data;
bp 288 ufs/ffs/ffs_balloc.c brelse(bp);
bp 296 ufs/ffs/ffs_balloc.c brelse(bp);
bp 306 ufs/ffs/ffs_balloc.c softdep_setup_allocindir_meta(nbp, ip, bp,
bp 315 ufs/ffs/ffs_balloc.c brelse(bp);
bp 327 ufs/ffs/ffs_balloc.c bwrite(bp);
bp 329 ufs/ffs/ffs_balloc.c bdwrite(bp);
bp 340 ufs/ffs/ffs_balloc.c brelse(bp);
bp 353 ufs/ffs/ffs_balloc.c softdep_setup_allocindir_page(ip, lbn, bp,
bp 361 ufs/ffs/ffs_balloc.c bwrite(bp);
bp 363 ufs/ffs/ffs_balloc.c bdwrite(bp);
bp 367 ufs/ffs/ffs_balloc.c brelse(bp);
bp 411 ufs/ffs/ffs_balloc.c (int)fs->fs_bsize, NOCRED, &bp);
bp 414 ufs/ffs/ffs_balloc.c bap = (daddr_t *)bp->b_data;
bp 417 ufs/ffs/ffs_balloc.c bwrite(bp);
bp 419 ufs/ffs/ffs_balloc.c bdwrite(bp);
bp 444 ufs/ffs/ffs_balloc.c struct buf *bp, *nbp;
bp 583 ufs/ffs/ffs_balloc.c bp = getblk(vp, lbn, fs->fs_bsize, 0, 0);
bp 585 ufs/ffs/ffs_balloc.c bp->b_bcount = nsize;
bp 586 ufs/ffs/ffs_balloc.c bp->b_blkno = fsbtodb(fs, newb);
bp 588 ufs/ffs/ffs_balloc.c clrbuf(bp);
bp 589 ufs/ffs/ffs_balloc.c *bpp = bp;
bp 633 ufs/ffs/ffs_balloc.c bp = getblk(vp, indirs[1].in_lbn, fs->fs_bsize, 0, 0);
bp 634 ufs/ffs/ffs_balloc.c bp->b_blkno = fsbtodb(fs, nb);
bp 635 ufs/ffs/ffs_balloc.c clrbuf(bp);
bp 639 ufs/ffs/ffs_balloc.c newb, 0, fs->fs_bsize, 0, bp);
bp 640 ufs/ffs/ffs_balloc.c bdwrite(bp);
bp 646 ufs/ffs/ffs_balloc.c error = bwrite(bp);
bp 662 ufs/ffs/ffs_balloc.c NOCRED, &bp);
bp 664 ufs/ffs/ffs_balloc.c brelse(bp);
bp 668 ufs/ffs/ffs_balloc.c bap = (int64_t *) bp->b_data;
bp 677 ufs/ffs/ffs_balloc.c brelse(bp);
bp 687 ufs/ffs/ffs_balloc.c brelse(bp);
bp 698 ufs/ffs/ffs_balloc.c softdep_setup_allocindir_meta(nbp, ip, bp,
bp 708 ufs/ffs/ffs_balloc.c brelse(bp);
bp 723 ufs/ffs/ffs_balloc.c bwrite(bp);
bp 725 ufs/ffs/ffs_balloc.c bdwrite(bp);
bp 737 ufs/ffs/ffs_balloc.c brelse(bp);
bp 753 ufs/ffs/ffs_balloc.c softdep_setup_allocindir_page(ip, lbn, bp,
bp 766 ufs/ffs/ffs_balloc.c bwrite(bp);
bp 768 ufs/ffs/ffs_balloc.c bdwrite(bp);
bp 773 ufs/ffs/ffs_balloc.c brelse(bp);
bp 822 ufs/ffs/ffs_balloc.c bp = getblk(vp, indirs[i].in_lbn, (int) fs->fs_bsize,
bp 824 ufs/ffs/ffs_balloc.c if (bp->b_flags & B_DELWRI) {
bp 826 ufs/ffs/ffs_balloc.c dbtofsb(fs, bp->b_blkno))));
bp 827 ufs/ffs/ffs_balloc.c bwrite(bp);
bp 828 ufs/ffs/ffs_balloc.c bp = getblk(ip->i_devvp, nb,
bp 830 ufs/ffs/ffs_balloc.c if (bp->b_flags & B_DELWRI)
bp 831 ufs/ffs/ffs_balloc.c bwrite(bp);
bp 833 ufs/ffs/ffs_balloc.c bp->b_flags |= B_INVAL;
bp 834 ufs/ffs/ffs_balloc.c brelse(bp);
bp 837 ufs/ffs/ffs_balloc.c bp->b_flags |= B_INVAL;
bp 838 ufs/ffs/ffs_balloc.c brelse(bp);
bp 858 ufs/ffs/ffs_balloc.c (int) fs->fs_bsize, NOCRED, &bp);
bp 862 ufs/ffs/ffs_balloc.c bap = (int64_t *) bp->b_data;
bp 864 ufs/ffs/ffs_balloc.c bwrite(bp);
bp 868 ufs/ffs/ffs_balloc.c bp = getblk(vp, indirs[i].in_lbn, (int)fs->fs_bsize, 0,
bp 870 ufs/ffs/ffs_balloc.c bp->b_flags |= B_INVAL;
bp 871 ufs/ffs/ffs_balloc.c brelse(bp);
bp 73 ufs/ffs/ffs_inode.c struct buf *bp;
bp 125 ufs/ffs/ffs_inode.c (int)fs->fs_bsize, NOCRED, &bp);
bp 127 ufs/ffs/ffs_inode.c brelse(bp);
bp 132 ufs/ffs/ffs_inode.c softdep_update_inodeblock(ip, bp, waitfor);
bp 138 ufs/ffs/ffs_inode.c *((struct ufs2_dinode *)bp->b_data +
bp 142 ufs/ffs/ffs_inode.c *((struct ufs1_dinode *)bp->b_data +
bp 146 ufs/ffs/ffs_inode.c return (bwrite(bp));
bp 148 ufs/ffs/ffs_inode.c bdwrite(bp);
bp 169 ufs/ffs/ffs_inode.c struct buf *bp;
bp 246 ufs/ffs/ffs_inode.c cred, aflags, &bp);
bp 253 ufs/ffs/ffs_inode.c bwrite(bp);
bp 255 ufs/ffs/ffs_inode.c bawrite(bp);
bp 278 ufs/ffs/ffs_inode.c cred, aflags, &bp);
bp 297 ufs/ffs/ffs_inode.c bzero((char *)bp->b_data + offset,
bp 299 ufs/ffs/ffs_inode.c bp->b_bcount = size;
bp 301 ufs/ffs/ffs_inode.c bwrite(bp);
bp 303 ufs/ffs/ffs_inode.c bawrite(bp);
bp 472 ufs/ffs/ffs_inode.c struct buf *bp;
bp 506 ufs/ffs/ffs_inode.c bp = getblk(vp, lbn, (int)fs->fs_bsize, 0, 0);
bp 507 ufs/ffs/ffs_inode.c if (!(bp->b_flags & (B_DONE | B_DELWRI))) {
bp 509 ufs/ffs/ffs_inode.c bp->b_flags |= B_READ;
bp 510 ufs/ffs/ffs_inode.c if (bp->b_bcount > bp->b_bufsize)
bp 512 ufs/ffs/ffs_inode.c bp->b_blkno = dbn;
bp 513 ufs/ffs/ffs_inode.c VOP_STRATEGY(bp);
bp 514 ufs/ffs/ffs_inode.c error = biowait(bp);
bp 517 ufs/ffs/ffs_inode.c brelse(bp);
bp 524 ufs/ffs/ffs_inode.c bap2 = (int64_t *)bp->b_data;
bp 527 ufs/ffs/ffs_inode.c bap1 = (int32_t *)bp->b_data;
bp 531 ufs/ffs/ffs_inode.c bcopy(bp->b_data, copy, (u_int) fs->fs_bsize);
bp 537 ufs/ffs/ffs_inode.c error = bwrite(bp);
bp 541 ufs/ffs/ffs_inode.c bawrite(bp);
bp 589 ufs/ffs/ffs_inode.c bp->b_flags |= B_INVAL;
bp 590 ufs/ffs/ffs_inode.c brelse(bp);
bp 175 ufs/ffs/ffs_softdep.c int softdep_count_dependencies(struct buf *bp, int, int);
bp 1251 ufs/ffs/ffs_softdep.c struct buf *bp;
bp 1264 ufs/ffs/ffs_softdep.c fs->fs_cgsize, cred, &bp)) != 0) {
bp 1265 ufs/ffs/ffs_softdep.c brelse(bp);
bp 1268 ufs/ffs/ffs_softdep.c cgp = (struct cg *)bp->b_data;
bp 1274 ufs/ffs/ffs_softdep.c brelse(bp);
bp 1320 ufs/ffs/ffs_softdep.c softdep_setup_inomapdep(bp, ip, newinum)
bp 1321 ufs/ffs/ffs_softdep.c struct buf *bp; /* buffer for cylgroup block with inode map */
bp 1340 ufs/ffs/ffs_softdep.c inodedep->id_buf = bp;
bp 1342 ufs/ffs/ffs_softdep.c bmsafemap = bmsafemap_lookup(bp);
bp 1352 ufs/ffs/ffs_softdep.c softdep_setup_blkmapdep(bp, fs, newblkno)
bp 1353 ufs/ffs/ffs_softdep.c struct buf *bp; /* buffer for cylgroup block with block map */
bp 1368 ufs/ffs/ffs_softdep.c newblk->nb_bmsafemap = bmsafemap = bmsafemap_lookup(bp);
bp 1380 ufs/ffs/ffs_softdep.c bmsafemap_lookup(bp)
bp 1381 ufs/ffs/ffs_softdep.c struct buf *bp;
bp 1392 ufs/ffs/ffs_softdep.c LIST_FOREACH(wk, &bp->b_dep, wk_list)
bp 1399 ufs/ffs/ffs_softdep.c bmsafemap->sm_buf = bp;
bp 1405 ufs/ffs/ffs_softdep.c WORKLIST_INSERT(&bp->b_dep, &bmsafemap->sm_list);
bp 1439 ufs/ffs/ffs_softdep.c softdep_setup_allocdirect(ip, lbn, newblkno, oldblkno, newsize, oldsize, bp)
bp 1446 ufs/ffs/ffs_softdep.c struct buf *bp; /* bp for allocated block */
bp 1489 ufs/ffs/ffs_softdep.c if (bp == NULL) {
bp 1495 ufs/ffs/ffs_softdep.c WORKLIST_INSERT(&bp->b_dep, &adp->ad_list);
bp 1512 ufs/ffs/ffs_softdep.c WORKLIST_INSERT(&bp->b_dep, &pagedep->pd_list);
bp 1719 ufs/ffs/ffs_softdep.c softdep_setup_allocindir_page(ip, lbn, bp, ptrno, newblkno, oldblkno, nbp)
bp 1722 ufs/ffs/ffs_softdep.c struct buf *bp; /* buffer with indirect blk referencing page */
bp 1749 ufs/ffs/ffs_softdep.c setup_allocindir_phase2(bp, ip, aip);
bp 1757 ufs/ffs/ffs_softdep.c softdep_setup_allocindir_meta(nbp, ip, bp, ptrno, newblkno)
bp 1760 ufs/ffs/ffs_softdep.c struct buf *bp; /* indirect block referencing allocated block */
bp 1770 ufs/ffs/ffs_softdep.c setup_allocindir_phase2(bp, ip, aip);
bp 1778 ufs/ffs/ffs_softdep.c setup_allocindir_phase2(bp, ip, aip)
bp 1779 ufs/ffs/ffs_softdep.c struct buf *bp; /* in-memory copy of the indirect block */
bp 1790 ufs/ffs/ffs_softdep.c if (bp->b_lblkno >= 0)
bp 1794 ufs/ffs/ffs_softdep.c LIST_FOREACH(wk, &bp->b_dep, wk_list) {
bp 1802 ufs/ffs/ffs_softdep.c WORKLIST_INSERT(&bp->b_dep, &indirdep->ir_list);
bp 1873 ufs/ffs/ffs_softdep.c if (bp->b_blkno == bp->b_lblkno) {
bp 1874 ufs/ffs/ffs_softdep.c VOP_BMAP(bp->b_vp, bp->b_lblkno, NULL, &bp->b_blkno,
bp 1878 ufs/ffs/ffs_softdep.c getblk(ip->i_devvp, bp->b_blkno, bp->b_bcount, 0, 0);
bp 1882 ufs/ffs/ffs_softdep.c bcopy(bp->b_data, newindirdep->ir_savebp->b_data, bp->b_bcount);
bp 1924 ufs/ffs/ffs_softdep.c struct buf *bp;
bp 1963 ufs/ffs/ffs_softdep.c (int)fs->fs_bsize, NOCRED, &bp)) != 0)
bp 1967 ufs/ffs/ffs_softdep.c *((struct ufs1_dinode *) bp->b_data +
bp 1970 ufs/ffs/ffs_softdep.c *((struct ufs2_dinode *) bp->b_data +
bp 2005 ufs/ffs/ffs_softdep.c bdwrite(bp);
bp 2015 ufs/ffs/ffs_softdep.c while ((bp = LIST_FIRST(&vp->v_dirtyblkhd))) {
bp 2016 ufs/ffs/ffs_softdep.c if (!getdirtybuf(bp, MNT_WAIT))
bp 2019 ufs/ffs/ffs_softdep.c deallocate_dependencies(bp, inodedep);
bp 2020 ufs/ffs/ffs_softdep.c bp->b_flags |= B_INVAL | B_NOCACHE;
bp 2022 ufs/ffs/ffs_softdep.c brelse(bp);
bp 2059 ufs/ffs/ffs_softdep.c deallocate_dependencies(bp, inodedep)
bp 2060 ufs/ffs/ffs_softdep.c struct buf *bp;
bp 2071 ufs/ffs/ffs_softdep.c while ((wk = LIST_FIRST(&bp->b_dep)) != NULL) {
bp 2097 ufs/ffs/ffs_softdep.c if (bp->b_lblkno >= 0 ||
bp 2098 ufs/ffs/ffs_softdep.c bp->b_blkno != indirdep->ir_savebp->b_lblkno) {
bp 2102 ufs/ffs/ffs_softdep.c bcopy(bp->b_data, indirdep->ir_savebp->b_data,
bp 2103 ufs/ffs/ffs_softdep.c bp->b_bcount);
bp 2468 ufs/ffs/ffs_softdep.c struct buf *bp;
bp 2494 ufs/ffs/ffs_softdep.c if ((bp = incore(ip->i_devvp, dbn)) != NULL &&
bp 2495 ufs/ffs/ffs_softdep.c (wk = LIST_FIRST(&bp->b_dep)) != NULL) {
bp 2497 ufs/ffs/ffs_softdep.c (indirdep = WK_INDIRDEP(wk))->ir_savebp != bp ||
bp 2504 ufs/ffs/ffs_softdep.c if (LIST_FIRST(&bp->b_dep) != NULL) {
bp 2511 ufs/ffs/ffs_softdep.c error = bread(ip->i_devvp, dbn, (int)fs->fs_bsize, NOCRED, &bp);
bp 2520 ufs/ffs/ffs_softdep.c bap1 = (int32_t *)bp->b_data;
bp 2523 ufs/ffs/ffs_softdep.c bap2 = (int64_t *)bp->b_data;
bp 2541 ufs/ffs/ffs_softdep.c bp->b_flags |= B_INVAL | B_NOCACHE;
bp 2542 ufs/ffs/ffs_softdep.c brelse(bp);
bp 2602 ufs/ffs/ffs_softdep.c softdep_setup_directory_add(bp, dp, diroffset, newinum, newdirbp, isnewblk)
bp 2603 ufs/ffs/ffs_softdep.c struct buf *bp; /* buffer containing directory block */
bp 2674 ufs/ffs/ffs_softdep.c WORKLIST_INSERT(&bp->b_dep, &pagedep->pd_list);
bp 2862 ufs/ffs/ffs_softdep.c softdep_setup_remove(bp, dp, ip, isrmdir)
bp 2863 ufs/ffs/ffs_softdep.c struct buf *bp; /* buffer containing directory block */
bp 2873 ufs/ffs/ffs_softdep.c dirrem = newdirrem(bp, dp, ip, isrmdir, &prevdirrem);
bp 2906 ufs/ffs/ffs_softdep.c newdirrem(bp, dp, ip, isrmdir, prevdirremp)
bp 2907 ufs/ffs/ffs_softdep.c struct buf *bp; /* buffer containing directory block */
bp 2944 ufs/ffs/ffs_softdep.c WORKLIST_INSERT(&bp->b_dep, &pagedep->pd_list);
bp 3013 ufs/ffs/ffs_softdep.c softdep_setup_directory_change(bp, dp, ip, newinum, isrmdir)
bp 3014 ufs/ffs/ffs_softdep.c struct buf *bp; /* buffer containing directory block */
bp 3037 ufs/ffs/ffs_softdep.c dirrem = newdirrem(bp, dp, ip, isrmdir, &prevdirrem);
bp 3294 ufs/ffs/ffs_softdep.c softdep_disk_io_initiation(bp)
bp 3295 ufs/ffs/ffs_softdep.c struct buf *bp; /* structure describing disk write to occur */
bp 3306 ufs/ffs/ffs_softdep.c if (bp->b_flags & B_READ)
bp 3314 ufs/ffs/ffs_softdep.c for (wk = LIST_FIRST(&bp->b_dep); wk; wk = nextwk) {
bp 3319 ufs/ffs/ffs_softdep.c initiate_write_filepage(WK_PAGEDEP(wk), bp);
bp 3325 ufs/ffs/ffs_softdep.c initiate_write_inodeblock_ufs1(inodedep, bp);
bp 3328 ufs/ffs/ffs_softdep.c initiate_write_inodeblock_ufs2(inodedep, bp);
bp 3357 ufs/ffs/ffs_softdep.c indirdep->ir_saveddata = malloc(bp->b_bcount,
bp 3362 ufs/ffs/ffs_softdep.c bcopy(bp->b_data, indirdep->ir_saveddata, bp->b_bcount);
bp 3363 ufs/ffs/ffs_softdep.c bcopy(indirdep->ir_savebp->b_data, bp->b_data,
bp 3364 ufs/ffs/ffs_softdep.c bp->b_bcount);
bp 3391 ufs/ffs/ffs_softdep.c initiate_write_filepage(pagedep, bp)
bp 3393 ufs/ffs/ffs_softdep.c struct buf *bp;
bp 3412 ufs/ffs/ffs_softdep.c ((char *)bp->b_data + dap->da_offset);
bp 3436 ufs/ffs/ffs_softdep.c initiate_write_inodeblock_ufs1(inodedep, bp)
bp 3438 ufs/ffs/ffs_softdep.c struct buf *bp; /* The inode block */
bp 3455 ufs/ffs/ffs_softdep.c dp = (struct ufs1_dinode *)bp->b_data +
bp 3584 ufs/ffs/ffs_softdep.c initiate_write_inodeblock_ufs2(inodedep, bp)
bp 3586 ufs/ffs/ffs_softdep.c struct buf *bp; /* The inode block */
bp 3600 ufs/ffs/ffs_softdep.c dp = (struct ufs2_dinode *)bp->b_data +
bp 3803 ufs/ffs/ffs_softdep.c softdep_disk_write_complete(bp)
bp 3804 ufs/ffs/ffs_softdep.c struct buf *bp; /* describes the completed disk write */
bp 3819 ufs/ffs/ffs_softdep.c if ((bp->b_flags & B_ERROR) && !(bp->b_flags & B_INVAL))
bp 3828 ufs/ffs/ffs_softdep.c while ((wk = LIST_FIRST(&bp->b_dep)) != NULL) {
bp 3833 ufs/ffs/ffs_softdep.c if (handle_written_filepage(WK_PAGEDEP(wk), bp))
bp 3838 ufs/ffs/ffs_softdep.c if (handle_written_inodeblock(WK_INODEDEP(wk), bp))
bp 3892 ufs/ffs/ffs_softdep.c bcopy(indirdep->ir_saveddata, bp->b_data, bp->b_bcount);
bp 3903 ufs/ffs/ffs_softdep.c if ((bp->b_flags & B_DELWRI) == 0)
bp 3905 ufs/ffs/ffs_softdep.c buf_dirty(bp);
bp 3919 ufs/ffs/ffs_softdep.c WORKLIST_INSERT(&bp->b_dep, wk);
bp 4045 ufs/ffs/ffs_softdep.c handle_written_inodeblock(inodedep, bp)
bp 4047 ufs/ffs/ffs_softdep.c struct buf *bp; /* buffer containing the inode block */
bp 4063 ufs/ffs/ffs_softdep.c dp1 = (struct ufs1_dinode *) bp->b_data +
bp 4067 ufs/ffs/ffs_softdep.c dp2 = (struct ufs2_dinode *) bp->b_data +
bp 4085 ufs/ffs/ffs_softdep.c if ((bp->b_flags & B_DELWRI) == 0)
bp 4087 ufs/ffs/ffs_softdep.c buf_dirty(bp);
bp 4143 ufs/ffs/ffs_softdep.c if (hadchanges && (bp->b_flags & B_DELWRI) == 0)
bp 4169 ufs/ffs/ffs_softdep.c buf_dirty(bp);
bp 4306 ufs/ffs/ffs_softdep.c handle_written_filepage(pagedep, bp)
bp 4308 ufs/ffs/ffs_softdep.c struct buf *bp; /* buffer containing the written page */
bp 4346 ufs/ffs/ffs_softdep.c ((char *)bp->b_data + dap->da_offset);
bp 4369 ufs/ffs/ffs_softdep.c if ((bp->b_flags & B_DELWRI) == 0)
bp 4371 ufs/ffs/ffs_softdep.c buf_dirty(bp);
bp 4434 ufs/ffs/ffs_softdep.c softdep_update_inodeblock(ip, bp, waitfor)
bp 4436 ufs/ffs/ffs_softdep.c struct buf *bp; /* the buffer containing the inode block */
bp 4467 ufs/ffs/ffs_softdep.c WORKLIST_INSERT(&bp->b_dep, &inodedep->id_list);
bp 4498 ufs/ffs/ffs_softdep.c bp = inodedep->id_buf;
bp 4499 ufs/ffs/ffs_softdep.c gotit = getdirtybuf(bp, MNT_WAIT);
bp 4501 ufs/ffs/ffs_softdep.c if (gotit && (error = bwrite(bp)) != 0)
bp 4557 ufs/ffs/ffs_softdep.c struct buf *bp;
bp 4656 ufs/ffs/ffs_softdep.c error = bread(pvp, lbn, fs->fs_bsize, p->p_ucred, &bp);
bp 4658 ufs/ffs/ffs_softdep.c bp->b_bcount = blksize(fs, pip, lbn);
bp 4659 ufs/ffs/ffs_softdep.c error = bwrite(bp);
bp 4661 ufs/ffs/ffs_softdep.c brelse(bp);
bp 4683 ufs/ffs/ffs_softdep.c struct buf *bp, *nbp;
bp 4689 ufs/ffs/ffs_softdep.c for (bp = LIST_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) {
bp 4690 ufs/ffs/ffs_softdep.c nbp = LIST_NEXT(bp, b_vnbufs);
bp 4694 ufs/ffs/ffs_softdep.c if (bp->b_flags & B_BUSY)
bp 4696 ufs/ffs/ffs_softdep.c bp->b_flags |= B_BUSY;
bp 4698 ufs/ffs/ffs_softdep.c if ((bp->b_flags & B_DELWRI) == 0) {
bp 4706 ufs/ffs/ffs_softdep.c if ((wk = LIST_FIRST(&bp->b_dep)) == NULL ||
bp 4708 ufs/ffs/ffs_softdep.c bp->b_flags &= ~B_BUSY;
bp 4711 ufs/ffs/ffs_softdep.c bremfree(bp);
bp 4713 ufs/ffs/ffs_softdep.c (void) bawrite(bp);
bp 4745 ufs/ffs/ffs_softdep.c struct buf *bp, *nbp;
bp 4792 ufs/ffs/ffs_softdep.c bp = LIST_FIRST(&vp->v_dirtyblkhd);
bp 4793 ufs/ffs/ffs_softdep.c if (getdirtybuf(bp, MNT_WAIT) == 0) {
bp 4802 ufs/ffs/ffs_softdep.c LIST_FOREACH(wk, &bp->b_dep, wk_list) {
bp 4816 ufs/ffs/ffs_softdep.c bawrite(bp);
bp 4833 ufs/ffs/ffs_softdep.c bawrite(bp);
bp 4850 ufs/ffs/ffs_softdep.c bawrite(bp);
bp 4862 ufs/ffs/ffs_softdep.c bawrite(bp);
bp 4883 ufs/ffs/ffs_softdep.c bawrite(bp);
bp 4904 ufs/ffs/ffs_softdep.c bawrite(bp);
bp 4925 ufs/ffs/ffs_softdep.c bawrite(bp);
bp 4938 ufs/ffs/ffs_softdep.c nbp = LIST_NEXT(bp, b_vnbufs);
bp 4941 ufs/ffs/ffs_softdep.c bawrite(bp);
bp 4944 ufs/ffs/ffs_softdep.c bp = nbp;
bp 5000 ufs/ffs/ffs_softdep.c struct buf *bp;
bp 5025 ufs/ffs/ffs_softdep.c bp = adp->ad_buf;
bp 5026 ufs/ffs/ffs_softdep.c if (getdirtybuf(bp, waitfor) == 0) {
bp 5033 ufs/ffs/ffs_softdep.c bawrite(bp);
bp 5034 ufs/ffs/ffs_softdep.c } else if ((error = VOP_BWRITE(bp)) != 0) {
bp 5046 ufs/ffs/ffs_softdep.c bp = adp->ad_buf;
bp 5047 ufs/ffs/ffs_softdep.c if (getdirtybuf(bp, waitfor) == 0) {
bp 5054 ufs/ffs/ffs_softdep.c bawrite(bp);
bp 5055 ufs/ffs/ffs_softdep.c } else if ((error = VOP_BWRITE(bp)) != 0) {
bp 5096 ufs/ffs/ffs_softdep.c struct buf *bp;
bp 5152 ufs/ffs/ffs_softdep.c bp = incore(vp, 0);
bp 5153 ufs/ffs/ffs_softdep.c if (bp == NULL) {
bp 5157 ufs/ffs/ffs_softdep.c LIST_FOREACH(wk, &bp->b_dep, wk_list)
bp 5161 ufs/ffs/ffs_softdep.c gotit = getdirtybuf(bp, MNT_WAIT);
bp 5163 ufs/ffs/ffs_softdep.c if (gotit && (error = bwrite(bp)) != 0)
bp 5203 ufs/ffs/ffs_softdep.c bp = inodedep->id_buf;
bp 5204 ufs/ffs/ffs_softdep.c gotit = getdirtybuf(bp, MNT_WAIT);
bp 5206 ufs/ffs/ffs_softdep.c if (gotit && (error = bwrite(bp)) != 0)
bp 5219 ufs/ffs/ffs_softdep.c (int)ump->um_fs->fs_bsize, NOCRED, &bp)) != 0) {
bp 5220 ufs/ffs/ffs_softdep.c brelse(bp);
bp 5223 ufs/ffs/ffs_softdep.c if ((error = bwrite(bp)) != 0)
bp 5509 ufs/ffs/ffs_softdep.c softdep_count_dependencies(bp, wantcount, islocked)
bp 5510 ufs/ffs/ffs_softdep.c struct buf *bp;
bp 5525 ufs/ffs/ffs_softdep.c LIST_FOREACH(wk, &bp->b_dep, wk_list) {
bp 5595 ufs/ffs/ffs_softdep.c getdirtybuf(bp, waitfor)
bp 5596 ufs/ffs/ffs_softdep.c struct buf *bp;
bp 5601 ufs/ffs/ffs_softdep.c if (bp == NULL)
bp 5607 ufs/ffs/ffs_softdep.c if ((bp->b_flags & B_BUSY) == 0)
bp 5611 ufs/ffs/ffs_softdep.c bp->b_flags |= B_WANTED;
bp 5613 ufs/ffs/ffs_softdep.c tsleep((caddr_t)bp, PRIBIO + 1, "sdsdty", 0);
bp 5616 ufs/ffs/ffs_softdep.c if ((bp->b_flags & B_DELWRI) == 0)
bp 5618 ufs/ffs/ffs_softdep.c bremfree(bp);
bp 5619 ufs/ffs/ffs_softdep.c bp->b_flags |= B_BUSY;
bp 5655 ufs/ffs/ffs_softdep.c softdep_deallocate_dependencies(bp)
bp 5656 ufs/ffs/ffs_softdep.c struct buf *bp;
bp 5659 ufs/ffs/ffs_softdep.c if ((bp->b_flags & B_ERROR) == 0)
bp 5661 ufs/ffs/ffs_softdep.c softdep_error(bp->b_vp->v_mount->mnt_stat.f_mntonname, bp->b_error);
bp 5684 ufs/ffs/ffs_softdep.c softdep_print(struct buf *bp, int full, int (*pr)(const char *, ...))
bp 5689 ufs/ffs/ffs_softdep.c LIST_FOREACH(wk, &bp->b_dep, wk_list)
bp 71 ufs/ffs/ffs_softdep_stub.c softdep_setup_inomapdep(struct buf *bp, struct inode *ip, ino_t newinum)
bp 77 ufs/ffs/ffs_softdep_stub.c softdep_setup_blkmapdep(struct buf *bp, struct fs *fs, daddr_t newblkno)
bp 84 ufs/ffs/ffs_softdep_stub.c daddr_t oldblkno, long newsize, long oldsize, struct buf *bp)
bp 90 ufs/ffs/ffs_softdep_stub.c softdep_setup_allocindir_page(struct inode *ip, daddr64_t lbn, struct buf *bp,
bp 98 ufs/ffs/ffs_softdep_stub.c struct buf *bp, int ptrno, daddr_t newblkno)
bp 116 ufs/ffs/ffs_softdep_stub.c softdep_setup_directory_add(struct buf *bp, struct inode *dp, off_t diroffset,
bp 131 ufs/ffs/ffs_softdep_stub.c softdep_setup_remove(struct buf *bp, struct inode *dp, struct inode *ip,
bp 138 ufs/ffs/ffs_softdep_stub.c softdep_setup_directory_change(struct buf *bp, struct inode *dp,
bp 157 ufs/ffs/ffs_softdep_stub.c softdep_update_inodeblock(struct inode *ip, struct buf *bp, int waitfor)
bp 61 ufs/ffs/ffs_subr.c struct buf *bp;
bp 71 ufs/ffs/ffs_subr.c if ((error = bread(vp, lbn, fs->fs_bsize, NOCRED, &bp)) != 0) {
bp 72 ufs/ffs/ffs_subr.c brelse(bp);
bp 75 ufs/ffs/ffs_subr.c bp->b_bcount = bsize;
bp 77 ufs/ffs/ffs_subr.c *res = (char *)bp->b_data + blkoff(fs, offset);
bp 78 ufs/ffs/ffs_subr.c *bpp = bp;
bp 124 ufs/ffs/ffs_subr.c ffs_checkoverlap(struct buf *bp, struct inode *ip)
bp 130 ufs/ffs/ffs_subr.c start = bp->b_blkno;
bp 131 ufs/ffs/ffs_subr.c last = start + btodb(bp->b_bcount) - 1;
bp 133 ufs/ffs/ffs_subr.c if (ep == bp || (ep->b_flags & B_INVAL) ||
bp 469 ufs/ffs/ffs_vfsops.c struct buf *bp;
bp 496 ufs/ffs/ffs_vfsops.c (int)fra->fs->fs_bsize, NOCRED, &bp);
bp 498 ufs/ffs/ffs_vfsops.c brelse(bp);
bp 503 ufs/ffs/ffs_vfsops.c *ip->i_din1 = *((struct ufs1_dinode *)bp->b_data +
bp 506 ufs/ffs/ffs_vfsops.c brelse(bp);
bp 533 ufs/ffs/ffs_vfsops.c struct buf *bp = NULL;
bp 559 ufs/ffs/ffs_vfsops.c NOCRED, &bp);
bp 561 ufs/ffs/ffs_vfsops.c brelse(bp);
bp 565 ufs/ffs/ffs_vfsops.c newfs = (struct fs *)bp->b_data;
bp 567 ufs/ffs/ffs_vfsops.c brelse(bp);
bp 581 ufs/ffs/ffs_vfsops.c bp->b_flags |= B_INVAL;
bp 582 ufs/ffs/ffs_vfsops.c brelse(bp);
bp 597 ufs/ffs/ffs_vfsops.c NOCRED, &bp);
bp 599 ufs/ffs/ffs_vfsops.c brelse(bp);
bp 602 ufs/ffs/ffs_vfsops.c bcopy(bp->b_data, space, (u_int)size);
bp 604 ufs/ffs/ffs_vfsops.c brelse(bp);
bp 668 ufs/ffs/ffs_vfsops.c struct buf *bp;
bp 707 ufs/ffs/ffs_vfsops.c bp = NULL;
bp 714 ufs/ffs/ffs_vfsops.c if (bp != NULL) {
bp 715 ufs/ffs/ffs_vfsops.c bp->b_flags |= B_NOCACHE;
bp 716 ufs/ffs/ffs_vfsops.c brelse(bp);
bp 717 ufs/ffs/ffs_vfsops.c bp = NULL;
bp 720 ufs/ffs/ffs_vfsops.c error = bread(devvp, sbtry[i] / size, SBSIZE, cred, &bp);
bp 724 ufs/ffs/ffs_vfsops.c fs = (struct fs *) bp->b_data;
bp 802 ufs/ffs/ffs_vfsops.c bcopy(bp->b_data, ump->um_fs, (u_int)fs->fs_sbsize);
bp 804 ufs/ffs/ffs_vfsops.c bp->b_flags |= B_INVAL;
bp 805 ufs/ffs/ffs_vfsops.c brelse(bp);
bp 806 ufs/ffs/ffs_vfsops.c bp = NULL;
bp 825 ufs/ffs/ffs_vfsops.c cred, &bp);
bp 830 ufs/ffs/ffs_vfsops.c bcopy(bp->b_data, space, (u_int)size);
bp 832 ufs/ffs/ffs_vfsops.c brelse(bp);
bp 833 ufs/ffs/ffs_vfsops.c bp = NULL;
bp 918 ufs/ffs/ffs_vfsops.c if (bp)
bp 919 ufs/ffs/ffs_vfsops.c brelse(bp);
bp 1243 ufs/ffs/ffs_vfsops.c struct buf *bp;
bp 1299 ufs/ffs/ffs_vfsops.c (int)fs->fs_bsize, NOCRED, &bp);
bp 1308 ufs/ffs/ffs_vfsops.c brelse(bp);
bp 1316 ufs/ffs/ffs_vfsops.c dp2 = (struct ufs2_dinode *) bp->b_data + ino_to_fsbo(fs, ino);
bp 1322 ufs/ffs/ffs_vfsops.c dp1 = (struct ufs1_dinode *) bp->b_data + ino_to_fsbo(fs, ino);
bp 1326 ufs/ffs/ffs_vfsops.c brelse(bp);
bp 1418 ufs/ffs/ffs_vfsops.c struct buf *bp;
bp 1432 ufs/ffs/ffs_vfsops.c bp = getblk(mp->um_devvp, fsbtodb(fs, fs->fs_csaddr + i),
bp 1434 ufs/ffs/ffs_vfsops.c bcopy(space, bp->b_data, (u_int)size);
bp 1437 ufs/ffs/ffs_vfsops.c bawrite(bp);
bp 1438 ufs/ffs/ffs_vfsops.c else if ((error = bwrite(bp)))
bp 1451 ufs/ffs/ffs_vfsops.c bp = getblk(mp->um_devvp,
bp 1456 ufs/ffs/ffs_vfsops.c bcopy((caddr_t)fs, bp->b_data, (u_int)fs->fs_sbsize);
bp 1458 ufs/ffs/ffs_vfsops.c dfs = (struct fs *)bp->b_data; /* XXX */
bp 1475 ufs/ffs/ffs_vfsops.c bawrite(bp);
bp 1476 ufs/ffs/ffs_vfsops.c else if ((error = bwrite(bp)))
bp 176 ufs/ffs/ffs_vnops.c struct buf *bp;
bp 207 ufs/ffs/ffs_vnops.c for (error = 0, bp = NULL; uio->uio_resid > 0; bp = NULL) {
bp 221 ufs/ffs/ffs_vnops.c error = bread(vp, lbn, size, NOCRED, &bp);
bp 223 ufs/ffs/ffs_vnops.c error = bread_cluster(vp, lbn, size, &bp);
bp 225 ufs/ffs/ffs_vnops.c error = bread(vp, lbn, size, NOCRED, &bp);
bp 238 ufs/ffs/ffs_vnops.c size -= bp->b_resid;
bp 244 ufs/ffs/ffs_vnops.c error = uiomove((char *)bp->b_data + blkoffset, (int)xfersize,
bp 248 ufs/ffs/ffs_vnops.c brelse(bp);
bp 250 ufs/ffs/ffs_vnops.c if (bp != NULL)
bp 251 ufs/ffs/ffs_vnops.c brelse(bp);
bp 267 ufs/ffs/ffs_vnops.c struct buf *bp;
bp 340 ufs/ffs/ffs_vnops.c ap->a_cred, flags, &bp)) != 0)
bp 349 ufs/ffs/ffs_vnops.c size = blksize(fs, ip, lbn) - bp->b_resid;
bp 354 ufs/ffs/ffs_vnops.c uiomove((char *)bp->b_data + blkoffset, xfersize, uio);
bp 357 ufs/ffs/ffs_vnops.c bzero((char *)bp->b_data + blkoffset, xfersize);
bp 360 ufs/ffs/ffs_vnops.c (void)bwrite(bp);
bp 363 ufs/ffs/ffs_vnops.c cluster_write(bp, &ip->i_ci, DIP(ip, size));
bp 365 ufs/ffs/ffs_vnops.c bawrite(bp);
bp 367 ufs/ffs/ffs_vnops.c bdwrite(bp);
bp 404 ufs/ffs/ffs_vnops.c struct buf *bp, *nbp;
bp 421 ufs/ffs/ffs_vnops.c for (bp = LIST_FIRST(&vp->v_dirtyblkhd); bp;
bp 422 ufs/ffs/ffs_vnops.c bp = LIST_NEXT(bp, b_vnbufs))
bp 423 ufs/ffs/ffs_vnops.c bp->b_flags &= ~B_SCANNED;
bp 424 ufs/ffs/ffs_vnops.c for (bp = LIST_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) {
bp 425 ufs/ffs/ffs_vnops.c nbp = LIST_NEXT(bp, b_vnbufs);
bp 434 ufs/ffs/ffs_vnops.c if (bp->b_flags & (B_BUSY | B_SCANNED))
bp 436 ufs/ffs/ffs_vnops.c if ((bp->b_flags & B_DELWRI) == 0)
bp 438 ufs/ffs/ffs_vnops.c if (skipmeta && bp->b_lblkno < 0)
bp 441 ufs/ffs/ffs_vnops.c LIST_FIRST(&bp->b_dep) != NULL &&
bp 442 ufs/ffs/ffs_vnops.c (bp->b_flags & B_DEFERRED) == 0 &&
bp 443 ufs/ffs/ffs_vnops.c buf_countdeps(bp, 0, 1)) {
bp 444 ufs/ffs/ffs_vnops.c bp->b_flags |= B_DEFERRED;
bp 448 ufs/ffs/ffs_vnops.c bremfree(bp);
bp 449 ufs/ffs/ffs_vnops.c bp->b_flags |= B_BUSY | B_SCANNED;
bp 457 ufs/ffs/ffs_vnops.c (void) bawrite(bp);
bp 458 ufs/ffs/ffs_vnops.c else if ((error = bwrite(bp)) != 0)
bp 248 ufs/mfs/mfs_vfsops.c struct buf *bp;
bp 254 ufs/mfs/mfs_vfsops.c while ((bp = mfsp->mfs_buflist) != NULL) {
bp 255 ufs/mfs/mfs_vfsops.c mfsp->mfs_buflist = bp->b_actf;
bp 256 ufs/mfs/mfs_vfsops.c mfs_doio(bp, base);
bp 257 ufs/mfs/mfs_vfsops.c wakeup((caddr_t)bp);
bp 139 ufs/mfs/mfs_vnops.c struct buf *bp = ap->a_bp;
bp 145 ufs/mfs/mfs_vnops.c if (!vfinddev(bp->b_dev, VBLK, &vp) || vp->v_usecount == 0)
bp 153 ufs/mfs/mfs_vnops.c base = mfsp->mfs_baseoff + (bp->b_blkno << DEV_BSHIFT);
bp 154 ufs/mfs/mfs_vnops.c if (bp->b_flags & B_READ)
bp 155 ufs/mfs/mfs_vnops.c bcopy(base, bp->b_data, bp->b_bcount);
bp 157 ufs/mfs/mfs_vnops.c bcopy(bp->b_data, base, bp->b_bcount);
bp 159 ufs/mfs/mfs_vnops.c biodone(bp);
bp 162 ufs/mfs/mfs_vnops.c mfs_doio(bp, mfsp->mfs_baseoff);
bp 164 ufs/mfs/mfs_vnops.c bp->b_actf = mfsp->mfs_buflist;
bp 165 ufs/mfs/mfs_vnops.c mfsp->mfs_buflist = bp;
bp 177 ufs/mfs/mfs_vnops.c mfs_doio(struct buf *bp, caddr_t base)
bp 181 ufs/mfs/mfs_vnops.c base += (bp->b_blkno << DEV_BSHIFT);
bp 182 ufs/mfs/mfs_vnops.c if (bp->b_flags & B_READ)
bp 183 ufs/mfs/mfs_vnops.c bp->b_error = copyin(base, bp->b_data, bp->b_bcount);
bp 185 ufs/mfs/mfs_vnops.c bp->b_error = copyout(bp->b_data, base, bp->b_bcount);
bp 186 ufs/mfs/mfs_vnops.c if (bp->b_error)
bp 187 ufs/mfs/mfs_vnops.c bp->b_flags |= B_ERROR;
bp 189 ufs/mfs/mfs_vnops.c bp->b_resid = 0;
bp 191 ufs/mfs/mfs_vnops.c biodone(bp);
bp 223 ufs/mfs/mfs_vnops.c struct buf *bp;
bp 229 ufs/mfs/mfs_vnops.c while ((bp = mfsp->mfs_buflist) != NULL) {
bp 230 ufs/mfs/mfs_vnops.c mfsp->mfs_buflist = bp->b_actf;
bp 231 ufs/mfs/mfs_vnops.c mfs_doio(bp, mfsp->mfs_baseoff);
bp 232 ufs/mfs/mfs_vnops.c wakeup((caddr_t)bp);
bp 96 ufs/ufs/ufs_bmap.c struct buf *bp;
bp 148 ufs/ufs/ufs_bmap.c for (bp = NULL, ++xap; --num; ++xap) {
bp 162 ufs/ufs/ufs_bmap.c if (bp)
bp 163 ufs/ufs/ufs_bmap.c brelse(bp);
bp 166 ufs/ufs/ufs_bmap.c bp = getblk(vp, metalbn, mp->mnt_stat.f_iosize, 0, 0);
bp 167 ufs/ufs/ufs_bmap.c if (bp->b_flags & (B_DONE | B_DELWRI)) {
bp 175 ufs/ufs/ufs_bmap.c bp->b_blkno = blkptrtodb(ump, daddr);
bp 176 ufs/ufs/ufs_bmap.c bp->b_flags |= B_READ;
bp 177 ufs/ufs/ufs_bmap.c VOP_STRATEGY(bp);
bp 179 ufs/ufs/ufs_bmap.c if ((error = biowait(bp)) != 0) {
bp 180 ufs/ufs/ufs_bmap.c brelse(bp);
bp 187 ufs/ufs/ufs_bmap.c daddr = ((daddr64_t *)bp->b_data)[xap->in_off];
bp 192 ufs/ufs/ufs_bmap.c ((daddr64_t *)bp->b_data)[bn - 1],
bp 193 ufs/ufs/ufs_bmap.c ((daddr64_t *)bp->b_data)[bn]);
bp 201 ufs/ufs/ufs_bmap.c daddr = ((daddr_t *)bp->b_data)[xap->in_off];
bp 206 ufs/ufs/ufs_bmap.c ((daddr_t *)bp->b_data)[bn - 1],
bp 207 ufs/ufs/ufs_bmap.c ((daddr_t *)bp->b_data)[bn]);
bp 210 ufs/ufs/ufs_bmap.c if (bp)
bp 211 ufs/ufs/ufs_bmap.c brelse(bp);
bp 110 ufs/ufs/ufs_dirhash.c struct buf *bp = NULL;
bp 211 ufs/ufs/ufs_dirhash.c if (bp != NULL)
bp 212 ufs/ufs/ufs_dirhash.c brelse(bp);
bp 213 ufs/ufs/ufs_dirhash.c if (UFS_BUFATOFF(ip, (off_t)pos, NULL, &bp) != 0)
bp 218 ufs/ufs/ufs_dirhash.c ep = (struct direct *)((char *)bp->b_data + (pos & bmask));
bp 222 ufs/ufs/ufs_dirhash.c brelse(bp);
bp 237 ufs/ufs/ufs_dirhash.c if (bp != NULL)
bp 238 ufs/ufs/ufs_dirhash.c brelse(bp);
bp 318 ufs/ufs/ufs_dirhash.c struct buf *bp;
bp 367 ufs/ufs/ufs_dirhash.c bp = NULL;
bp 402 ufs/ufs/ufs_dirhash.c if (bp != NULL)
bp 403 ufs/ufs/ufs_dirhash.c brelse(bp);
bp 405 ufs/ufs/ufs_dirhash.c if (UFS_BUFATOFF(ip, (off_t)blkoff, NULL, &bp) != 0)
bp 408 ufs/ufs/ufs_dirhash.c dp = (struct direct *)(bp->b_data + (offset & bmask));
bp 412 ufs/ufs/ufs_dirhash.c brelse(bp);
bp 423 ufs/ufs/ufs_dirhash.c brelse(bp);
bp 436 ufs/ufs/ufs_dirhash.c *bpp = bp;
bp 444 ufs/ufs/ufs_dirhash.c if (bp != NULL)
bp 445 ufs/ufs/ufs_dirhash.c brelse(bp);
bp 459 ufs/ufs/ufs_dirhash.c if (bp != NULL)
bp 460 ufs/ufs/ufs_dirhash.c brelse(bp);
bp 485 ufs/ufs/ufs_dirhash.c struct buf *bp;
bp 513 ufs/ufs/ufs_dirhash.c error = UFS_BUFATOFF(ip, (off_t)pos, (char **)&dp, &bp);
bp 520 ufs/ufs/ufs_dirhash.c brelse(bp);
bp 529 ufs/ufs/ufs_dirhash.c brelse(bp);
bp 541 ufs/ufs/ufs_dirhash.c brelse(bp);
bp 548 ufs/ufs/ufs_dirhash.c brelse(bp);
bp 553 ufs/ufs/ufs_dirhash.c brelse(bp);
bp 110 ufs/ufs/ufs_lookup.c struct buf *bp; /* a buffer of directory entries */
bp 138 ufs/ufs/ufs_lookup.c bp = NULL;
bp 220 ufs/ufs/ufs_lookup.c &dp->i_offset, &bp, nameiop == DELETE ? &prevoff : NULL)) {
bp 222 ufs/ufs/ufs_lookup.c ep = (struct direct *)((char *)bp->b_data +
bp 244 ufs/ufs/ufs_lookup.c (error = UFS_BUFATOFF(dp, (off_t)dp->i_offset, NULL, &bp)))
bp 259 ufs/ufs/ufs_lookup.c if (bp != NULL)
bp 260 ufs/ufs/ufs_lookup.c brelse(bp);
bp 262 ufs/ufs/ufs_lookup.c &bp);
bp 283 ufs/ufs/ufs_lookup.c ep = (struct direct *)((char *)bp->b_data + entryoffsetinblock);
bp 371 ufs/ufs/ufs_lookup.c if (bp != NULL)
bp 372 ufs/ufs/ufs_lookup.c brelse(bp);
bp 452 ufs/ufs/ufs_lookup.c brelse(bp);
bp 704 ufs/ufs/ufs_lookup.c struct buf *bp;
bp 729 ufs/ufs/ufs_lookup.c cr, flags, &bp)) != 0) {
bp 740 ufs/ufs/ufs_lookup.c bcopy((caddr_t)dirp, (caddr_t)bp->b_data + blkoff,newentrysize);
bp 746 ufs/ufs/ufs_lookup.c ufsdirhash_checkblock(dp, (char *)bp->b_data + blkoff,
bp 759 ufs/ufs/ufs_lookup.c while (blkoff < bp->b_bcount) {
bp 761 ufs/ufs/ufs_lookup.c (bp->b_data + blkoff))->d_reclen = DIRBLKSIZ;
bp 764 ufs/ufs/ufs_lookup.c if (softdep_setup_directory_add(bp, dp, dp->i_offset,
bp 766 ufs/ufs/ufs_lookup.c bdwrite(bp);
bp 779 ufs/ufs/ufs_lookup.c if ((error = VOP_BWRITE(bp)))
bp 788 ufs/ufs/ufs_lookup.c error = VOP_BWRITE(bp);
bp 816 ufs/ufs/ufs_lookup.c if ((error = UFS_BUFATOFF(dp, (off_t)dp->i_offset, &dirbuf, &bp))
bp 903 ufs/ufs/ufs_lookup.c (void)softdep_setup_directory_add(bp, dp,
bp 906 ufs/ufs/ufs_lookup.c bdwrite(bp);
bp 908 ufs/ufs/ufs_lookup.c error = VOP_BWRITE(bp);
bp 954 ufs/ufs/ufs_lookup.c struct buf *bp;
bp 960 ufs/ufs/ufs_lookup.c (off_t)(dp->i_offset - dp->i_count), (char **)&ep, &bp)) != 0)
bp 993 ufs/ufs/ufs_lookup.c softdep_setup_remove(bp, dp, ip, isrmdir);
bp 996 ufs/ufs/ufs_lookup.c error = bwrite(bp);
bp 998 ufs/ufs/ufs_lookup.c bdwrite(bp);
bp 1008 ufs/ufs/ufs_lookup.c bdwrite(bp);
bp 1011 ufs/ufs/ufs_lookup.c error = bwrite(bp);
bp 1026 ufs/ufs/ufs_lookup.c struct buf *bp;
bp 1031 ufs/ufs/ufs_lookup.c error = UFS_BUFATOFF(dp, (off_t)dp->i_offset, (char **)&ep, &bp);
bp 1040 ufs/ufs/ufs_lookup.c softdep_setup_directory_change(bp, dp, oip, newinum, isrmdir);
bp 1041 ufs/ufs/ufs_lookup.c bdwrite(bp);
bp 1046 ufs/ufs/ufs_lookup.c bdwrite(bp);
bp 1049 ufs/ufs/ufs_lookup.c error = VOP_BWRITE(bp);
bp 1095 ufs/ufs/ufs_vnops.c struct buf *bp;
bp 1166 ufs/ufs/ufs_vnops.c B_CLRBUF, &bp)) != 0)
bp 1171 ufs/ufs/ufs_vnops.c bcopy((caddr_t)&dirtemplate, (caddr_t)bp->b_data, sizeof dirtemplate);
bp 1180 ufs/ufs/ufs_vnops.c while (blkoff < bp->b_bcount) {
bp 1182 ufs/ufs/ufs_vnops.c (bp->b_data + blkoff))->d_reclen = DIRBLKSIZ;
bp 1187 ufs/ufs/ufs_vnops.c (void)VOP_BWRITE(bp);
bp 1202 ufs/ufs/ufs_vnops.c if (!DOINGSOFTDEP(dvp) && ((error = VOP_BWRITE(bp)) != 0))
bp 1205 ufs/ufs/ufs_vnops.c error = ufs_direnter(dvp, tvp, &newdir, cnp, bp);
bp 1546 ufs/ufs/ufs_vnops.c struct buf *bp = ap->a_bp;
bp 1547 ufs/ufs/ufs_vnops.c struct vnode *vp = bp->b_vp;
bp 1555 ufs/ufs/ufs_vnops.c if (bp->b_blkno == bp->b_lblkno) {
bp 1556 ufs/ufs/ufs_vnops.c error = VOP_BMAP(vp, bp->b_lblkno, NULL, &bp->b_blkno,
bp 1559 ufs/ufs/ufs_vnops.c bp->b_error = error;
bp 1560 ufs/ufs/ufs_vnops.c bp->b_flags |= B_ERROR;
bp 1562 ufs/ufs/ufs_vnops.c biodone(bp);
bp 1566 ufs/ufs/ufs_vnops.c if ((long)bp->b_blkno == -1)
bp 1567 ufs/ufs/ufs_vnops.c clrbuf(bp);
bp 1569 ufs/ufs/ufs_vnops.c if ((long)bp->b_blkno == -1) {
bp 1571 ufs/ufs/ufs_vnops.c biodone(bp);
bp 1576 ufs/ufs/ufs_vnops.c bp->b_dev = vp->v_rdev;
bp 741 uvm/uvm_pager.c uvm_aio_biodone1(bp)
bp 742 uvm/uvm_pager.c struct buf *bp;
bp 744 uvm/uvm_pager.c struct buf *mbp = bp->b_private;
bp 748 uvm/uvm_pager.c KASSERT(mbp != bp);
bp 749 uvm/uvm_pager.c if (bp->b_flags & B_ERROR) {
bp 751 uvm/uvm_pager.c mbp->b_error = bp->b_error;
bp 753 uvm/uvm_pager.c mbp->b_resid -= bp->b_bcount;
bp 754 uvm/uvm_pager.c pool_put(&bufpool, bp);
bp 769 uvm/uvm_pager.c uvm_aio_biodone(bp)
bp 770 uvm/uvm_pager.c struct buf *bp;
bp 775 uvm/uvm_pager.c bp->b_iodone = uvm_aio_aiodone;
bp 778 uvm/uvm_pager.c TAILQ_INSERT_TAIL(&uvm.aio_done, bp, b_freelist);
bp 789 uvm/uvm_pager.c uvm_aio_aiodone(bp)
bp 790 uvm/uvm_pager.c struct buf *bp;
bp 792 uvm/uvm_pager.c int npages = bp->b_bufsize >> PAGE_SHIFT;
bp 798 uvm/uvm_pager.c UVMHIST_LOG(pdhist, "bp %p", bp, 0,0,0);
bp 802 uvm/uvm_pager.c error = (bp->b_flags & B_ERROR) ? (bp->b_error ? bp->b_error : EIO) : 0;
bp 803 uvm/uvm_pager.c write = (bp->b_flags & B_READ) == 0;
bp 806 uvm/uvm_pager.c if (write && !(bp->b_flags & B_NOCACHE) && bioops.io_pageiodone) {
bp 807 uvm/uvm_pager.c (*bioops.io_pageiodone)(bp);
bp 813 uvm/uvm_pager.c pgs[i] = uvm_pageratop((vaddr_t)bp->b_data + (i << PAGE_SHIFT));
bp 816 uvm/uvm_pager.c uvm_pagermapout((vaddr_t)bp->b_data, npages);
bp 883 uvm/uvm_pager.c if (write && (bp->b_flags & B_AGE) != 0 && bp->b_vp != NULL) {
bp 884 uvm/uvm_pager.c vwakeup(bp->b_vp);
bp 886 uvm/uvm_pager.c pool_put(&bufpool, bp);
bp 289 uvm/uvm_pdaemon.c struct buf *bp, *nbp;
bp 316 uvm/uvm_pdaemon.c bp = TAILQ_FIRST(&uvm.aio_done);
bp 317 uvm/uvm_pdaemon.c if (bp) {
bp 329 uvm/uvm_pdaemon.c while (bp != NULL) {
bp 330 uvm/uvm_pdaemon.c if (bp->b_flags & B_PDAEMON) {
bp 331 uvm/uvm_pdaemon.c uvmexp.paging -= bp->b_bufsize >> PAGE_SHIFT;
bp 333 uvm/uvm_pdaemon.c nbp = TAILQ_NEXT(bp, b_freelist);
bp 335 uvm/uvm_pdaemon.c (*bp->b_iodone)(bp);
bp 337 uvm/uvm_pdaemon.c bp = nbp;
bp 1206 uvm/uvm_swap.c swstrategy(bp)
bp 1207 uvm/uvm_swap.c struct buf *bp;
bp 1218 uvm/uvm_swap.c pageno = dbtob((int64_t)bp->b_blkno) >> PAGE_SHIFT;
bp 1223 uvm/uvm_swap.c bp->b_error = EINVAL;
bp 1224 uvm/uvm_swap.c bp->b_flags |= B_ERROR;
bp 1226 uvm/uvm_swap.c biodone(bp);
bp 1240 uvm/uvm_swap.c ((bp->b_flags & B_READ) == 0) ? "write" : "read",
bp 1241 uvm/uvm_swap.c sdp->swd_drumoffset, bn, bp->b_bcount);
bp 1260 uvm/uvm_swap.c buf_replacevnode(bp, sdp->swd_vp);
bp 1262 uvm/uvm_swap.c bp->b_blkno = bn;
bp 1264 uvm/uvm_swap.c VOP_STRATEGY(bp);
bp 1271 uvm/uvm_swap.c sw_reg_strategy(sdp, bp, bn);
bp 1281 uvm/uvm_swap.c sw_reg_strategy(sdp, bp, bn)
bp 1283 uvm/uvm_swap.c struct buf *bp;
bp 1302 uvm/uvm_swap.c vnx->vx_bp = bp;
bp 1310 uvm/uvm_swap.c bp->b_resid = bp->b_bcount; /* nothing transferred yet! */
bp 1311 uvm/uvm_swap.c addr = bp->b_data; /* current position in buffer */
bp 1314 uvm/uvm_swap.c for (resid = bp->b_resid; resid; resid -= sz) {
bp 1374 uvm/uvm_swap.c nbp->vb_buf.b_flags = bp->b_flags | B_CALL;
bp 1380 uvm/uvm_swap.c nbp->vb_buf.b_proc = bp->b_proc;
bp 1391 uvm/uvm_swap.c if (bp->b_dirtyend == 0) {
bp 1396 uvm/uvm_swap.c max(0, bp->b_dirtyoff - (bp->b_bcount-resid));
bp 1399 uvm/uvm_swap.c max(0, bp->b_dirtyend - (bp->b_bcount-resid)));
bp 1401 uvm/uvm_swap.c if (bp->b_validend == 0) {
bp 1406 uvm/uvm_swap.c max(0, bp->b_validoff - (bp->b_bcount-resid));
bp 1409 uvm/uvm_swap.c max(0, bp->b_validend - (bp->b_bcount-resid)));
bp 1446 uvm/uvm_swap.c bp->b_error = vnx->vx_error;
bp 1447 uvm/uvm_swap.c bp->b_flags |= B_ERROR;
bp 1450 uvm/uvm_swap.c biodone(bp);
bp 1464 uvm/uvm_swap.c struct buf *bp;
bp 1474 uvm/uvm_swap.c bp = sdp->swd_tab.b_actf;
bp 1475 uvm/uvm_swap.c if (bp == NULL)
bp 1477 uvm/uvm_swap.c sdp->swd_tab.b_actf = bp->b_actf;
bp 1482 uvm/uvm_swap.c bp, bp->b_vp, bp->b_blkno, bp->b_bcount);
bp 1483 uvm/uvm_swap.c if ((bp->b_flags & B_READ) == 0)
bp 1484 uvm/uvm_swap.c bp->b_vp->v_numoutput++;
bp 1486 uvm/uvm_swap.c VOP_STRATEGY(bp);
bp 1497 uvm/uvm_swap.c sw_reg_iodone(bp)
bp 1498 uvm/uvm_swap.c struct buf *bp;
bp 1500 uvm/uvm_swap.c struct vndbuf *vbp = (struct vndbuf *) bp;
bp 1804 uvm/uvm_swap.c struct buf *bp;
bp 1924 uvm/uvm_swap.c bp = pool_get(&bufpool, pflag);
bp 1930 uvm/uvm_swap.c if (bp == NULL) {
bp 1962 uvm/uvm_swap.c bp->b_flags = B_BUSY | B_NOCACHE | (flags & (B_READ|B_ASYNC));
bp 1963 uvm/uvm_swap.c bp->b_proc = &proc0; /* XXX */
bp 1964 uvm/uvm_swap.c bp->b_vnbufs.le_next = NOLIST;
bp 1965 uvm/uvm_swap.c bp->b_data = (caddr_t)kva;
bp 1966 uvm/uvm_swap.c bp->b_blkno = startblk;
bp 1967 uvm/uvm_swap.c LIST_INIT(&bp->b_dep);
bp 1969 uvm/uvm_swap.c bp->b_vp = NULL;
bp 1970 uvm/uvm_swap.c buf_replacevnode(bp, swapdev_vp);
bp 1972 uvm/uvm_swap.c bp->b_bufsize = bp->b_bcount = npages << PAGE_SHIFT;
bp 1979 uvm/uvm_swap.c bp->b_dirtyoff = 0;
bp 1980 uvm/uvm_swap.c bp->b_dirtyend = npages << PAGE_SHIFT;
bp 1995 uvm/uvm_swap.c bp->b_flags |= B_CALL | (curproc == uvm.pagedaemon_proc ?
bp 1997 uvm/uvm_swap.c bp->b_iodone = uvm_aio_biodone;
bp 2002 uvm/uvm_swap.c bp->b_data, bp->b_blkno, bp->b_bcount, 0);
bp 2007 uvm/uvm_swap.c VOP_STRATEGY(bp);
bp 2014 uvm/uvm_swap.c (void) biowait(bp);
bp 2015 uvm/uvm_swap.c result = (bp->b_flags & B_ERROR) ? VM_PAGER_ERROR : VM_PAGER_OK;
bp 2022 uvm/uvm_swap.c (bp->b_flags & B_READ) && !(bp->b_flags & B_ERROR)) {
bp 2024 uvm/uvm_swap.c caddr_t data = bp->b_data;
bp 2049 uvm/uvm_swap.c if ((bp->b_flags & B_READ) == 0 && encrypt)
bp 2056 uvm/uvm_swap.c if (bp->b_vp)
bp 2057 uvm/uvm_swap.c brelvp(bp);
bp 2059 uvm/uvm_swap.c if (write && bp->b_vp)
bp 2060 uvm/uvm_swap.c vwakeup(bp->b_vp);
bp 2061 uvm/uvm_swap.c pool_put(&bufpool, bp);