Lines Matching refs:bp
264 buf_t bp;
279 bp = alloc_io_buf(jnl->jdev, 1);
302 buf_setflags(bp, B_READ);
309 buf_setsize(bp, curlen);
310 buf_setcount(bp, curlen);
311 buf_setdataptr(bp, (uintptr_t)data);
312 buf_setblkno(bp, (daddr64_t) ((jnl->jdev_offset + *offset) / (off_t)jnl->jhdr->jhdr_size));
313 buf_setlblkno(bp, (daddr64_t) ((jnl->jdev_offset + *offset) / (off_t)jnl->jhdr->jhdr_size));
315 buf_markfua(bp);
318 err = VNOP_STRATEGY(bp);
320 err = (int)buf_biowait(bp);
322 free_io_buf(bp);
462 buffer_flushed_callback(struct buf *bp, void *arg)
471 //printf("jnl: buf flush: bp @ 0x%x l/blkno %qd/%qd vp 0x%x tr @ 0x%x\n",
472 // bp, buf_lblkno(bp), buf_blkno(bp), buf_vnode(bp), arg);
475 bufsize = buf_size(bp);
2269 journal_modify_block_start(journal *jnl, struct buf *bp)
2281 if ((buf_flags(bp) & B_META) == 0) {
2282 panic("jnl: modify_block_start: bp @ %p is not a meta-data block! (jnl %p)\n", bp, jnl);
2295 //printf("jnl: mod block start (bp 0x%x vp 0x%x l/blkno %qd/%qd bsz %d; total bytes %d)\n",
2296 // bp, buf_vnode(bp), buf_lblkno(bp), buf_blkno(bp), buf_size(bp), tr->total_bytes);
2300 if ((buf_size(bp) % jnl->jhdr->jhdr_size) != 0) {
2302 buf_size(bp), jnl->jhdr->jhdr_size);
2307 if (tr->total_bytes+buf_size(bp) >= (jnl->jhdr->size - jnl->jhdr->jhdr_size)) {
2308 panic("jnl: transaction too big (%d >= %lld bytes, bufsize %d, tr %p bp %p)\n",
2309 tr->total_bytes, (tr->jnl->jhdr->size - jnl->jhdr->jhdr_size), buf_size(bp), tr, bp);
2317 if ((buf_flags(bp) & (B_DELWRI | B_LOCKED)) == B_DELWRI) {
2319 if (buf_flags(bp) & B_ASYNC) {
2320 panic("modify_block_start: bp @ %p has async flag set!\n", bp);
2324 buf_setflags(bp, B_NORELSE);
2325 VNOP_BWRITE(bp);
2327 buf_setflags(bp, B_LOCKED);
2333 journal_modify_block_abort(journal *jnl, struct buf *bp)
2349 buf_brelse(bp);
2366 // printf("jnl: modify_block_abort: tr 0x%x bp 0x%x\n", jnl->active_tr, bp);
2371 if (bp == blhdr->binfo[i].b.bp) {
2372 if (buf_size(bp) != blhdr->binfo[i].bsize) {
2373 panic("jnl: bp @ %p changed size on me! (%d vs. %lu, jnl %p)\n",
2374 bp, buf_size(bp), blhdr->binfo[i].bsize, jnl);
2393 buf_clearflags(bp, B_LOCKED);
2396 buf_brelse(bp);
2402 journal_modify_block_end(journal *jnl, struct buf *bp, void (*func)(struct buf *bp, void *arg), void *arg)
2426 //printf("jnl: mod block end: (bp 0x%x vp 0x%x l/blkno %qd/%qd bsz %d, total bytes %d)\n",
2427 // bp, buf_vnode(bp), buf_lblkno(bp), buf_blkno(bp), buf_size(bp), tr->total_bytes);
2429 if ((buf_flags(bp) & B_LOCKED) == 0) {
2430 panic("jnl: modify_block_end: bp %p not locked! jnl @ %p\n", bp, jnl);
2438 if (bp == blhdr->binfo[i].b.bp) {
2439 if (buf_size(bp) != blhdr->binfo[i].bsize) {
2440 panic("jnl: bp @ %p changed size on me! (%d vs. %lu, jnl %p)\n",
2441 bp, buf_size(bp), blhdr->binfo[i].bsize, jnl);
2456 && (prev->bytes_used+buf_size(bp)) <= (uint32_t)tr->tbuffer_size) {
2462 panic("jnl: modify block end: no way man, prev == NULL?!?, jnl %p, bp %p\n", jnl, bp);
2512 memcpy(blkptr, (char *)0 + buf_dataptr(bp), buf_size(bp));
2520 vp = buf_vnode(bp);
2522 bsize = buf_size(bp);
2524 blhdr->binfo[i].bnum = (off_t)(buf_blkno(bp));
2526 blhdr->binfo[i].b.bp = bp;
2530 buf_setfilter(bp, func, arg, &old_func, &old_arg);
2541 buf_bdwrite(bp);
2547 journal_kill_block(journal *jnl, struct buf *bp)
2570 bflags = buf_flags(bp);
2573 panic("jnl: modify_block_end: called with bp not B_LOCKED");
2576 * bp must be BL_BUSY and B_LOCKED
2582 if (bp == blhdr->binfo[i].b.bp) {
2585 buf_clearflags(bp, B_LOCKED);
2588 vp = buf_vnode(bp);
2597 // panic("jnl: kill block: this defies all logic! bp 0x%x\n", bp);
2599 tr->num_killed += buf_size(bp);
2601 blhdr->binfo[i].b.bp = NULL;
2604 buf_markinvalid(bp);
2605 buf_brelse(bp);
2627 if (bi_a->b.bp == NULL) {
2630 if (bi_b->b.bp == NULL) {
2637 res = (buf_blkno(bi_a->b.bp) - buf_blkno(bi_b->b.bp));
2680 struct buf *bp, **bparray;
2771 bp = blhdr->binfo[i].b.bp;
2774 // it now and then copy the data from the bp into
2776 if (bp) {
2780 buf_setfilter(bp, NULL, NULL, (void **)&func, &arg);
2783 // acquire the bp here so that we can safely
2788 errno = buf_acquire(bp, 0, 0, 0);
2795 func(bp, arg);
2798 memcpy(blkptr, (char *)buf_dataptr(bp), buf_size(bp));
2800 buf_drop(bp);
2802 panic("could not acquire bp %p (err %d)\n", bp, errno);
2806 } else { // bp == NULL, only true if a block was "killed"
2808 panic("jnl: inconsistent binfo (NULL bp w/bnum %lld; jnl @ %p, tr %p)\n",
2818 vp = buf_vnode(bp);
2819 blkno = buf_blkno(bp);
2820 lblkno = buf_lblkno(bp);
2823 printf("jnl: %s: end_tr: bad news! bp @ %p w/null vp and l/blkno = %qd/%qd. aborting the transaction (tr %p jnl %p).\n",
2824 jnl->jdev_name, bp, lblkno, blkno, tr, jnl);
2828 // if the lblkno is the same as blkno and this bp isn't
2837 printf("jnl: %s: end_tr: vnop_blktooff failed @ %p, jnl %p\n", jnl->jdev_name, bp, jnl);
2840 if (VNOP_BLOCKMAP(vp, f_offset, buf_count(bp), &blkno, &contig_bytes, NULL, 0, NULL)) {
2841 printf("jnl: %s: end_tr: can't blockmap the bp @ %p, jnl %p\n", jnl->jdev_name, bp, jnl);
2844 if ((uint32_t)contig_bytes < buf_count(bp)) {
2845 printf("jnl: %s: end_tr: blk not physically contiguous on disk@ %p, jnl %p\n", jnl->jdev_name, bp, jnl);
2848 buf_setblkno(bp, blkno);
2874 bparray[i] = blhdr->binfo[i].b.bp;
2886 // always put the bp pointers back
2888 blhdr->binfo[i].b.bp = bparray[i];
2942 if (blhdr->binfo[i].b.bp == NULL) {
2946 bp = blhdr->binfo[i].b.bp;
2951 errno = buf_acquire(bp, BAC_REMOVE, 0, 0);
2958 if ((buf_flags(bp) & (B_LOCKED|B_DELWRI)) != (B_LOCKED|B_DELWRI)) {
2960 buf_clearflags(bp, B_LOCKED);
2961 buf_brelse(bp);
2964 panic("jnl: end_tr: !!!DANGER!!! bp %p flags (0x%x) not LOCKED & DELWRI\n", bp, buf_flags(bp));
2967 save_vp = buf_vnode(bp);
2969 buf_setfilter(bp, buffer_flushed_callback, tr, &cur_filter, NULL);
2972 panic("jnl: bp @ %p (blkno %qd, vp %p) has non-null iodone (%p) buffflushcb %p\n",
2973 bp, buf_blkno(bp), save_vp, cur_filter, buffer_flushed_callback);
2975 buf_clearflags(bp, B_LOCKED);
2978 buf_bawrite(bp);
2979 // XXXdbg this is good for testing: buf_bdwrite(bp);
2980 //buf_bdwrite(bp);
2986 jnl->jdev_name,bp, errno);
3015 struct buf *bp;
3026 if (blhdr->binfo[i].b.bp == NULL) {
3029 if ( (buf_vnode(blhdr->binfo[i].b.bp) == NULL) ||
3030 !(buf_flags(blhdr->binfo[i].b.bp) & B_LOCKED) ) {
3034 errno = buf_meta_bread(buf_vnode(blhdr->binfo[i].b.bp),
3035 buf_lblkno(blhdr->binfo[i].b.bp),
3036 buf_size(blhdr->binfo[i].b.bp),
3038 &bp);
3040 if (bp != blhdr->binfo[i].b.bp) {
3041 panic("jnl: abort_tr: got back a different bp! (bp %p should be %p, jnl %p\n",
3042 bp, blhdr->binfo[i].b.bp, jnl);
3045 // releasing a bp marked invalid
3047 buf_markinvalid(bp);
3048 save_vp = buf_vnode(bp);
3050 buf_brelse(bp);
3055 jnl->jdev_name, blhdr->binfo[i].bnum, blhdr->binfo[i].b.bp);
3056 if (bp) {
3057 buf_brelse(bp);