bsd/vfs/vfs_journal.c

335 	buf_t	bp;
350 	bp = alloc_io_buf(jnl->jdev, 1);
373 		buf_setflags(bp, B_READ);
380 	buf_setsize(bp, curlen);
381 	buf_setcount(bp, curlen);
382 	buf_setdataptr(bp, (uintptr_t)data);
383 	buf_setblkno(bp, (daddr64_t) ((jnl->jdev_offset + *offset) / (off_t)jnl->jhdr->jhdr_size));
384 	buf_setlblkno(bp, (daddr64_t) ((jnl->jdev_offset + *offset) / (off_t)jnl->jhdr->jhdr_size));
387 		buf_markfua(bp);
390 	DTRACE_IO1(journal__start, buf_t, bp);
391 	err = VNOP_STRATEGY(bp);
393 		err = (int)buf_biowait(bp);
395 	DTRACE_IO1(journal__done, buf_t, bp);
396 	free_io_buf(bp);
550 buffer_flushed_callback(struct buf *bp, void *arg)
559 	//printf("jnl: buf flush: bp @ 0x%x l/blkno %qd/%qd vp 0x%x tr @ 0x%x\n",
560 	//	   bp, buf_lblkno(bp), buf_blkno(bp), buf_vnode(bp), arg);
563 	bufsize = buf_size(bp);
2559 journal_modify_block_start(journal *jnl, struct buf *bp)
2574 	if ((buf_flags(bp) & B_META) == 0) {
2575 		panic("jnl: modify_block_start: bp @ %p is not a meta-data block! (jnl %p)\n", bp, jnl);
2586 	//printf("jnl: mod block start (bp 0x%x vp 0x%x l/blkno %qd/%qd bsz %d; total bytes %d)\n",
2587 	//   bp, buf_vnode(bp), buf_lblkno(bp), buf_blkno(bp), buf_size(bp), tr->total_bytes);
2591 	if ((buf_size(bp) % jnl->jhdr->jhdr_size) != 0) {
2599 				      phys_blksz, buf_size(bp), jnl->jhdr->jhdr_size);
2602 			if ((buf_size(bp) % phys_blksz) != 0) {
2633 			      buf_size(bp), jnl->jhdr->jhdr_size);
2639 	if (tr->total_bytes+buf_size(bp) >= (jnl->jhdr->size - jnl->jhdr->jhdr_size)) {
2640 		panic("jnl: transaction too big (%d >= %lld bytes, bufsize %d, tr %p bp %p)\n",
2641 		      tr->total_bytes, (tr->jnl->jhdr->size - jnl->jhdr->jhdr_size), buf_size(bp), tr, bp);
2649 	if ((buf_flags(bp) & (B_DELWRI | B_LOCKED)) == B_DELWRI) {
2651 		if (buf_flags(bp) & B_ASYNC) {
2652 			panic("modify_block_start: bp @ %p has async flag set!\n", bp);
2654 		if (bp->b_shadow_ref)
2655 			panic("modify_block_start: dirty bp @ %p has shadows!\n", bp);
2658                 buf_setflags(bp, B_NORELSE);
2659 		VNOP_BWRITE(bp);
2661 	buf_setflags(bp, B_LOCKED);
2667 journal_modify_block_abort(journal *jnl, struct buf *bp)
2685 		buf_brelse(bp);
2690     	/* Still need to buf_brelse(). Callers assume we consume the bp. */
2691     	buf_brelse(bp);
2702 	// printf("jnl: modify_block_abort: tr 0x%x bp 0x%x\n", jnl->active_tr, bp);
2707 			if (bp == blhdr->binfo[i].u.bp) {
2725 		buf_clearflags(bp, B_LOCKED);
2728 	buf_brelse(bp);
2734 journal_modify_block_end(journal *jnl, struct buf *bp, void (*func)(buf_t bp, void *arg), void *arg)
2746     	/* Still need to buf_brelse(). Callers assume we consume the bp. */
2747     	buf_brelse(bp);
2759 	//printf("jnl: mod block end:  (bp 0x%x vp 0x%x l/blkno %qd/%qd bsz %d, total bytes %d)\n",
2760 	//   bp, buf_vnode(bp), buf_lblkno(bp), buf_blkno(bp), buf_size(bp), tr->total_bytes);
2762 	if ((buf_flags(bp) & B_LOCKED) == 0) {
2763 		panic("jnl: modify_block_end: bp %p not locked! jnl @ %p\n", bp, jnl);
2771 			if (bp == blhdr->binfo[i].u.bp) {
2775 				tbuffer_offset += buf_size(blhdr->binfo[i].u.bp);
2789 	    && (prev->bytes_used+buf_size(bp)) <= (uint32_t)tr->tbuffer_size) {
2795 			panic("jnl: modify block end: no way man, prev == NULL?!?, jnl %p, bp %p\n", jnl, bp);
2843 		vp = buf_vnode(bp);
2845 		bsize = buf_size(bp);
2847 		blhdr->binfo[i].bnum = (off_t)(buf_blkno(bp));
2848 		blhdr->binfo[i].u.bp = bp;
2853 			buf_setfilter(bp, func, arg, &old_func, &old_arg);
2864 	buf_bdwrite(bp);
2870 journal_kill_block(journal *jnl, struct buf *bp)
2893 	bflags = buf_flags(bp);
2896 		panic("jnl: modify_block_end: called with bp not B_LOCKED");
2899 	 * bp must be BL_BUSY and B_LOCKED
2905 			if (bp == blhdr->binfo[i].u.bp) {
2908 				buf_clearflags(bp, B_LOCKED);
2911 				vp = buf_vnode(bp);
2920 				//	panic("jnl: kill block: this defies all logic! bp 0x%x\n", bp);
2922 					tr->num_killed += buf_size(bp);
2925 				blhdr->binfo[i].u.bp = NULL;
2926 				blhdr->binfo[i].u.bi.bsize = buf_size(bp);
2928 				buf_markinvalid(bp);
2929 				buf_brelse(bp);
3527 	res = (buf_blkno(bi_a->u.bp) - buf_blkno(bi_b->u.bp));
3570 	struct buf	*bp;
3716 				bp = blhdr->binfo[i].u.bp;
3718 				if (bp == NULL) {
3719 					panic("jnl: inconsistent binfo (NULL bp w/bnum %lld; jnl @ %p, tr %p)\n",
3723 				 * acquire the bp here so that we can safely
3729 					errno = buf_acquire(bp, BAC_REMOVE, 0, 0);
3733 					panic("could not acquire bp %p (err %d)\n", bp, errno);
3735 				if ((buf_flags(bp) & (B_LOCKED|B_DELWRI)) != (B_LOCKED|B_DELWRI)) {
3737 						buf_clearflags(bp, B_LOCKED);
3738 						buf_brelse(bp);
3744 						 * the bp that is recorded in our array no longer belongs
3745 						 * to us (normally we substitute a shadow bp to be processed
3752 						panic("jnl: end_tr: !!!DANGER!!! bp %p flags (0x%x) not LOCKED & DELWRI\n", bp, buf_flags(bp));
3755 				bsize = buf_size(bp);
3757 				buf_setfilter(bp, NULL, NULL, &func, &arg);
3761 				sbp = buf_create_shadow_priv(bp, FALSE, (uintptr_t)blkptr, 0, 0);
3769 				memcpy(blkptr, (char *)buf_dataptr(bp), bsize);
3771 				buf_clearflags(bp, B_LOCKED);
3772 				buf_markclean(bp);
3773 				buf_drop(bp);
3786 				blhdr->binfo[i].u.bp = sbp;
3872 	buf_t		bp, *bparray;
3910 				bp = blhdr->binfo[i].u.bp;
3912 				vp = buf_vnode(bp);
3913 				blkno = buf_blkno(bp);
3914 				lblkno = buf_lblkno(bp);
3917 					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",
3918 					       jnl->jdev_name, bp, lblkno, blkno, tr, jnl);
3923 				// if the lblkno is the same as blkno and this bp isn't
3932 						printf("jnl: %s: end_tr: vnop_blktooff failed @ %p, jnl %p\n", jnl->jdev_name, bp, jnl);
3936 					if (VNOP_BLOCKMAP(vp, f_offset, buf_count(bp), &blkno, &contig_bytes, NULL, 0, NULL)) {
3937 						printf("jnl: %s: end_tr: can't blockmap the bp @ %p, jnl %p\n", jnl->jdev_name, bp, jnl);
3941 					if ((uint32_t)contig_bytes < buf_count(bp)) {
3942 						printf("jnl: %s: end_tr: blk not physically contiguous on disk@ %p, jnl %p\n", jnl->jdev_name, bp, jnl);
3946 					buf_setblkno(bp, blkno);
3955 				buf_setfilter(bp, buffer_flushed_callback, tr, &func, &arg);
3963 					func(bp, arg);
3965 				bparray[i] = bp;
3966 				bsize = buf_size(bp);
3988 		 * put the bp pointers back so that we can
3992 			blhdr->binfo[i].u.bp = bparray[i];
4078 			if ((bp = blhdr->binfo[i].u.bp)) {
4079 				vp = buf_vnode(bp);
4081 				buf_bawrite(bp);
4209 			buf_t		bp, tbp, sbp;
4216 			tbp = blhdr->binfo[i].u.bp;
4232 						       &bp);
4234 					if (sbp == NULL && bp != tbp && (buf_flags(tbp) & B_LOCKED)) {
4235 						panic("jnl: abort_tr: got back a different bp! (bp %p should be %p, jnl %p\n",
4236 						      bp, tbp, jnl);
4244 					buf_setflags(bp, B_LOCKED);
4245 					buf_markclean(bp);
4246 					buf_brelse(bp);
4248 					KERNEL_DEBUG(0xbbbbc034|DBG_FUNC_NONE, jnl, tr, bp, 0, 0);
4257 					if (bp) {
4258 						buf_brelse(bp);
4664 journal_modify_block_start(__unused journal *jnl, __unused struct buf *bp)
4671 			 __unused struct buf *bp,
4672 			 __unused void (*func)(struct buf *bp, void *arg),
4679 journal_kill_block(__unused journal *jnl, __unused struct buf *bp)