Major BUF/BIO work commit. Make I/O BIO-centric and specify the disk or
authorMatthew Dillon <dillon@dragonflybsd.org>
Fri, 24 Mar 2006 18:35:34 +0000 (18:35 +0000)
committerMatthew Dillon <dillon@dragonflybsd.org>
Fri, 24 Mar 2006 18:35:34 +0000 (18:35 +0000)
file location with a 64 bit offset instead of a 32 bit block number.

* All I/O is now BIO-centric instead of BUF-centric.

* File/Disk addresses universally use a 64 bit bio_offset now.  bio_blkno
  no longer exists.

* Stackable BIO's hold disk offset translations.  Translations are no longer
  overloaded onto a single structure (BUF or BIO).

* bio_offset == NOOFFSET is now universally used to indicate that a
  translation has not been made.  The old (blkno == lblkno) junk has all
  been removed.

* There is no longer a distinction between logical I/O and physical I/O.

* All driver BUFQs have been converted to BIOQs.

* BMAP, FREEBLKS, getblk, bread, breadn, bwrite, inmem, cluster_*,
  and findblk all now take and/or return 64 bit byte offsets instead
  of block numbers.  Note that BMAP now returns a byte range for the before
  and after variables.

122 files changed:
lib/libstand/ufs.c
sbin/clri/clri.c
sys/bus/cam/scsi/scsi_cd.c
sys/bus/cam/scsi/scsi_da.c
sys/bus/cam/scsi/scsi_pass.c
sys/conf/bsd.kern.mk
sys/contrib/dev/fla/fla.c
sys/cpu/i386/include/param.h
sys/dev/disk/ata/ata-disk.c
sys/dev/disk/ata/ata-raid.c
sys/dev/disk/ata/atapi-cd.c
sys/dev/disk/ata/atapi-fd.c
sys/dev/disk/ata/atapi-tape.c
sys/dev/disk/ccd/ccd.c
sys/dev/disk/fd/fd.c
sys/dev/disk/mcd/mcd.c
sys/dev/disk/md/md.c
sys/dev/disk/scd/scd.c
sys/dev/disk/vn/vn.c
sys/dev/raid/aac/aac.c
sys/dev/raid/aac/aac_disk.c
sys/dev/raid/amr/amr.c
sys/dev/raid/ida/ida.c
sys/dev/raid/ips/ips_commands.c
sys/dev/raid/mlx/mlx.c
sys/dev/raid/pst/pst-raid.c
sys/dev/raid/twe/twe.c
sys/dev/raid/vinum/.gdbinit.kernel
sys/dev/raid/vinum/.gdbinit.vinum
sys/dev/raid/vinum/vinumdaemon.c
sys/dev/raid/vinum/vinuminterrupt.c
sys/dev/raid/vinum/vinumio.c
sys/dev/raid/vinum/vinumrequest.c
sys/dev/raid/vinum/vinumrevive.c
sys/emulation/linux/i386/linprocfs/linprocfs_vnops.c
sys/i386/i386/machdep.c
sys/i386/include/param.h
sys/kern/kern_physio.c
sys/kern/kern_shutdown.c
sys/kern/subr_disk.c
sys/kern/subr_diskmbr.c
sys/kern/subr_diskslice.c
sys/kern/vfs_aio.c
sys/kern/vfs_bio.c
sys/kern/vfs_cluster.c
sys/kern/vfs_init.c
sys/kern/vfs_subr.c
sys/kern/vfs_vopops.c
sys/platform/pc32/i386/machdep.c
sys/sys/bio.h
sys/sys/buf.h
sys/sys/buf2.h
sys/sys/ccdvar.h
sys/sys/disklabel.h
sys/sys/disklabel32.h
sys/sys/odisklabel.h
sys/sys/vfsops.h
sys/sys/vnode.h
sys/vfs/coda/coda_vnops.c
sys/vfs/deadfs/dead_vnops.c
sys/vfs/fifofs/fifo_vnops.c
sys/vfs/gnu/ext2fs/ext2_alloc.c
sys/vfs/gnu/ext2fs/ext2_balloc.c
sys/vfs/gnu/ext2fs/ext2_inode.c
sys/vfs/gnu/ext2fs/ext2_linux_balloc.c
sys/vfs/gnu/ext2fs/ext2_linux_ialloc.c
sys/vfs/gnu/ext2fs/ext2_readwrite.c
sys/vfs/gnu/ext2fs/ext2_subr.c
sys/vfs/gnu/ext2fs/ext2_vfsops.c
sys/vfs/gnu/ext2fs/fs.h
sys/vfs/hpfs/hpfs.h
sys/vfs/hpfs/hpfs_alsubr.c
sys/vfs/hpfs/hpfs_subr.c
sys/vfs/hpfs/hpfs_vfsops.c
sys/vfs/hpfs/hpfs_vnops.c
sys/vfs/isofs/cd9660/cd9660_bmap.c
sys/vfs/isofs/cd9660/cd9660_lookup.c
sys/vfs/isofs/cd9660/cd9660_node.c
sys/vfs/isofs/cd9660/cd9660_rrip.c
sys/vfs/isofs/cd9660/cd9660_vfsops.c
sys/vfs/isofs/cd9660/cd9660_vnops.c
sys/vfs/isofs/cd9660/iso.h
sys/vfs/mfs/mfs_vfsops.c
sys/vfs/mfs/mfs_vnops.c
sys/vfs/msdosfs/msdosfs_denode.c
sys/vfs/msdosfs/msdosfs_fat.c
sys/vfs/msdosfs/msdosfs_lookup.c
sys/vfs/msdosfs/msdosfs_vfsops.c
sys/vfs/msdosfs/msdosfs_vnops.c
sys/vfs/msdosfs/msdosfsmount.h
sys/vfs/nfs/nfs_bio.c
sys/vfs/nfs/nfs_serv.c
sys/vfs/nfs/nfs_vnops.c
sys/vfs/ntfs/ntfs.h
sys/vfs/ntfs/ntfs_subr.c
sys/vfs/ntfs/ntfs_vfsops.c
sys/vfs/ntfs/ntfs_vnops.c
sys/vfs/nwfs/nwfs_io.c
sys/vfs/nwfs/nwfs_vnops.c
sys/vfs/procfs/procfs_vnops.c
sys/vfs/smbfs/smbfs_io.c
sys/vfs/smbfs/smbfs_vnops.c
sys/vfs/specfs/spec_vnops.c
sys/vfs/udf/udf.h
sys/vfs/udf/udf_vfsops.c
sys/vfs/udf/udf_vnops.c
sys/vfs/ufs/ffs_alloc.c
sys/vfs/ufs/ffs_balloc.c
sys/vfs/ufs/ffs_inode.c
sys/vfs/ufs/ffs_rawread.c
sys/vfs/ufs/ffs_softdep.c
sys/vfs/ufs/ffs_subr.c
sys/vfs/ufs/ffs_vfsops.c
sys/vfs/ufs/ffs_vnops.c
sys/vfs/ufs/fs.h
sys/vfs/ufs/ufs_bmap.c
sys/vfs/ufs/ufs_readwrite.c
sys/vfs/ufs/ufs_vnops.c
sys/vfs/union/union_vnops.c
sys/vm/swap_pager.c
sys/vm/vm_swap.c
sys/vm/vnode_pager.c

index 417e981..3e9f410 100644 (file)
@@ -1,5 +1,5 @@
 /* $FreeBSD: src/lib/libstand/ufs.c,v 1.5.6.1 2000/05/04 13:47:53 ps Exp $ */
-/* $DragonFly: src/lib/libstand/ufs.c,v 1.7 2005/12/11 02:27:26 swildner Exp $ */
+/* $DragonFly: src/lib/libstand/ufs.c,v 1.8 2006/03/24 18:35:22 dillon Exp $ */
 /*     $NetBSD: ufs.c,v 1.20 1998/03/01 07:15:39 ross Exp $    */
 
 /*-
@@ -424,7 +424,7 @@ ufs_open(const char *upath, struct open_file *f)
        fp->f_fs = fs;
        twiddle();
        rc = (f->f_dev->dv_strategy)(f->f_devdata, F_READ,
-               SBLOCK, SBSIZE, (char *)fs, &buf_size);
+               SBOFF / DEV_BSIZE, SBSIZE, (char *)fs, &buf_size);
        if (rc)
                goto out;
 
index fb1a9f3..0a89dfa 100644 (file)
@@ -36,7 +36,7 @@
  * @(#) Copyright (c) 1990, 1993 The Regents of the University of California.  All rights reserved.
  * @(#)clri.c  8.2 (Berkeley) 9/23/93
  * $FreeBSD: src/sbin/clri/clri.c,v 1.4 1999/08/28 00:12:32 peter Exp $
- * $DragonFly: src/sbin/clri/clri.c,v 1.6 2005/11/06 12:08:12 swildner Exp $
+ * $DragonFly: src/sbin/clri/clri.c,v 1.7 2006/03/24 18:35:25 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -78,7 +78,7 @@ main(int argc, char **argv)
        /* get the superblock. */
        if ((fd = open(fs, O_RDWR, 0)) < 0)
                err(1, "%s", fs);
-       if (lseek(fd, (off_t)(SBLOCK * DEV_BSIZE), SEEK_SET) < 0)
+       if (lseek(fd, (off_t)SBOFF, SEEK_SET) < 0)
                err(1, "%s", fs);
        if (read(fd, sblock, sizeof(sblock)) != sizeof(sblock))
                errx(1, "%s: can't read superblock", fs);
index 0a910d6..418081d 100644 (file)
@@ -25,7 +25,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/cam/scsi/scsi_cd.c,v 1.31.2.16 2003/10/21 22:26:11 thomas Exp $
- * $DragonFly: src/sys/bus/cam/scsi/scsi_cd.c,v 1.20 2006/02/17 19:17:42 dillon Exp $
+ * $DragonFly: src/sys/bus/cam/scsi/scsi_cd.c,v 1.21 2006/03/24 18:35:26 dillon Exp $
  */
 /*
  * Portions of this driver taken from the original FreeBSD cd driver.
@@ -1544,6 +1544,8 @@ cdstart(struct cam_periph *periph, union ccb *start_ccb)
 
                        devstat_start_transaction(&softc->device_stats);
 
+                       KKASSERT(bio->bio_offset % softc->params.blksize == 0);
+
                        scsi_read_write(&start_ccb->csio,
                                        /*retries*/4,
                                        /* cbfcnp */ cddone,
@@ -1553,7 +1555,8 @@ cdstart(struct cam_periph *periph, union ccb *start_ccb)
                                        /* read */bp->b_flags & B_READ,
                                        /* byte2 */ 0,
                                        /* minimum_cmd_size */ 10,
-                                       /* lba */ bio->bio_blkno,
+                                       /* lba */ 
+                                       bio->bio_offset / softc->params.blksize,
                                        bp->b_bcount / softc->params.blksize,
                                        /* data_ptr */ bp->b_data,
                                        /* dxfer_len */ bp->b_bcount,
index a6890f5..d215a54 100644 (file)
@@ -26,7 +26,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/cam/scsi/scsi_da.c,v 1.42.2.46 2003/10/21 22:18:19 thomas Exp $
- * $DragonFly: src/sys/bus/cam/scsi/scsi_da.c,v 1.27 2006/02/17 19:17:42 dillon Exp $
+ * $DragonFly: src/sys/bus/cam/scsi/scsi_da.c,v 1.28 2006/03/24 18:35:27 dillon Exp $
  */
 
 #ifdef _KERNEL
@@ -1392,6 +1392,9 @@ dastart(struct cam_periph *periph, union ccb *start_ccb)
                        } else {
                                tag_code = MSG_SIMPLE_Q_TAG;
                        }
+
+                       KKASSERT(bio->bio_offset % softc->params.secsize == 0);
+
                        scsi_read_write(&start_ccb->csio,
                                        /*retries*/da_retry_count,
                                        dadone,
@@ -1399,7 +1402,7 @@ dastart(struct cam_periph *periph, union ccb *start_ccb)
                                        bp->b_flags & B_READ,
                                        /*byte2*/0,
                                        softc->minimum_cmd_size,
-                                       bio->bio_blkno,
+                                       bio->bio_offset / softc->params.secsize,
                                        bp->b_bcount / softc->params.secsize,
                                        bp->b_data,
                                        bp->b_bcount,
index 8be0a79..6a48512 100644 (file)
@@ -25,7 +25,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/cam/scsi/scsi_pass.c,v 1.19 2000/01/17 06:27:37 mjacob Exp $
- * $DragonFly: src/sys/bus/cam/scsi/scsi_pass.c,v 1.14 2006/02/17 19:17:42 dillon Exp $
+ * $DragonFly: src/sys/bus/cam/scsi/scsi_pass.c,v 1.15 2006/03/24 18:35:27 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -480,7 +480,7 @@ passstrategy(dev_t dev, struct bio *bio)
         * Odd number of bytes or negative offset
         */
        /* valid request?  */
-       if (bio->bio_blkno < 0) {
+       if (bio->bio_offset < 0) {
                bp->b_error = EINVAL;
                goto bad;
         }
index b15a974..728d755 100644 (file)
@@ -1,5 +1,5 @@
 # $FreeBSD: src/share/mk/bsd.kern.mk,v 1.17.2.1 2001/08/01 16:56:56 obrien Exp $
-# $DragonFly: src/sys/conf/bsd.kern.mk,v 1.6 2005/07/23 07:33:15 dillon Exp $
+# $DragonFly: src/sys/conf/bsd.kern.mk,v 1.7 2006/03/24 18:35:28 dillon Exp $
 
 #
 # Warning flags for compiling the kernel and components of the kernel.
@@ -34,9 +34,14 @@ CWARNFLAGS?= -Wall -Wredundant-decls -Wnested-externs -Wstrict-prototypes \
 # use of code cache tag lines) and uses more stack (less efficient use of data
 # cache tag lines)
 #
+# Prohibit the use of FP registers in the kernel.  The user FP state is
+# only saved and restored under strictly managed conditions and mainline
+# kernel code cannot safely use the FP system.
+#
 .if ${MACHINE_ARCH} == "i386"
 CFLAGS+=       -mpreferred-stack-boundary=2
 CFLAGS+=       -fno-stack-protector
+CFLAGS+=       -mno-mmx -mno-3dnow -mno-sse -mno-sse2 -mno-sse3
 .endif
 
 #
index 2a59d8d..460e657 100644 (file)
@@ -7,7 +7,7 @@
  * ----------------------------------------------------------------------------
  *
  * $FreeBSD: src/sys/contrib/dev/fla/fla.c,v 1.16 1999/12/08 04:45:16 ken Exp $ 
- * $DragonFly: src/sys/contrib/dev/fla/Attic/fla.c,v 1.10 2006/02/17 19:17:52 dillon Exp $ 
+ * $DragonFly: src/sys/contrib/dev/fla/Attic/fla.c,v 1.11 2006/03/24 18:35:29 dillon Exp $ 
  *
  */
 
@@ -198,9 +198,9 @@ flastrategy(dev_t dev, struct bio *bio)
        enum doc2k_work what;
 
        if (fla_debug > 1) {
-               printf("flastrategy(%p) %s %lx, %d, %ld, %p)\n",
-                   bp, devtoname(dev), bp->b_flags, bio->bio_blkno
-                   bp->b_bcount / DEV_BSIZE, bp->b_data);
+               printf("flastrategy(%p) %s %lx, %lld, %ld, %p)\n",
+                   bp, devtoname(dev), bp->b_flags, bio->bio_offset
+                   bp->b_bcount, bp->b_data);
        }
 
        sc = dev->si_drv1;
@@ -236,15 +236,16 @@ flastrategy(dev_t dev, struct bio *bio)
 
                LEAVE();
 
-               error = doc2k_rwe(unit, what, bio->bio_blkno,
+               error = doc2k_rwe(unit, what,
+                                 (unsigned)(bio->bio_offset >> DEV_BSHIFT),
                                  bp->b_bcount / DEV_BSIZE, bp->b_data);
 
                ENTER();
 
                if (fla_debug > 1 || error) {
-                       printf("fla%d: %d = rwe(%p, %d, %d, %d, %ld, %p)\n",
-                           unit, error, bp, unit, what, bio->bio_blkno
-                           bp->b_bcount / DEV_BSIZE, bp->b_data);
+                       printf("fla%d: %d = rwe(%p, %d, %d, %lld, %ld, %p)\n",
+                           unit, error, bp, unit, what, bio->bio_offset
+                           bp->b_bcount, bp->b_data);
                }
                if (error) {
                        bp->b_error = EIO;
index 2a2e068..bd570fa 100644 (file)
@@ -35,7 +35,7 @@
  *
  *     from: @(#)param.h       5.8 (Berkeley) 6/28/91
  * $FreeBSD: src/sys/i386/include/param.h,v 1.54.2.8 2002/08/31 21:15:55 dillon Exp $
- * $DragonFly: src/sys/cpu/i386/include/param.h,v 1.8 2006/03/08 04:54:05 reed Exp $
+ * $DragonFly: src/sys/cpu/i386/include/param.h,v 1.9 2006/03/24 18:35:33 dillon Exp $
  */
 
 #ifndef _MACHINE_PARAM_H_
 #define PDRMASK                (NBPDR-1)
 
 #define DEV_BSHIFT     9               /* log2(DEV_BSIZE) */
-#define DEV_BSIZE      (1<<DEV_BSHIFT)
+#define DEV_BSIZE      (1 << DEV_BSHIFT)
+#define DEV_BMASK      (DEV_BSIZE - 1)
 
 #ifndef BLKDEV_IOSIZE
 #define BLKDEV_IOSIZE  PAGE_SIZE       /* default block device I/O size */
index 81a2348..3cbbf01 100644 (file)
@@ -26,7 +26,7 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/dev/ata/ata-disk.c,v 1.60.2.24 2003/01/30 07:19:59 sos Exp $
- * $DragonFly: src/sys/dev/disk/ata/ata-disk.c,v 1.26 2006/02/17 19:17:54 dillon Exp $
+ * $DragonFly: src/sys/dev/disk/ata/ata-disk.c,v 1.27 2006/03/24 18:35:30 dillon Exp $
  */
 
 #include "opt_ata.h"
@@ -422,10 +422,12 @@ ad_start(struct ata_device *atadev)
        return;
     }
 
+    KKASSERT((bio->bio_offset & DEV_BMASK) == 0);
+
     /* setup request */
     request->softc = adp;
     request->bio = bio;
-    request->blockaddr = bio->bio_blkno;
+    request->blockaddr = (u_int32_t)(bio->bio_offset >> DEV_BSHIFT);
     request->bytecount = bp->b_bcount;
     request->data = bp->b_data;
     request->tag = tag;
@@ -644,8 +646,7 @@ ad_interrupt(struct ad_request *request)
     if (adp->device->channel->status & ATA_S_CORR)
        diskerr(request->bio, dev,
                "soft error (ECC corrected)", LOG_PRINTF,
-               request->blockaddr + (request->donecount / DEV_BSIZE),
-               &adp->disk.d_label);
+               request->donecount, &adp->disk.d_label);
 
     /* did any real errors happen ? */
     if ((adp->device->channel->status & ATA_S_ERROR) ||
@@ -655,8 +656,7 @@ ad_interrupt(struct ad_request *request)
        diskerr(request->bio, dev,
                (adp->device->channel->error & ATA_E_ICRC) ?
                "UDMA ICRC error" : "hard error", LOG_PRINTF,
-               request->blockaddr + (request->donecount / DEV_BSIZE),
-               &adp->disk.d_label);
+               request->donecount, &adp->disk.d_label);
 
        /* if this is a UDMA CRC error, reinject request */
        if (request->flags & ADR_F_DMA_USED &&
index f305ef4..7e11554 100644 (file)
@@ -26,7 +26,7 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/dev/ata/ata-raid.c,v 1.3.2.19 2003/01/30 07:19:59 sos Exp $
- * $DragonFly: src/sys/dev/disk/ata/ata-raid.c,v 1.16 2006/03/10 20:31:37 dillon Exp $
+ * $DragonFly: src/sys/dev/disk/ata/ata-raid.c,v 1.17 2006/03/24 18:35:30 dillon Exp $
  */
 
 #include "opt_ata.h"
@@ -485,6 +485,8 @@ arstrategy(dev_t dev, struct bio *bio)
     struct buf *bp = bio->bio_buf;
     struct ar_softc *rdp = dev->si_drv1;
     int blkno, count, chunk, lba, lbs, tmplba;
+    int orig_blkno;
+    int buf1_blkno;
     int drv = 0, change = 0;
     caddr_t data;
 
@@ -495,9 +497,13 @@ arstrategy(dev_t dev, struct bio *bio)
        return;
     }
 
+    KKASSERT((bio->bio_offset & DEV_BMASK) == 0);
+
     bp->b_resid = bp->b_bcount;
-    blkno = bio->bio_blkno;
+    blkno = (int)(bio->bio_offset >> DEV_BSHIFT);
+    orig_blkno = blkno;
     data = bp->b_data;
+
     for (count = howmany(bp->b_bcount, DEV_BSIZE); count > 0; 
         count -= chunk, blkno += chunk, data += (chunk * DEV_BSIZE)) {
        struct ar_buf *buf1, *buf2;
@@ -546,15 +552,16 @@ arstrategy(dev_t dev, struct bio *bio)
        BUF_LOCKINIT(&buf1->bp);
        BUF_LOCK(&buf1->bp, LK_EXCLUSIVE);
        initbufbio(&buf1->bp);
-       buf1->bp.b_bio1.bio_blkno = lba;
+       buf1->bp.b_bio1.bio_offset = (off_t)lba << DEV_BSHIFT;
        if ((buf1->drive = drv) > 0)
-           buf1->bp.b_bio1.bio_blkno += rdp->offset;
+           buf1->bp.b_bio1.bio_offset += (off_t)rdp->offset << DEV_BSHIFT;
        buf1->bp.b_bio1.bio_caller_info1.ptr = (void *)rdp;
        buf1->bp.b_bcount = chunk * DEV_BSIZE;
        buf1->bp.b_data = data;
        buf1->bp.b_flags = bp->b_flags;
        buf1->bp.b_bio1.bio_done = ar_done;
        buf1->org = bio;
+       buf1_blkno = (int)(buf1->bp.b_bio1.bio_offset >> DEV_BSHIFT);
 
        switch (rdp->flags & (AR_F_RAID0 | AR_F_RAID1 | AR_F_SPAN)) {
        case AR_F_SPAN:
@@ -577,10 +584,10 @@ arstrategy(dev_t dev, struct bio *bio)
        case AR_F_RAID1:
        case AR_F_RAID0 | AR_F_RAID1:
            if ((rdp->flags & AR_F_REBUILDING) && !(bp->b_flags & B_READ)) {
-               if ((bio->bio_blkno >= rdp->lock_start &&
-                    bio->bio_blkno < rdp->lock_end) ||
-                   ((bio->bio_blkno + chunk) > rdp->lock_start &&
-                    (bio->bio_blkno + chunk) <= rdp->lock_end)) {
+               if ((orig_blkno >= rdp->lock_start &&
+                    orig_blkno < rdp->lock_end) ||
+                   ((orig_blkno + chunk) > rdp->lock_start &&
+                    (orig_blkno + chunk) <= rdp->lock_end)) {
                    tsleep(rdp, 0, "arwait", 0);
                }
            }
@@ -607,36 +614,34 @@ arstrategy(dev_t dev, struct bio *bio)
                return;
            }
            if (bp->b_flags & B_READ) {
-               if ((buf1->bp.b_bio1.bio_blkno <
+               if ((buf1_blkno <
                     (rdp->disks[buf1->drive].last_lba - AR_PROXIMITY) ||
-                    buf1->bp.b_bio1.bio_blkno >
+                    buf1_blkno >
                     (rdp->disks[buf1->drive].last_lba + AR_PROXIMITY) ||
                     !(rdp->disks[buf1->drive].flags & AR_DF_ONLINE)) &&
                     (rdp->disks[buf1->drive+rdp->width].flags & AR_DF_ONLINE))
                        buf1->drive = buf1->drive + rdp->width;
-           }
-           else {
+           } else {
                if ((rdp->disks[buf1->drive+rdp->width].flags & AR_DF_ONLINE) ||
                    ((rdp->flags & AR_F_REBUILDING) &&
                     (rdp->disks[buf1->drive+rdp->width].flags & AR_DF_SPARE) &&
-                    buf1->bp.b_bio1.bio_blkno < rdp->lock_start)) {
+                    buf1_blkno < rdp->lock_start)) {
                    if ((rdp->disks[buf1->drive].flags & AR_DF_ONLINE) ||
                        ((rdp->flags & AR_F_REBUILDING) &&
                         (rdp->disks[buf1->drive].flags & AR_DF_SPARE) &&
-                        buf1->bp.b_bio1.bio_blkno < rdp->lock_start)) {
+                        buf1_blkno < rdp->lock_start)) {
                        buf2 = malloc(sizeof(struct ar_buf), M_AR, M_INTWAIT);
                        bcopy(buf1, buf2, sizeof(struct ar_buf));
                        BUF_LOCKINIT(&buf2->bp);
                        BUF_LOCK(&buf2->bp, LK_EXCLUSIVE);
                        initbufbio(&buf2->bp);
-                       buf2->bp.b_bio1.bio_blkno = buf1->bp.b_bio1.bio_blkno;
+                       buf2->bp.b_bio1.bio_offset = buf1->bp.b_bio1.bio_offset;
                        buf1->mirror = buf2;
                        buf2->mirror = buf1;
                        buf2->drive = buf1->drive + rdp->width;
                        dev_dstrategy(AD_SOFTC(rdp->disks[buf2->drive])->dev,
                                      &buf2->bp.b_bio1);
-                       rdp->disks[buf2->drive].last_lba =
-                           buf2->bp.b_bio1.bio_blkno + chunk;
+                       rdp->disks[buf2->drive].last_lba = buf1_blkno + chunk;
                    }
                    else
                        buf1->drive = buf1->drive + rdp->width;
@@ -644,7 +649,7 @@ arstrategy(dev_t dev, struct bio *bio)
            }
            dev_dstrategy(AD_SOFTC(rdp->disks[buf1->drive])->dev,
                          &buf1->bp.b_bio1);
-           rdp->disks[buf1->drive].last_lba = buf1->bp.b_bio1.bio_blkno + chunk;
+           rdp->disks[buf1->drive].last_lba = buf1_blkno + chunk;
            break;
 
        default:
@@ -1390,7 +1395,7 @@ ar_rw(struct ad_softc *adp, u_int32_t lba, int count, caddr_t data, int flags)
     BUF_LOCK(bp, LK_EXCLUSIVE);
     initbufbio(bp);
     bp->b_data = data;
-    bp->b_bio1.bio_blkno = lba;
+    bp->b_bio1.bio_offset = (off_t)lba << DEV_BSHIFT;
     bp->b_bcount = count;
     if (flags & AR_WAIT)
        bp->b_bio1.bio_done = (void *)wakeup;
index 40fa8a7..5f030f2 100644 (file)
@@ -26,7 +26,7 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/dev/ata/atapi-cd.c,v 1.48.2.20 2002/11/25 05:30:31 njl Exp $
- * $DragonFly: src/sys/dev/disk/ata/atapi-cd.c,v 1.20 2006/02/17 19:17:54 dillon Exp $
+ * $DragonFly: src/sys/dev/disk/ata/atapi-cd.c,v 1.21 2006/03/24 18:35:30 dillon Exp $
  */
 
 #include "opt_ata.h"
@@ -1104,7 +1104,7 @@ acdstrategy(dev_t dev, struct bio *bio)
        return;
     }
 
-    KKASSERT(bio->bio_blkno != (daddr_t)-1);
+    KKASSERT(bio->bio_offset != NOOFFSET);
     bio->bio_driver_info = dev;
     bp->b_resid = bp->b_bcount;
 
@@ -1164,19 +1164,13 @@ acd_start(struct ata_device *atadev)
     if (track) {
        blocksize = (cdp->toc.tab[track - 1].control & 4) ? 2048 : 2352;
        lastlba = ntohl(cdp->toc.tab[track].addr.lba);
-       if (bp->b_flags & B_PHYS)
-           lba = bio->bio_offset / blocksize;
-       else
-           lba = bio->bio_blkno / (blocksize / DEV_BSIZE);
+       lba = bio->bio_offset / blocksize;
        lba += ntohl(cdp->toc.tab[track - 1].addr.lba);
     }
     else {
        blocksize = cdp->block_size;
        lastlba = cdp->disk_size;
-       if (bp->b_flags & B_PHYS)
-           lba = bio->bio_offset / blocksize;
-       else
-           lba = bio->bio_blkno / (blocksize / DEV_BSIZE);
+       lba = bio->bio_offset / blocksize;
     }
 
     if (bp->b_bcount % blocksize != 0) {
index 7ba44a7..6b48f40 100644 (file)
@@ -26,7 +26,7 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/dev/ata/atapi-fd.c,v 1.44.2.9 2002/07/31 11:19:26 sos Exp $
- * $DragonFly: src/sys/dev/disk/ata/atapi-fd.c,v 1.13 2006/02/17 19:17:54 dillon Exp $
+ * $DragonFly: src/sys/dev/disk/ata/atapi-fd.c,v 1.14 2006/03/24 18:35:30 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -344,7 +344,9 @@ afd_start(struct ata_device *atadev)
        return;
     }
 
-    lba = bio->bio_blkno;
+    KKASSERT(bio->bio_offset % fdp->cap.sector_size == 0);
+
+    lba = bio->bio_offset / fdp->cap.sector_size;
     count = bp->b_bcount / fdp->cap.sector_size;
     data_ptr = bp->b_data;
     bp->b_resid = bp->b_bcount; 
index 8764c43..cece6f6 100644 (file)
@@ -26,7 +26,7 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/dev/ata/atapi-tape.c,v 1.36.2.12 2002/07/31 11:19:26 sos Exp $
- * $DragonFly: src/sys/dev/disk/ata/atapi-tape.c,v 1.13 2006/02/17 19:17:54 dillon Exp $
+ * $DragonFly: src/sys/dev/disk/ata/atapi-tape.c,v 1.14 2006/03/24 18:35:30 dillon Exp $
  */
 
 #include "opt_ata.h"
@@ -457,7 +457,7 @@ aststrategy(dev_t dev, struct bio *bio)
     /* warn about transfers bigger than the device suggests */
     if (bp->b_bcount > stp->blksize * stp->cap.ctl) {   
        if ((stp->flags & F_CTL_WARN) == 0) {
-           ata_prtdev(stp->device, "WARNING: CTL exceeded %ld>%d\n",
+           ata_prtdev(stp->device, "WARNING: CTL exceeded %d > %d\n",
                       bp->b_bcount, stp->blksize * stp->cap.ctl);
            stp->flags |= F_CTL_WARN;
        }
index 2920b47..d82e039 100644 (file)
@@ -1,5 +1,5 @@
 /* $FreeBSD: src/sys/dev/ccd/ccd.c,v 1.73.2.1 2001/09/11 09:49:52 kris Exp $ */
-/* $DragonFly: src/sys/dev/disk/ccd/ccd.c,v 1.23 2006/03/08 17:14:11 dillon Exp $ */
+/* $DragonFly: src/sys/dev/disk/ccd/ccd.c,v 1.24 2006/03/24 18:35:32 dillon Exp $ */
 
 /*     $NetBSD: ccd.c,v 1.22 1995/12/08 19:13:26 thorpej Exp $ */
 
@@ -206,7 +206,7 @@ static      void ccdintr (struct ccd_softc *, struct bio *);
 static int ccdinit (struct ccddevice *, char **, struct thread *);
 static int ccdlookup (char *, struct thread *td, struct vnode **);
 static void ccdbuffer (struct ccdbuf **ret, struct ccd_softc *,
-               struct bio *, daddr_t, caddr_t, long);
+               struct bio *, off_t, caddr_t, long);
 static void ccdgetdisklabel (dev_t);
 static void ccdmakedisklabel (struct ccd_softc *);
 static int ccdlock (struct ccd_softc *);
@@ -781,7 +781,7 @@ ccdstrategy(dev_t dev, struct bio *bio)
                int pbn;        /* in sc_secsize chunks */
                long sz;        /* in sc_secsize chunks */
 
-               pbn = bio->bio_blkno / (cs->sc_geom.ccg_secsize / DEV_BSIZE);
+               pbn = (int)(bio->bio_offset / cs->sc_geom.ccg_secsize);
                sz = howmany(bp->b_bcount, cs->sc_geom.ccg_secsize);
 
                /*
@@ -835,7 +835,7 @@ ccdstart(struct ccd_softc *cs, struct bio *bio)
        dev_t dev = bio->bio_driver_info;
        /* XXX! : 2 reads and 2 writes for RAID 4/5 */
        caddr_t addr;
-       daddr_t bn;
+       off_t doffset;
        struct partition *pp;
 
 #ifdef DEBUG
@@ -849,10 +849,10 @@ ccdstart(struct ccd_softc *cs, struct bio *bio)
        /*
         * Translate the partition-relative block number to an absolute.
         */
-       bn = bio->bio_blkno;
+       doffset = bio->bio_offset;
        if (ccdpart(dev) != RAW_PART) {
                pp = &cs->sc_label.d_partitions[ccdpart(dev)];
-               bn += pp->p_offset;
+               doffset += pp->p_offset * cs->sc_label.d_secsize;
        }
 
        /*
@@ -860,7 +860,7 @@ ccdstart(struct ccd_softc *cs, struct bio *bio)
         */
        addr = bp->b_data;
        for (bcount = bp->b_bcount; bcount > 0; bcount -= rcount) {
-               ccdbuffer(cbp, cs, bio, bn, addr, bcount);
+               ccdbuffer(cbp, cs, bio, doffset, addr, bcount);
                rcount = cbp[0]->cb_buf.b_bcount;
 
                if (cs->sc_cflags & CCDF_MIRROR) {
@@ -880,14 +880,14 @@ ccdstart(struct ccd_softc *cs, struct bio *bio)
                                    &cbp[1]->cb_buf.b_bio1);
                        } else {
                                int pick = cs->sc_pick;
-                               daddr_t range = cs->sc_size / 16;
+                               daddr_t range = cs->sc_size / 16 * cs->sc_label.d_secsize;
 
-                               if (bn < cs->sc_blk[pick] - range ||
-                                   bn > cs->sc_blk[pick] + range
+                               if (doffset < cs->sc_blk[pick] - range ||
+                                   doffset > cs->sc_blk[pick] + range
                                ) {
                                        cs->sc_pick = pick = 1 - pick;
                                }
-                               cs->sc_blk[pick] = bn + btodb(rcount);
+                               cs->sc_blk[pick] = doffset + rcount;
                                vn_strategy(cbp[pick]->cb_buf.b_vp, 
                                    &cbp[pick]->cb_buf.b_bio1);
                        }
@@ -898,7 +898,7 @@ ccdstart(struct ccd_softc *cs, struct bio *bio)
                        vn_strategy(cbp[0]->cb_buf.b_vp,
                                     &cbp[0]->cb_buf.b_bio1);
                }
-               bn += btodb(rcount);
+               doffset += rcount;
                addr += rcount;
        }
 }
@@ -907,12 +907,12 @@ ccdstart(struct ccd_softc *cs, struct bio *bio)
  * Build a component buffer header.
  */
 static void
-ccdbuffer(struct ccdbuf **cb, struct ccd_softc *cs, struct bio *bio, daddr_t bn,
-         caddr_t addr, long bcount)
+ccdbuffer(struct ccdbuf **cb, struct ccd_softc *cs, struct bio *bio,
+         off_t doffset, caddr_t addr, long bcount)
 {
        struct ccdcinfo *ci, *ci2 = NULL;       /* XXX */
        struct ccdbuf *cbp;
-       daddr_t cbn, cboff;
+       daddr_t bn, cbn, cboff;
        off_t cbc;
 
 #ifdef DEBUG
@@ -923,6 +923,7 @@ ccdbuffer(struct ccdbuf **cb, struct ccd_softc *cs, struct bio *bio, daddr_t bn,
        /*
         * Determine which component bn falls in.
         */
+       bn = (daddr_t)(doffset / cs->sc_geom.ccg_secsize);
        cbn = bn;
        cboff = 0;
 
@@ -1040,7 +1041,6 @@ ccdbuffer(struct ccdbuf **cb, struct ccd_softc *cs, struct bio *bio, daddr_t bn,
 
        cbp->cb_buf.b_bio1.bio_done = ccdiodone;
        cbp->cb_buf.b_bio1.bio_caller_info1.ptr = cbp;
-       cbp->cb_buf.b_bio1.bio_blkno = cbn + cboff + CCD_OFFSET;
        cbp->cb_buf.b_bio1.bio_offset = dbtob(cbn + cboff + CCD_OFFSET);
 
        /*
@@ -1052,9 +1052,9 @@ ccdbuffer(struct ccdbuf **cb, struct ccd_softc *cs, struct bio *bio, daddr_t bn,
 
 #ifdef DEBUG
        if (ccddebug & CCDB_IO)
-               printf(" dev %x(u%d): cbp %x bn %d addr %x bcnt %d\n",
+               printf(" dev %x(u%d): cbp %x off %lld addr %x bcnt %d\n",
                       ci->ci_dev, ci-cs->sc_cinfo, cbp,
-                      cbp->cb_buf.b_bio1.bio_blkno,
+                      cbp->cb_buf.b_bio1.bio_offset,
                       cbp->cb_buf.b_data, cbp->cb_buf.b_bcount);
 #endif
        cb[0] = cbp;
@@ -1079,7 +1079,6 @@ ccdbuffer(struct ccdbuf **cb, struct ccd_softc *cs, struct bio *bio, daddr_t bn,
 
                cbp->cb_buf.b_bio1.bio_done = ccdiodone;
                cbp->cb_buf.b_bio1.bio_caller_info1.ptr = cbp;
-               cbp->cb_buf.b_bio1.bio_blkno = cbn + cboff + CCD_OFFSET;
                cbp->cb_buf.b_bio1.bio_offset = dbtob(cbn + cboff + CCD_OFFSET);
 
                /*
@@ -1142,9 +1141,9 @@ ccdiodone(struct bio *bio)
        if (ccddebug & CCDB_IO) {
                printf("ccdiodone: bp %x bcount %d resid %d\n",
                       obp, obp->b_bcount, obp->b_resid);
-               printf(" dev %x(u%d), cbp %x bn %d addr %x bcnt %d\n",
+               printf(" dev %x(u%d), cbp %x off %lld addr %x bcnt %d\n",
                       cbp->cb_buf.b_dev, cbp->cb_comp, cbp,
-                      cbp->cb_buf.b_lblkno, cbp->cb_buf.b_data,
+                      cbp->cb_buf.b_loffset, cbp->cb_buf.b_data,
                       cbp->cb_buf.b_bcount);
        }
 #endif
@@ -1170,16 +1169,16 @@ ccdiodone(struct bio *bio)
 
                        msg = ", trying other disk";
                        cs->sc_pick = 1 - cs->sc_pick;
-                       cs->sc_blk[cs->sc_pick] = obio->bio_blkno;
+                       cs->sc_blk[cs->sc_pick] = obio->bio_offset;
                } else {
                        obp->b_flags |= B_ERROR;
                        obp->b_error = cbp->cb_buf.b_error ? 
                            cbp->cb_buf.b_error : EIO;
                }
-               printf("ccd%d: error %d on component %d block %d (ccd block %d)%s\n",
+               printf("ccd%d: error %d on component %d offset %lld (ccd offset %lld)%s\n",
                       unit, obp->b_error, cbp->cb_comp, 
-                      (int)cbp->cb_buf.b_bio2.bio_blkno
-                      obio->bio_blkno, msg);
+                      cbp->cb_buf.b_bio2.bio_offset
+                      obio->bio_offset, msg);
        }
 
        /*
index 8ce8ffe..59d076a 100644 (file)
@@ -51,7 +51,7 @@
  *
  *     from:   @(#)fd.c        7.4 (Berkeley) 5/25/91
  * $FreeBSD: src/sys/isa/fd.c,v 1.176.2.8 2002/05/15 21:56:14 joerg Exp $
- * $DragonFly: src/sys/dev/disk/fd/fd.c,v 1.25 2006/02/17 19:17:57 dillon Exp $
+ * $DragonFly: src/sys/dev/disk/fd/fd.c,v 1.26 2006/03/24 18:35:32 dillon Exp $
  *
  */
 
@@ -1404,10 +1404,10 @@ fdstrategy(dev_t dev, struct bio *bio)
 
        fdblk = 128 << (fd->ft->secsize);
        if (!(bp->b_flags & B_FORMAT)) {
-               if (bio->bio_blkno < 0) {
+               if (bio->bio_offset < 0) {
                        printf(
-               "fd%d: fdstrat: bad request blkno = %lu, bcount = %ld\n",
-                              fdu, (u_long)bio->bio_blkno, bp->b_bcount);
+               "fd%d: fdstrat: bad request offset = %lld, bcount = %d\n",
+                              fdu, bio->bio_offset, bp->b_bcount);
                        bp->b_error = EINVAL;
                        bp->b_flags |= B_ERROR;
                        goto bad;
@@ -1422,7 +1422,7 @@ fdstrategy(dev_t dev, struct bio *bio)
        /*
         * Set up block calculations.
         */
-       if (bio->bio_blkno > 20000000) {
+       if (bio->bio_offset > 20000000LL * fdblk) {
                /*
                 * Reject unreasonably high block number, prevent the
                 * multiplication below from overflowing.
@@ -1431,7 +1431,7 @@ fdstrategy(dev_t dev, struct bio *bio)
                bp->b_flags |= B_ERROR;
                goto bad;
        }
-       blknum = (unsigned) bio->bio_blkno * DEV_BSIZE/fdblk;
+       blknum = (unsigned)(bio->bio_offset / fdblk);
        nblocks = fd->ft->size;
        bp->b_resid = 0;
        if (blknum + (bp->b_bcount / fdblk) > nblocks) {
@@ -1621,8 +1621,8 @@ fdstate(fdc_p fdc)
                        - (char *)finfo;
        }
        if (fdc->state == DOSEEK || fdc->state == SEEKCOMPLETE) {
-               blknum = (unsigned) bio->bio_blkno * DEV_BSIZE/fdblk +
-                       fd->skip/fdblk;
+               blknum = (unsigned)(bio->bio_offset / fdblk) +
+                        fd->skip  /fdblk;
                b_cylinder = blknum / (fd->ft->sectrac * fd->ft->heads);
        }
        TRACE1("fd%d", fdu);
@@ -2121,8 +2121,7 @@ retrier(struct fdc_data *fdc)
                                    (FDUNIT(minor(dev))<<3)|RAW_PART);
                                diskerr(bio, subdev,
                                        "hard error", LOG_PRINTF,
-                                       fdc->fd->skip / DEV_BSIZE,
-                                       (struct disklabel *)NULL);
+                                       fdc->fd->skip, NULL);
                        }
                        if (printerror) {
                                if (fdc->flags & FDC_STAT_VALID)
@@ -2181,8 +2180,9 @@ fdformat(dev_t dev, struct fd_formb *finfo, struct thread *td)
         * calculate a fake blkno, so fdstrategy() would initiate a
         * seek to the requested cylinder
         */
-       bp->b_bio1.bio_blkno = (finfo->cyl * (fd->ft->sectrac * fd->ft->heads)
-               + finfo->head * fd->ft->sectrac) * fdblk / DEV_BSIZE;
+       bp->b_bio1.bio_offset = (off_t)(finfo->cyl * 
+               (fd->ft->sectrac * fd->ft->heads)
+               + finfo->head * fd->ft->sectrac) * fdblk;
        bp->b_bio1.bio_driver_info = dev;
 
        bp->b_bcount = sizeof(struct fd_idfield_data) * finfo->fd_formb_nsecs;
index 3b93a24..5ad6272 100644 (file)
@@ -41,7 +41,7 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/i386/isa/mcd.c,v 1.115 2000/01/29 16:17:34 peter Exp $
- * $DragonFly: src/sys/dev/disk/mcd/Attic/mcd.c,v 1.15 2006/02/17 19:17:59 dillon Exp $
+ * $DragonFly: src/sys/dev/disk/mcd/Attic/mcd.c,v 1.16 2006/03/24 18:35:32 dillon Exp $
  */
 static const char COPYRIGHT[] = "mcd-driver (C)1993 by H.Veit & B.Moore";
 
@@ -400,11 +400,11 @@ mcdstrategy(dev_t dev, struct bio *bio)
        bio->bio_driver_info = dev;
 
        /* test validity */
-/*MCD_TRACE("strategy: buf=0x%lx, unit=%ld, block#=%ld bcount=%ld\n",
-       bp,unit,bio->bio_blkno,bp->b_bcount);*/
-       if (unit >= NMCD || bio->bio_blkno < 0) {
-               printf("mcdstrategy: unit = %d, blkno = %ld, bcount = %ld\n",
-                       unit, (long)bio->bio_blkno, bp->b_bcount);
+/*MCD_TRACE("strategy: buf=0x%lx, unit=%ld, offset=%lld bcount=%ld\n",
+       bp,unit,bio->bio_offset,bp->b_bcount);*/
+       if (unit >= NMCD || bio->bio_offset < 0) {
+               printf("mcdstrategy: unit = %d, offset = %lld, bcount = %ld\n",
+                       unit, bio->bio_offset, bp->b_bcount);
                printf("mcd: mcdstratregy failure");
                bp->b_error = EINVAL;
                bp->b_flags |= B_ERROR;
@@ -1099,8 +1099,8 @@ modedone:
                mbx->skip = 0;
 
 nextblock:
-               blknum  = (bio->bio_blkno / (mbx->sz/DEV_BSIZE))
-                       + mbx->p_offset + mbx->skip/mbx->sz;
+               blknum  = (bio->bio_offset / mbx->sz)
+                         + mbx->p_offset + mbx->skip/mbx->sz;
 
                MCD_TRACE("mcd_doread: read blknum=%d for bp=%p\n",
                        blknum, bp);
index 64a938e..b7d35a6 100644 (file)
@@ -7,7 +7,7 @@
  * ----------------------------------------------------------------------------
  *
  * $FreeBSD: src/sys/dev/md/md.c,v 1.8.2.2 2002/08/19 17:43:34 jdp Exp $
- * $DragonFly: src/sys/dev/disk/md/md.c,v 1.9 2006/02/17 19:18:00 dillon Exp $
+ * $DragonFly: src/sys/dev/disk/md/md.c,v 1.10 2006/03/24 18:35:32 dillon Exp $
  *
  */
 
@@ -149,9 +149,9 @@ mdstrategy(dev_t dev, struct bio *bio)
        struct md_s *sc;
 
        if (md_debug > 1) {
-               printf("mdstrategy(%p) %s %lx, %d, %ld, %p)\n",
-                   bp, devtoname(dev), bp->b_flags, bio->bio_blkno
-                   bp->b_bcount / DEV_BSIZE, bp->b_data);
+               printf("mdstrategy(%p) %s %08x, %lld, %d, %p)\n",
+                   bp, devtoname(dev), bp->b_flags, bio->bio_offset
+                   bp->b_bcount, bp->b_data);
        }
        bio->bio_driver_info = dev;
        sc = dev->si_drv1;
@@ -174,9 +174,9 @@ mdstrategy_malloc(dev_t dev, struct bio *bio)
        int i;
 
        if (md_debug > 1)
-               printf("mdstrategy_malloc(%p) %s %lx, %d, %ld, %p)\n",
-                   bp, devtoname(dev), bp->b_flags, bio->bio_blkno
-                   bp->b_bcount / DEV_BSIZE, bp->b_data);
+               printf("mdstrategy_malloc(%p) %s %08xx, %lld, %d, %p)\n",
+                   bp, devtoname(dev), bp->b_flags, bio->bio_offset
+                   bp->b_bcount, bp->b_data);
 
        sc = dev->si_drv1;
 
@@ -208,8 +208,8 @@ mdstrategy_malloc(dev_t dev, struct bio *bio)
                else
                        dop = DEVSTAT_WRITE;
 
-               nsec = bp->b_bcount / DEV_BSIZE;
-               secno = bio->bio_blkno;
+               nsec = bp->b_bcount >> DEV_BSHIFT;
+               secno = (unsigned)(bio->bio_offset >> DEV_BSHIFT);
                dst = bp->b_data;
                while (nsec--) {
                        if (secno < sc->nsecp) {
@@ -227,7 +227,7 @@ mdstrategy_malloc(dev_t dev, struct bio *bio)
                                secval = 0;
                        }
                        if (md_debug > 2)
-                               printf("%lx %p %p %d\n", bp->b_flags, secpp, secp, secval);
+                               printf("%08x %p %p %d\n", bp->b_flags, secpp, secp, secval);
 
                        if (bp->b_flags & B_FREEBUF) {
                                if (secpp) {
@@ -297,9 +297,9 @@ mdstrategy_preload(dev_t dev, struct bio *bio)
        struct md_s *sc;
 
        if (md_debug > 1)
-               printf("mdstrategy_preload(%p) %s %lx, %d, %ld, %p)\n",
-                   bp, devtoname(dev), bp->b_flags, bio->bio_blkno
-                   bp->b_bcount / DEV_BSIZE, bp->b_data);
+               printf("mdstrategy_preload(%p) %s %08x, %lld, %d, %p)\n",
+                   bp, devtoname(dev), bp->b_flags, bio->bio_offset
+                   bp->b_bcount, bp->b_data);
 
        sc = dev->si_drv1;
 
@@ -328,10 +328,12 @@ mdstrategy_preload(dev_t dev, struct bio *bio)
                        dop = DEVSTAT_NO_DATA;
                } else if (bp->b_flags & B_READ) {
                        dop = DEVSTAT_READ;
-                       bcopy(sc->pl_ptr + (bio->bio_blkno << DEV_BSHIFT), bp->b_data, bp->b_bcount);
+                       bcopy(sc->pl_ptr + bio->bio_offset, 
+                              bp->b_data, bp->b_bcount);
                } else {
                        dop = DEVSTAT_WRITE;
-                       bcopy(bp->b_data, sc->pl_ptr + (bio->bio_blkno << DEV_BSHIFT), bp->b_bcount);
+                       bcopy(bp->b_data, sc->pl_ptr + bio->bio_offset,
+                             bp->b_bcount);
                }
                bp->b_resid = 0;
                devstat_end_transaction_buf(&sc->stats, bp);
index c2920df..9f8472c 100644 (file)
@@ -42,7 +42,7 @@
 
 
 /* $FreeBSD: src/sys/i386/isa/scd.c,v 1.54 2000/01/29 16:00:30 peter Exp $ */
-/* $DragonFly: src/sys/dev/disk/scd/Attic/scd.c,v 1.14 2006/02/17 19:18:01 dillon Exp $ */
+/* $DragonFly: src/sys/dev/disk/scd/Attic/scd.c,v 1.15 2006/03/24 18:35:32 dillon Exp $ */
 
 /* Please send any comments to micke@dynas.se */
 
@@ -324,12 +324,12 @@ scdstrategy(dev_t dev, struct bio *bio)
 
        cd = scd_data + unit;
 
-       XDEBUG(2, ("scd%d: DEBUG: strategy: block=%ld, bcount=%ld\n",
-               unit, (long)bio->bio_blkno, bp->b_bcount));
+       XDEBUG(2, ("scd%d: DEBUG: strategy: offset=%lld, bcount=%ld\n",
+               unit, bio->bio_offset, bp->b_bcount));
 
-       if (unit >= NSCD || bio->bio_blkno < 0 || (bp->b_bcount % SCDBLKSIZE)) {
-               printf("scd%d: strategy failure: blkno = %ld, bcount = %ld\n",
-                       unit, (long)bio->bio_blkno, bp->b_bcount);
+       if (unit >= NSCD || bio->bio_offset < 0 || (bp->b_bcount % SCDBLKSIZE)) {
+               printf("scd%d: strategy failure: offset = %lld, bcount = %ld\n",
+                       unit, bio->bio_offset, bp->b_bcount);
                bp->b_error = EINVAL;
                bp->b_flags |= B_ERROR;
                goto bad;
@@ -847,8 +847,8 @@ nextblock:
                if (!(cd->flags & SCDVALID))
                        goto changed;
 
-               blknum  = (bio->bio_blkno / (mbx->sz/DEV_BSIZE))
-                       + mbx->p_offset + mbx->skip/mbx->sz;
+               blknum  = (bio->bio_offset / mbx->sz) +
+                         mbx->p_offset + mbx->skip/mbx->sz;
 
                XDEBUG(2, ("scd%d: scd_doread: read blknum=%d\n", unit, blknum));
 
index 7a55443..cee04a7 100644 (file)
@@ -39,7 +39,7 @@
  *
  *     from: @(#)vn.c  8.6 (Berkeley) 4/1/94
  * $FreeBSD: src/sys/dev/vn/vn.c,v 1.105.2.4 2001/11/18 07:11:00 dillon Exp $
- * $DragonFly: src/sys/dev/disk/vn/vn.c,v 1.16 2006/02/17 19:18:02 dillon Exp $
+ * $DragonFly: src/sys/dev/disk/vn/vn.c,v 1.17 2006/03/24 18:35:32 dillon Exp $
  */
 
 /*
  * Block/character interface to a vnode.  Allows one to treat a file
  * as a disk (e.g. build a filesystem in it, mount it, etc.).
  *
- * NOTE 1: This uses the VOP_BMAP/VOP_STRATEGY interface to the vnode
- * instead of a simple VOP_RDWR.  We do this to avoid distorting the
- * local buffer cache.
- *
- * NOTE 2: There is a security issue involved with this driver.
+ * NOTE 1: There is a security issue involved with this driver.
  * Once mounted all access to the contents of the "mapped" file via
  * the special file is controlled by the permissions on the special
  * file, the protection of the mapped file is ignored (effectively,
  * by using root credentials in all transactions).
  *
- * NOTE 3: Doesn't interact with leases, should it?
+ * NOTE 2: Doesn't interact with leases, should it?
  */
 
 #include <sys/param.h>
@@ -75,7 +71,6 @@
 #include <sys/disklabel.h>
 #include <sys/diskslice.h>
 #include <sys/stat.h>
-#include <sys/conf.h>
 #include <sys/module.h>
 #include <sys/vnioctl.h>
 
@@ -278,9 +273,6 @@ vnopen(dev_t dev, int flags, int mode, struct thread *td)
  *     vm_object-backed vn's.
  *
  *     Currently B_ASYNC is only partially handled - for OBJT_SWAP I/O only.
- *
- *     NOTE: bio->bio_blkno is DEV_BSIZE'd.  We must generate a new bio
- *     with a secsize'd blkno.
  */
 
 static void
@@ -334,14 +326,14 @@ vnstrategy(dev_t dev, struct bio *bio)
                 * multiple of the sector size.
                 */
                if (bp->b_bcount % vn->sc_secsize != 0 ||
-                   bio->bio_blkno % (vn->sc_secsize / DEV_BSIZE) != 0) {
+                   bio->bio_offset % vn->sc_secsize != 0) {
                        bp->b_error = EINVAL;
                        bp->b_flags |= B_ERROR | B_INVAL;
                        biodone(bio);
                        return;
                }
 
-               pbn = bio->bio_blkno / (vn->sc_secsize / DEV_BSIZE);
+               pbn = bio->bio_offset / vn->sc_secsize;
                sz = howmany(bp->b_bcount, vn->sc_secsize);
 
                /*
@@ -365,7 +357,7 @@ vnstrategy(dev_t dev, struct bio *bio)
                        bp->b_resid = bp->b_bcount;
                }
                nbio = push_bio(bio);
-               nbio->bio_blkno = pbn;
+               nbio->bio_offset = pbn * vn->sc_secsize;
        }
 
        /*
@@ -393,7 +385,7 @@ vnstrategy(dev_t dev, struct bio *bio)
                aiov.iov_len = bp->b_bcount;
                auio.uio_iov = &aiov;
                auio.uio_iovcnt = 1;
-               auio.uio_offset = (vm_ooffset_t)nbio->bio_blkno * vn->sc_secsize;
+               auio.uio_offset = nbio->bio_offset;
                auio.uio_segflg = UIO_SYSSPACE;
                if (bp->b_flags & B_READ)
                        auio.uio_rw = UIO_READ;
index f1eb7d7..63c932f 100644 (file)
@@ -27,7 +27,7 @@
  * SUCH DAMAGE.
  *
  *     $FreeBSD: src/sys/dev/aac/aac.c,v 1.9.2.14 2003/04/08 13:22:08 scottl Exp $
- *     $DragonFly: src/sys/dev/raid/aac/aac.c,v 1.20 2006/02/17 19:18:05 dillon Exp $
+ *     $DragonFly: src/sys/dev/raid/aac/aac.c,v 1.21 2006/03/24 18:35:32 dillon Exp $
  */
 
 /*
@@ -943,7 +943,7 @@ aac_bio_command(struct aac_softc *sc, struct aac_command **cmp)
                br = (struct aac_blockread *)&fib->data[0];
                br->Command = VM_CtBlockRead;
                br->ContainerId = ad->ad_container->co_mntobj.ObjectId;
-               br->BlockNumber = bio->bio_blkno;
+               br->BlockNumber = bio->bio_offset / AAC_BLOCK_SIZE;
                br->ByteCount = bp->b_bcount;
                fib->Header.Size += sizeof(struct aac_blockread);
                cm->cm_sgtable = &br->SgMap;
@@ -952,7 +952,7 @@ aac_bio_command(struct aac_softc *sc, struct aac_command **cmp)
                bw = (struct aac_blockwrite *)&fib->data[0];
                bw->Command = VM_CtBlockWrite;
                bw->ContainerId = ad->ad_container->co_mntobj.ObjectId;
-               bw->BlockNumber = bio->bio_blkno;
+               bw->BlockNumber = bio->bio_offset / AAC_BLOCK_SIZE;
                bw->ByteCount = bp->b_bcount;
                bw->Stable = CUNSTABLE; /* XXX what's appropriate here? */
                fib->Header.Size += sizeof(struct aac_blockwrite);
index b9548b7..40154cc 100644 (file)
@@ -27,7 +27,7 @@
  * SUCH DAMAGE.
  *
  *     $FreeBSD: src/sys/dev/aac/aac_disk.c,v 1.3.2.8 2003/01/11 18:39:39 scottl Exp $
- *     $DragonFly: src/sys/dev/raid/aac/aac_disk.c,v 1.11 2006/02/17 19:18:05 dillon Exp $
+ *     $DragonFly: src/sys/dev/raid/aac/aac_disk.c,v 1.12 2006/03/24 18:35:32 dillon Exp $
  */
 
 #include "opt_aac.h"
@@ -298,7 +298,6 @@ aac_biodone(struct bio *bio, const char *code)
 {
        struct buf *bp = bio->bio_buf;
        struct aac_disk *sc;
-       int blkno;
 
        debug_called(4);
 
@@ -306,14 +305,8 @@ aac_biodone(struct bio *bio, const char *code)
 
        devstat_end_transaction_buf(&sc->ad_stats, bp);
        if (bp->b_flags & B_ERROR) {
-               blkno = (sc->ad_label.d_nsectors) ? 0 : -1;
-#if defined(__FreeBSD__) && __FreeBSD_version > 500005
                diskerr(bio, sc->ad_dev_t,
-                       code, blkno, &sc->ad_label);
-#else
-               diskerr(bio, sc->ad_dev_t,
-                       code, 0, blkno, &sc->ad_label);
-#endif
+                       code, 0, 0, &sc->ad_label);
        }
        biodone(bio);
 }
index 236918b..5e2f156 100644 (file)
@@ -53,7 +53,7 @@
  * SUCH DAMAGE.
  *
  *     $FreeBSD: src/sys/dev/amr/amr.c,v 1.7.2.13 2003/01/15 13:41:18 emoore Exp $
- *     $DragonFly: src/sys/dev/raid/amr/amr.c,v 1.16 2006/02/17 19:18:05 dillon Exp $
+ *     $DragonFly: src/sys/dev/raid/amr/amr.c,v 1.17 2006/03/24 18:35:32 dillon Exp $
  */
 
 /*
@@ -867,6 +867,7 @@ amr_bio_command(struct amr_softc *sc, struct amr_command **acp)
     int                        blkcount;
     int                        driveno;
     int                        cmd;
+    u_int32_t          lba;
 
     ac = NULL;
     error = 0;
@@ -896,16 +897,17 @@ amr_bio_command(struct amr_softc *sc, struct amr_command **acp)
     amrd = (struct amrd_softc *)bio->bio_driver_info;
     driveno = amrd->amrd_drive - sc->amr_drive;
     blkcount = (bio->bio_buf->b_bcount + AMR_BLKSIZE - 1) / AMR_BLKSIZE;
+    lba = bio->bio_offset / AMR_BLKSIZE;
 
     ac->ac_mailbox.mb_command = cmd;
     ac->ac_mailbox.mb_blkcount = blkcount;
-    ac->ac_mailbox.mb_lba = bio->bio_blkno;
+    ac->ac_mailbox.mb_lba = lba;
     ac->ac_mailbox.mb_drive = driveno;
     /* we fill in the s/g related data when the command is mapped */
 
-    if ((bio->bio_blkno + blkcount) > sc->amr_drive[driveno].al_size)
-       device_printf(sc->amr_dev, "I/O beyond end of unit (%lld,%d > %lu)\n", 
-                     (long long)bio->bio_blkno, blkcount,
+    if ((lba + blkcount) > sc->amr_drive[driveno].al_size)
+       device_printf(sc->amr_dev, "I/O beyond end of unit (%ud,%d > %lu)\n", 
+                     lba, blkcount,
                      (u_long)sc->amr_drive[driveno].al_size);
 
 out:
index ef7e646..f5e71ac 100644 (file)
@@ -28,7 +28,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/dev/ida/ida.c,v 1.7.2.3 2001/03/01 01:57:32 ps Exp $
- * $DragonFly: src/sys/dev/raid/ida/ida.c,v 1.9 2006/02/17 19:18:05 dillon Exp $
+ * $DragonFly: src/sys/dev/raid/ida/ida.c,v 1.10 2006/03/24 18:35:32 dillon Exp $
  */
 
 /*
@@ -417,7 +417,7 @@ ida_construct_qcb(struct ida_softc *ida)
                hwqcb->hdr.drive = drv->drive;
        }
 
-       hwqcb->req.blkno = bio->bio_blkno;
+       hwqcb->req.blkno = bio->bio_offset >> DEV_BSHIFT;
        hwqcb->req.bcount = howmany(bp->b_bcount, DEV_BSIZE);
        hwqcb->req.command = bp->b_flags & B_READ ? CMD_READ : CMD_WRITE;
 
index 7e392b5..01b63d7 100644 (file)
@@ -25,7 +25,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/dev/ips/ips_commands.c,v 1.10 2004/05/30 04:01:29 scottl Exp $
- * $DragonFly: src/sys/dev/raid/ips/ips_commands.c,v 1.11 2006/02/17 19:18:05 dillon Exp $
+ * $DragonFly: src/sys/dev/raid/ips/ips_commands.c,v 1.12 2006/03/24 18:35:32 dillon Exp $
  */
 
 #include <sys/devicestat.h>
@@ -144,7 +144,7 @@ ips_io_request_callback(void *cmdptr, bus_dma_segment_t *segments, int segnum,
                length = segments[0].ds_len;
        }
        command_struct->command = cmdtype;
-       command_struct->lba = bio->bio_blkno;
+       command_struct->lba = bio->bio_offset / IPS_BLKSIZE;
        length = (length + IPS_BLKSIZE - 1)/IPS_BLKSIZE;
        command_struct->length = length;
        bus_dmamap_sync(sc->command_dmatag, command->command_dmamap,
@@ -162,7 +162,7 @@ ips_io_request_callback(void *cmdptr, bus_dma_segment_t *segments, int segnum,
         */
        PRINTF(10, "ips test: command id: %d segments: %d "
                "pblkno: %lld length: %d, ds_len: %d\n", command->id, segnum,
-               (long long)bio->bio_blkno,
+               bio->bio_offset / IPS_BLKSIZE,
                length, segments[0].ds_len);
 
        sc->ips_issue_cmd(command);
index 9f9506e..f60b4c9 100644 (file)
@@ -24,7 +24,7 @@
  * SUCH DAMAGE.
  *
  *     $FreeBSD: src/sys/dev/mlx/mlx.c,v 1.14.2.5 2001/09/11 09:49:53 kris Exp $
- *     $DragonFly: src/sys/dev/raid/mlx/mlx.c,v 1.16 2006/02/17 19:18:05 dillon Exp $
+ *     $DragonFly: src/sys/dev/raid/mlx/mlx.c,v 1.17 2006/03/24 18:35:32 dillon Exp $
  */
 
 /*
@@ -1737,6 +1737,7 @@ mlx_startio(struct mlx_softc *sc)
     int                        blkcount;
     int                        driveno;
     int                        cmd;
+    u_daddr_t          blkno;
 
     /* avoid reentrancy */
     if (mlx_lock_tas(sc, MLX_LOCK_STARTING))
@@ -1783,10 +1784,11 @@ mlx_startio(struct mlx_softc *sc)
        mlxd = (struct mlxd_softc *)bio->bio_driver_info;
        driveno = mlxd->mlxd_drive - sc->mlx_sysdrive;
        blkcount = (bp->b_bcount + MLX_BLKSIZE - 1) / MLX_BLKSIZE;
+       blkno = bio->bio_offset / MLX_BLKSIZE;
 
-       if ((bio->bio_blkno + blkcount) > sc->mlx_sysdrive[driveno].ms_size)
+       if ((blkno + blkcount) > sc->mlx_sysdrive[driveno].ms_size)
            device_printf(sc->mlx_dev, "I/O beyond end of unit (%u,%d > %u)\n", 
-                         bio->bio_blkno, blkcount, sc->mlx_sysdrive[driveno].ms_size);
+                         blkno, blkcount, sc->mlx_sysdrive[driveno].ms_size);
 
        /*
         * Build the I/O command.  Note that the SG list type bits are set to zero,
@@ -1795,7 +1797,7 @@ mlx_startio(struct mlx_softc *sc)
        if (sc->mlx_iftype == MLX_IFTYPE_2) {
            mlx_make_type1(mc, (cmd == MLX_CMD_WRITESG) ? MLX_CMD_WRITESG_OLD : MLX_CMD_READSG_OLD,
                           blkcount & 0xff,                             /* xfer length low byte */
-                          bio->bio_blkno,                              /* physical block number */
+                          blkno,                               /* physical block number */
                           driveno,                                     /* target drive number */
                           mc->mc_sgphys,                               /* location of SG list */
                           mc->mc_nsgent & 0x3f);                       /* size of SG list (top 3 bits clear) */
@@ -1803,7 +1805,7 @@ mlx_startio(struct mlx_softc *sc)
            mlx_make_type5(mc, cmd, 
                           blkcount & 0xff,                             /* xfer length low byte */
                           (driveno << 3) | ((blkcount >> 8) & 0x07),   /* target and length high 3 bits */
-                          bio->bio_blkno,                              /* physical block number */
+                          blkno,                               /* physical block number */
                           mc->mc_sgphys,                               /* location of SG list */
                           mc->mc_nsgent & 0x3f);                       /* size of SG list (top 3 bits clear) */
        }
@@ -1845,8 +1847,8 @@ mlx_completeio(struct mlx_command *mc)
        default:                                /* other I/O error */
            device_printf(sc->mlx_dev, "I/O error - %s\n", mlx_diagnose_command(mc));
 #if 0
-           device_printf(sc->mlx_dev, "  b_bcount %ld  blkcount %ld  b_pblkno %d\n", 
-                         bp->b_bcount, bp->b_bcount / MLX_BLKSIZE, bio->bio_blkno);
+           device_printf(sc->mlx_dev, "  b_bcount %ld  offset %lld\n", 
+                         bp->b_bcount, bio->bio_offset);
            device_printf(sc->mlx_dev, "  %13D\n", mc->mc_mailbox, " ");
 #endif
            break;
index 2037054..e1af78b 100644 (file)
@@ -26,7 +26,7 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/dev/pst/pst-raid.c,v 1.2.2.1 2002/08/18 12:32:36 sos Exp $
- * $DragonFly: src/sys/dev/raid/pst/pst-raid.c,v 1.13 2006/02/17 19:18:06 dillon Exp $
+ * $DragonFly: src/sys/dev/raid/pst/pst-raid.c,v 1.14 2006/03/24 18:35:32 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -358,7 +358,7 @@ pst_rw(struct pst_request *request)
     msg->transaction_context = (u_int32_t)request;
     msg->time_multiplier = 1;
     msg->bytecount = bp->b_bcount;
-    msg->lba = ((u_int64_t)request->bio->bio_blkno) * (DEV_BSIZE * 1LL);
+    msg->lba = request->bio->bio_offset;       /* 64 bits */
     if (!iop_create_sgl((struct i2o_basic_message *)msg, bp->b_data,
                        bp->b_bcount, sgl_flag))
        return -1;
index 6849851..06542e5 100644 (file)
@@ -27,7 +27,7 @@
  * SUCH DAMAGE.
  *
  *     $FreeBSD: src/sys/dev/twe/twe.c,v 1.1.2.10 2004/06/11 18:57:31 vkashyap Exp $
- *     $DragonFly: src/sys/dev/raid/twe/twe.c,v 1.13 2006/02/17 19:18:06 dillon Exp $
+ *     $DragonFly: src/sys/dev/raid/twe/twe.c,v 1.14 2006/03/24 18:35:32 dillon Exp $
  */
 
 /*
@@ -423,7 +423,7 @@ twe_startio(struct twe_softc *sc)
            cmd->io.size = 3;
            cmd->io.unit = ((struct twed_softc *)bio->bio_driver_info)->twed_drive->td_twe_unit;
            cmd->io.block_count = (tr->tr_length + TWE_BLOCK_SIZE - 1) / TWE_BLOCK_SIZE;
-           cmd->io.lba = bio->bio_blkno;
+           cmd->io.lba = (u_int32_t)(bio->bio_offset / TWE_BLOCK_SIZE);
        }
        
        /* did we find something to do? */
index 82980c9..7364a01 100644 (file)
@@ -1,4 +1,4 @@
-# $DragonFly: src/sys/dev/raid/vinum/.gdbinit.kernel,v 1.3 2006/02/17 19:18:06 dillon Exp $
+# $DragonFly: src/sys/dev/raid/vinum/.gdbinit.kernel,v 1.4 2006/03/24 18:35:32 dillon Exp $
 set remotebaud 38400
 set remotetimeout 1
 set complaints 1
@@ -229,19 +229,19 @@ end
 define bpp
 set $bp = (struct buf *) $arg0
     if $bp->b_dev
-      printf "  Buffer at 0x%x: dev 0x%x  data 0x%x  bcount 0x%x  blkno 0x%x resid 0x%x\n", \
+      printf "  Buffer at 0x%x: dev 0x%x  data 0x%x  bcount 0x%x  doffset 0x%llx resid 0x%x\n", \
         $bp, \
         $bp->b_dev->si_udev, \
         $bp->b_data, \
         $bp->b_bcount, \
-        $bp->b_bio->bio_blkno, \
+        $bp->b_bio_array[1].bio_offset, \
         $bp->b_resid
     else
-      printf "  Buffer at 0x%x: dev (none) data 0x%x  bcount 0x%x  blkno 0x%x resid 0x%x\n", \
+      printf "  Buffer at 0x%x: dev (none) data 0x%x  bcount 0x%x  doffset 0x%llx resid 0x%x\n", \
         $bp, \
         $bp->b_data, \
         $bp->b_bcount, \
-        $bp->b_bio->bio_blkno, \
+        $bp->b_bio_array[1].bio_offset, \
         $bp->b_resid
     end
     printf "   flags 0x%x: ", $bp->b_flags
@@ -289,10 +289,10 @@ printf "\nb_data:       "
 output $bp->b_data
 printf "\nb_kvasize:    "
 output $bp->b_kvasize
-printf "\nb_lblkno:     "
-output $bp->b_lblkno
-printf "\nb_blkno:      "
-output $bp->b_bio->bio_blkno
+printf "\nb_loffset:     "
+output $bp->b_bio_array[0].bio_offset
+printf "\nb_doffset:      "
+output $bp->b_bio_array[1].bio_offset
 printf "\nb_iodone:     "
 output $bp->b_bio->bio_done
 printf "\nb_vp: "
@@ -307,8 +307,8 @@ printf "\nb_validoff:   "
 output $bp->b_validoff
 printf "\nb_validend:   "
 output $bp->b_validend
-printf "\nb_pblkno:     "
-output $bp->b_pblkno
+printf "\nb_poffset:     "
+output $bp->b_bio_array[2].bio_offset
 printf "\nb_saveaddr:   "
 output $bp->b_saveaddr
 printf "\nb_savekva:    "
@@ -375,8 +375,8 @@ printf "\n b_data "
 output/x bp->b_data
 printf "\n b_kvasize " 
 output/x bp->b_kvasize
-printf "\n b_blkno " 
-output/x bp->b_bio->bio_blkno
+printf "\n b_doffset " 
+output/x bp->b_bio_array[1].bio_offset
 printf "\n b_vp " 
 output/x bp->b_vp
 printf "\n b_dirtyoff " 
index f1e71af..a8bc1a7 100644 (file)
@@ -1,4 +1,4 @@
-# $DragonFly: src/sys/dev/raid/vinum/.gdbinit.vinum,v 1.2 2006/02/17 19:18:06 dillon Exp $
+# $DragonFly: src/sys/dev/raid/vinum/.gdbinit.vinum,v 1.3 2006/03/24 18:35:32 dillon Exp $
 define rq
 rqq rq
 end
@@ -63,7 +63,7 @@ output/x rq->prq[0].rqe[0].b.b_data
 printf " length: " 
 output/x rq->prq[0].rqe[0].b.b_bcount
 printf " drive offset: " 
-output/x rq->prq[0].rqe[0].b.b_bio1.bio_blkno
+output/x rq->prq[0].rqe[0].b.b_bio1.bio_offset
 printf " subdisk offset: " 
 output/x rq->prq[0].rqe[0].sdoffset
 printf "\nFlags: " 
@@ -89,7 +89,7 @@ output/x rq->prq[0].rqe[1].b.b_data
 printf " length: " 
 output/x rq->prq[0].rqe[1].b.b_bcount
 printf " drive offset: " 
-output/x rq->prq[0].rqe[1].b.b_bio1.bio_blkno
+output/x rq->prq[0].rqe[1].b.b_bio1.bio_offset
 printf " subdisk offset: " 
 output/x rq->prq[0].rqe[1].sdoffset
 printf "\nFlags: " 
@@ -106,7 +106,7 @@ output/x rq->prq[1].rqe[0].b.b_data
 printf " length: " 
 output/x rq->prq[1].rqe[0].b.b_bcount
 printf " drive offset: " 
-output/x rq->prq[1].rqe[0].b.b_bio1.bio_blkno
+output/x rq->prq[1].rqe[0].b.b_bio1.bio_offset
 printf " subdisk offset: " 
 output/x rq->prq[1].rqe[0].sdoffset
 printf "\nFlags: " 
@@ -115,9 +115,9 @@ printf "\nrq->prq [1].rqe[1].sdno: "
 output/x rq->prq[1].rqe[1].sdno
 printf "\nBuffer: device: " 
 output/x rq->prq[1].rqe[1].b.b_dev
-printf " data: 0x%x  length 0x%x  drive offset 0x%x  sd offset 0x%x\n" rq->prq[1].rqe[1].b.b_data,
+printf " data: 0x%x  length 0x%x  drive offset 0x%llx  sd offset 0x%x\n" rq->prq[1].rqe[1].b.b_data,
  rq->prq[1].rqe[1].b.b_bcount,
- rq->prq[1].rqe[1].b.b_bio1.bio_blkno,
+ rq->prq[1].rqe[1].b.b_bio1.bio_offset,
  rq->prq[1].rqe[1].sdoffset
 printf "\nFlags: " 
 output/x rq->prq[1].rqe[1].b.b_flags
@@ -187,7 +187,7 @@ define rqinfo
          else
            printf "1VS Write"
          end
-       printf "\t%p\t%d.%d\t0x%-9x\t%ld\n", $rqip->bp, $rqip->devmajor, $rqip->devminor & 0xff, $rqip->info.b.b_bio1.bio_blkno, $rqip->info.b.b_bcount
+       printf "\t%p\t%d.%d\t0x%-9llx\t%ld\n", $rqip->bp, $rqip->devmajor, $rqip->devminor & 0xff, $rqip->info.b.b_bio1.bio_offset, $rqip->info.b.b_bcount
        end
        
       if ($rqip->type == loginfo_user_bpl)
@@ -196,7 +196,7 @@ define rqinfo
          else
            printf "2LR Write"
          end
-       printf "\t%p\t%d.%d\t0x%-9x\t%ld\n", $rqip->bp, $rqip->devmajor, $rqip->devminor & 0xff, $rqip->info.b.b_bio1.bio_blkno, $rqip->info.b.b_bcount
+       printf "\t%p\t%d.%d\t0x%-9llx\t%ld\n", $rqip->bp, $rqip->devmajor, $rqip->devminor & 0xff, $rqip->info.b.b_bio1.bio_offset, $rqip->info.b.b_bcount
        end
         
       if ($rqip->type == loginfo_rqe)
@@ -205,7 +205,7 @@ define rqinfo
          else
            printf "3RQ Write"
          end
-       printf "\t%p\t%d.%d\t0x%-9x\t%ld\t%d\t%x\t%x\t%x\n", $rqip->bp, $rqip->devmajor, $rqip->devminor & 0xff, $rqip->info.rqe.b.b_bio1.bio_blkno, $rqip->info.rqe.b.b_bcount, $rqip->info.rqe.sdno, $rqip->info.rqe.sdoffset, $rqip->info.rqe.dataoffset, $rqip->info.rqe.groupoffset
+       printf "\t%p\t%d.%d\t0x%-9llx\t%ld\t%d\t%x\t%x\t%x\n", $rqip->bp, $rqip->devmajor, $rqip->devminor & 0xff, $rqip->info.rqe.b.b_bio1.bio_offset, $rqip->info.rqe.b.b_bcount, $rqip->info.rqe.sdno, $rqip->info.rqe.sdoffset, $rqip->info.rqe.dataoffset, $rqip->info.rqe.groupoffset
        end
        
       if ($rqip->type == loginfo_iodone)
@@ -214,7 +214,7 @@ define rqinfo
          else
            printf "4DN Write"
          end
-       printf "\t%p\t%d.%d\t0x%-9x\t%ld\t%d\t%x\t%x\t%x\n", $rqip->bp, $rqip->devmajor, $rqip->devminor & 0xff, $rqip->info.rqe.b.b_bio1.bio_blkno, $rqip->info.rqe.b.b_bcount, $rqip->info.rqe.sdno, $rqip->info.rqe.sdoffset, $rqip->info.rqe.dataoffset, $rqip->info.rqe.groupoffset
+       printf "\t%p\t%d.%d\t0x%-9llx\t%ld\t%d\t%x\t%x\t%x\n", $rqip->bp, $rqip->devmajor, $rqip->devminor & 0xff, $rqip->info.rqe.b.b_bio1.bio_offset, $rqip->info.rqe.b.b_bcount, $rqip->info.rqe.sdno, $rqip->info.rqe.sdoffset, $rqip->info.rqe.dataoffset, $rqip->info.rqe.groupoffset
        end
        
       if ($rqip->type == loginfo_raid5_data)
@@ -223,7 +223,7 @@ define rqinfo
          else
            printf "5RD Write"
          end
-       printf "\t%p\t%d.%d\t0x%-9x\t%ld\t%d\t%x\t%x\t%x\n", $rqip->bp, $rqip->devmajor, $rqip->devminor & 0xff, $rqip->info.rqe.b.b_bio1.bio_blkno, $rqip->info.rqe.b.b_bcount, $rqip->info.rqe.sdno, $rqip->info.rqe.sdoffset, $rqip->info.rqe.dataoffset, $rqip->info.rqe.groupoffset
+       printf "\t%p\t%d.%d\t0x%-9llx\t%ld\t%d\t%x\t%x\t%x\n", $rqip->bp, $rqip->devmajor, $rqip->devminor & 0xff, $rqip->info.rqe.b.b_bio1.bio_offset, $rqip->info.rqe.b.b_bcount, $rqip->info.rqe.sdno, $rqip->info.rqe.sdoffset, $rqip->info.rqe.dataoffset, $rqip->info.rqe.groupoffset
        end
        
       if ($rqip->type == loginfo_raid5_parity)
@@ -232,7 +232,7 @@ define rqinfo
          else
            printf "6RP Write"
          end
-       printf "\t%p\t%d.%d\t0x%-9x\t%ld\t%d\t%x\t%x\t%x\n", $rqip->bp, $rqip->devmajor, $rqip->devminor & 0xff, $rqip->info.rqe.b.b_bio1.bio_blkno, $rqip->info.rqe.b.b_bcount, $rqip->info.rqe.sdno, $rqip->info.rqe.sdoffset, $rqip->info.rqe.dataoffset, $rqip->info.rqe.groupoffset
+       printf "\t%p\t%d.%d\t0x%-9llx\t%ld\t%d\t%x\t%x\t%x\n", $rqip->bp, $rqip->devmajor, $rqip->devminor & 0xff, $rqip->info.rqe.b.b_bio1.bio_offset, $rqip->info.rqe.b.b_bcount, $rqip->info.rqe.sdno, $rqip->info.rqe.sdoffset, $rqip->info.rqe.dataoffset, $rqip->info.rqe.groupoffset
        end
 
       if ($rqip->type == loginfo_sdio)
@@ -241,7 +241,7 @@ define rqinfo
          else
            printf "7VS Write"
          end
-       printf "\t%p\t\t  0x%-9x\t%ld\t%d\n", $rqip->bp, $rqip->info.b.b_bio1.bio_blkno, $rqip->info.b.b_bcount, $rqip->devminor & 0xff
+       printf "\t%p\t\t  0x%-9llx\t%ld\t%d\n", $rqip->bp, $rqip->info.b.b_bio1.bio_offset, $rqip->info.b.b_bcount, $rqip->devminor & 0xff
        end
 
       if ($rqip->type == loginfo_sdiol)
@@ -250,7 +250,7 @@ define rqinfo
          else
            printf "8LR Write"
          end
-       printf "\t%p\t%d.%d\t0x%-9x\t%ld\n", $rqip->bp, $rqip->devmajor, $rqip->devminor & 0xff, $rqip->info.b.b_bio1.bio_blkno, $rqip->info.b.b_bcount
+       printf "\t%p\t%d.%d\t0x%-9llx\t%ld\n", $rqip->bp, $rqip->devmajor, $rqip->devminor & 0xff, $rqip->info.b.b_bio1.bio_offset, $rqip->info.b.b_bcount
        end
         
       if ($rqip->type == loginfo_lockwait)
@@ -271,7 +271,7 @@ define rqinfo
          else
            printf "9DN Write"
          end
-       printf "\t%p\t\t  0x%-9x\t%ld\t%d\n", $rqip->bp, $rqip->info.b.b_bio1.bio_blkno, $rqip->info.b.b_bcount, $rqip->devminor
+       printf "\t%p\t\t  0x%-9llx\t%ld\t%d\n", $rqip->bp, $rqip->info.b.b_bio1.bio_offset, $rqip->info.b.b_bcount, $rqip->devminor
        end
 
        end
index e25debc..0f65c69 100644 (file)
@@ -36,7 +36,7 @@
  *
  * $Id: vinumdaemon.c,v 1.8 2000/01/03 05:22:03 grog Exp grog $
  * $FreeBSD: src/sys/dev/vinum/vinumdaemon.c,v 1.16 2000/01/05 06:03:56 grog Exp $
- * $DragonFly: src/sys/dev/raid/vinum/vinumdaemon.c,v 1.8 2006/02/17 19:18:06 dillon Exp $
+ * $DragonFly: src/sys/dev/raid/vinum/vinumdaemon.c,v 1.9 2006/03/24 18:35:32 dillon Exp $
  */
 
 #include "vinumhdr.h"
@@ -104,12 +104,12 @@ vinum_daemon(void)
                    struct request *rq = request->info.rq;
 
                    log(LOG_WARNING,
-                       "vinum: recovering I/O request: %p\n%s dev %d.%d, offset 0x%x, length %ld\n",
+                       "vinum: recovering I/O request: %p\n%s dev %d.%d, offset 0x%012llx, length %d\n",
                        rq,
                        rq->bio->bio_buf->b_flags & B_READ ? "Read" : "Write",
                        major((dev_t)rq->bio->bio_driver_info),
                        minor((dev_t)rq->bio->bio_driver_info),
-                       rq->bio->bio_blkno,
+                       rq->bio->bio_offset,
                        rq->bio->bio_buf->b_bcount);
                }
                recover_io(request->info.rq);               /* the failed request */
index ee07ab1..d5ef5db 100644 (file)
@@ -41,7 +41,7 @@
  *
  * $Id: vinuminterrupt.c,v 1.12 2000/11/24 03:41:42 grog Exp grog $
  * $FreeBSD: src/sys/dev/vinum/vinuminterrupt.c,v 1.25.2.3 2001/05/28 05:56:27 grog Exp $
- * $DragonFly: src/sys/dev/raid/vinum/vinuminterrupt.c,v 1.6 2006/02/17 19:18:06 dillon Exp $
+ * $DragonFly: src/sys/dev/raid/vinum/vinuminterrupt.c,v 1.7 2006/03/24 18:35:32 dillon Exp $
  */
 
 #include "vinumhdr.h"
@@ -102,10 +102,10 @@ complete_rqe(struct bio *bio)
                set_sd_state(rqe->sdno, sd_crashed, setstate_force); /* subdisk is crashed */
            }
            log(LOG_ERR,
-               "%s:%s read error, block %d for %ld bytes\n",
+               "%s:%s read error, offset %lld for %d bytes\n",
                gravity,
                sd->name,
-               bio->bio_blkno,
+               bio->bio_offset,
                bp->b_bcount);
        } else {                                            /* write operation */
            if ((rq->error == ENXIO) || (sd->flags & VF_RETRYERRORS) == 0) {
@@ -113,22 +113,22 @@ complete_rqe(struct bio *bio)
                set_sd_state(rqe->sdno, sd_stale, setstate_force); /* subdisk is stale */
            }
            log(LOG_ERR,
-               "%s:%s write error, block %d for %ld bytes\n",
+               "%s:%s write error, offset %lld for %d bytes\n",
                gravity,
                sd->name,
-               bio->bio_blkno,
+               bio->bio_offset,
                bp->b_bcount);
        }
        log(LOG_ERR,
-           "%s: user buffer block %d for %ld bytes\n",
+           "%s: user buffer offset %lld for %d bytes\n",
            sd->name,
-           ubio->bio_blkno,
+           ubio->bio_offset,
            ubio->bio_buf->b_bcount);
        if (rq->error == ENXIO) {                           /* the drive's down too */
            log(LOG_ERR,
-               "%s: fatal drive I/O error, block %d for %ld bytes\n",
+               "%s: fatal drive I/O error, offset %lld for %d bytes\n",
                DRIVE[rqe->driveno].label.name,
-               bio->bio_blkno,
+               bio->bio_offset,
                bp->b_bcount);
            DRIVE[rqe->driveno].lasterror = rq->error;
            set_drive_state(rqe->driveno,                   /* take the drive down */
@@ -393,7 +393,7 @@ complete_raid5_write(struct rqelement *rqe)
                    rqe->b.b_bcount = rqe->datalen << DEV_BSHIFT; /* length to write */
                    rqe->b.b_bufsize = rqe->b.b_bcount;     /* don't claim more */
                    rqe->b.b_resid = rqe->b.b_bcount;       /* nothing transferred */
-                   rqe->b.b_bio1.bio_blkno += rqe->dataoffset;     /* point to the correct block */
+                   rqe->b.b_bio1.bio_offset += (off_t)rqe->dataoffset << DEV_BSHIFT;       /* point to the correct block */
                    dev = DRIVE[rqe->driveno].dev;
                    rqe->b.b_bio1.bio_driver_info = dev;
                    rqg->active++;                          /* another active request */
@@ -409,13 +409,13 @@ complete_raid5_write(struct rqelement *rqe)
 #if VINUMDEBUG
                    if (debug & DEBUG_ADDRESSES)
                        log(LOG_DEBUG,
-                           "  %s dev %d.%d, sd %d, offset 0x%x, devoffset 0x%x, length %ld\n",
+                           "  %s dev %d.%d, sd %d, offset 0x%llx, devoffset 0x%llx, length %ld\n",
                            rqe->b.b_flags & B_READ ? "Read" : "Write",
                            major(dev),
                            minor(dev),
                            rqe->sdno,
-                           (u_int) (rqe->b.b_bio1.bio_blkno - SD[rqe->sdno].driveoffset),
-                           rqe->b.b_bio1.bio_blkno,
+                           rqe->b.b_bio1.bio_offset - ((off_t)SD[rqe->sdno].driveoffset << DEV_BSHIFT),
+                           rqe->b.b_bio1.bio_offset,
                            rqe->b.b_bcount);
                    if (debug & DEBUG_LASTREQS)
                        logrq(loginfo_raid5_data, (union rqinfou) rqe, ubio);
@@ -449,13 +449,13 @@ complete_raid5_write(struct rqelement *rqe)
 #if VINUMDEBUG
     if (debug & DEBUG_ADDRESSES)
        log(LOG_DEBUG,
-           "  %s dev %d.%d, sd %d, offset 0x%x, devoffset 0x%x, length %ld\n",
+           "  %s dev %d.%d, sd %d, offset 0x%llx, devoffset 0x%llx, length %ld\n",
            rqe->b.b_flags & B_READ ? "Read" : "Write",
            major(dev),
            minor(dev),
            rqe->sdno,
-           (u_int) (rqe->b.b_bio1.bio_blkno - SD[rqe->sdno].driveoffset),
-           rqe->b.b_bio1.bio_blkno,
+           rqe->b.b_bio1.bio_offset - ((off_t)SD[rqe->sdno].driveoffset << DEV_BSHIFT),
+           rqe->b.b_bio1.bio_offset,
            rqe->b.b_bcount);
     if (debug & DEBUG_LASTREQS)
        logrq(loginfo_raid5_parity, (union rqinfou) rqe, ubio);
index e8ab7fa..9bc3f0d 100644 (file)
@@ -35,7 +35,7 @@
  *
  * $Id: vinumio.c,v 1.30 2000/05/10 23:23:30 grog Exp grog $
  * $FreeBSD: src/sys/dev/vinum/vinumio.c,v 1.52.2.6 2002/05/02 08:43:44 grog Exp $
- * $DragonFly: src/sys/dev/raid/vinum/vinumio.c,v 1.10 2006/02/17 19:18:06 dillon Exp $
+ * $DragonFly: src/sys/dev/raid/vinum/vinumio.c,v 1.11 2006/03/24 18:35:32 dillon Exp $
  */
 
 #include "vinumhdr.h"
@@ -324,7 +324,7 @@ driveio(struct drive *drive, char *buf, size_t length, off_t offset, int flag)
 
        bp = geteblk(len);                                  /* get a buffer header */
        bp->b_flags = flag;
-       bp->b_bio1.bio_blkno = offset / drive->partinfo.disklab->d_secsize; /* block number */
+       bp->b_bio1.bio_offset = offset;                     /* disk offset */
        bp->b_saveaddr = bp->b_data;
        bp->b_data = buf;
        bp->b_bcount = len;
@@ -793,7 +793,7 @@ write_volume_label(int volno)
      */
     bp = geteblk((int) lp->d_secsize);                     /* get a buffer */
     dev = make_adhoc_dev(&vinum_cdevsw, vol->volno);
-    bp->b_bio1.bio_blkno = LABELSECTOR * ((int) lp->d_secsize / DEV_BSIZE);
+    bp->b_bio1.bio_offset = (off_t)LABELSECTOR * lp->d_secsize;
     bp->b_bcount = lp->d_secsize;
     bzero(bp->b_data, lp->d_secsize);
     dlp = (struct disklabel *) bp->b_data;
index a5194c0..47f7000 100644 (file)
@@ -39,7 +39,7 @@
  *
  * $Id: vinumrequest.c,v 1.30 2001/01/09 04:20:55 grog Exp grog $
  * $FreeBSD: src/sys/dev/vinum/vinumrequest.c,v 1.44.2.5 2002/08/28 04:30:56 grog Exp $
- * $DragonFly: src/sys/dev/raid/vinum/vinumrequest.c,v 1.7 2006/02/17 19:18:06 dillon Exp $
+ * $DragonFly: src/sys/dev/raid/vinum/vinumrequest.c,v 1.8 2006/03/24 18:35:32 dillon Exp $
  */
 
 #include "vinumhdr.h"
@@ -258,7 +258,8 @@ vinumstart(dev_t dev, struct bio *bio, int reviveok)
            }
            status = build_read_request(rq, plexno);        /* build a request */
        } else {
-           daddr_t diskaddr = bio->bio_blkno;              /* start offset of transfer */
+           daddr_t diskaddr = (daddr_t)(bio->bio_offset >> DEV_BSHIFT);
+                                                           /* start offset of transfer */
            status = bre(rq,                                /* build a request list */
                rq->volplex.plexno,
                &diskaddr,
@@ -285,12 +286,12 @@ vinumstart(dev_t dev, struct bio *bio, int reviveok)
            status = build_write_request(rq);               /* Not all the subdisks are up */
        else {                                              /* plex I/O */
            daddr_t diskstart;
+           daddr_t diskend;
 
-           diskstart = bio->bio_blkno;                     /* start offset of transfer */
-           status = bre(rq,
-               Plexno(dev),
-               &diskstart,
-               bio->bio_blkno + (bp->b_bcount / DEV_BSIZE));  /* build requests for the plex */
+           diskstart = (daddr_t)(bio->bio_offset >> DEV_BSHIFT); /* start offset of transfer */
+           diskend = diskstart + bp->b_bcount / DEV_BSIZE;
+           status = bre(rq, Plexno(dev),
+               &diskstart, diskend);  /* build requests for the plex */
        }
        if (status > REQUEST_RECOVERED) {                   /* can't satisfy it */
            if (status == REQUEST_DOWN) {                   /* not enough subdisks */
@@ -342,13 +343,13 @@ launch_requests(struct request *rq, int reviveok)
 #if VINUMDEBUG
        if (debug & DEBUG_REVIVECONFLICT) {
            log(LOG_DEBUG,
-               "Revive conflict sd %d: %p\n%s dev %d.%d, offset 0x%x, length %ld\n",
+               "Revive conflict sd %d: %p\n%s dev %d.%d, offset 0x%llx, length %ld\n",
                rq->sdno,
                rq,
                rq->bio->bio_buf->b_flags & B_READ ? "Read" : "Write",
                major(((dev_t)rq->bio->bio_driver_info)),
                minor(((dev_t)rq->bio->bio_driver_info)),
-               rq->bio->bio_blkno,
+               rq->bio->bio_offset,
                rq->bio->bio_buf->b_bcount);
        }
 #endif
@@ -358,12 +359,12 @@ launch_requests(struct request *rq, int reviveok)
 #if VINUMDEBUG
     if (debug & DEBUG_ADDRESSES)
        log(LOG_DEBUG,
-           "Request: %p\n%s dev %d.%d, offset 0x%x, length %ld\n",
+           "Request: %p\n%s dev %d.%d, offset 0x%llx, length %ld\n",
            rq,
            rq->bio->bio_buf->b_flags & B_READ ? "Read" : "Write",
            major(((dev_t)rq->bio->bio_driver_info)),
            minor(((dev_t)rq->bio->bio_driver_info)),
-           rq->bio->bio_blkno,
+           rq->bio->bio_offset,
            rq->bio->bio_buf->b_bcount);
     vinum_conf.lastrq = rq;
     vinum_conf.lastbio = rq->bio;
@@ -421,13 +422,13 @@ launch_requests(struct request *rq, int reviveok)
 #ifdef VINUMDEBUG
                if (debug & DEBUG_ADDRESSES)
                    log(LOG_DEBUG,
-                       "  %s dev %d.%d, sd %d, offset 0x%x, devoffset 0x%x, length %ld\n",
+                       "  %s dev %d.%d, sd %d, offset 0x%llx, devoffset 0x%llx, length %ld\n",
                        rqe->b.b_flags & B_READ ? "Read" : "Write",
                        major(dev),
                        minor(dev),
                        rqe->sdno,
-                       (u_int) (rqe->b.b_bio1.bio_blkno - SD[rqe->sdno].driveoffset),
-                       rqe->b.b_bio1.bio_blkno,
+                       rqe->b.b_bio1.bio_offset - ((off_t)SD[rqe->sdno].driveoffset << DEV_BSHIFT),
+                       rqe->b.b_bio1.bio_offset,
                        rqe->b.b_bcount);
                if (debug & DEBUG_LASTREQS)
                    logrq(loginfo_rqe, (union rqinfou) rqe, rq->bio);
@@ -627,11 +628,11 @@ bre(struct request *rq,
 #if VINUMDEBUG
                    if (debug & DEBUG_EOFINFO) {            /* tell on the request */
                        log(LOG_DEBUG,
-                           "vinum: EOF on plex %s, sd %s offset %x (user offset %x)\n",
+                           "vinum: EOF on plex %s, sd %s offset %llx (user offset %x)\n",
                            plex->name,
                            sd->name,
                            (u_int) sd->sectors,
-                           bp->b_bio1.bio_blkno);
+                           bp->b_bio1.bio_offset);
                        log(LOG_DEBUG,
                            "vinum: stripebase %x, stripeoffset %x, blockoffset %x\n",
                            stripebase,
@@ -697,7 +698,7 @@ build_read_request(struct request *rq,                          /* request */
 
     bio = rq->bio;                                         /* buffer pointer */
     bp = bio->bio_buf;
-    diskaddr = bio->bio_blkno;                             /* start offset of transfer */
+    diskaddr = bio->bio_offset >> DEV_BSHIFT;              /* start offset of transfer */
     diskend = diskaddr + (bp->b_bcount / DEV_BSIZE);       /* and end offset of transfer */
     rqg = &rq->rqg[plexindex];                             /* plex request */
     vol = &VOL[rq->volplex.volno];                         /* point to volume */
@@ -774,10 +775,10 @@ build_write_request(struct request *rq)
     bio = rq->bio;                                         /* buffer pointer */
     bp = bio->bio_buf;
     vol = &VOL[rq->volplex.volno];                         /* point to volume */
-    diskend = bio->bio_blkno + (bp->b_bcount / DEV_BSIZE);         /* end offset of transfer */
+    diskend = (daddr_t)(bio->bio_offset >> DEV_BSHIFT) + (bp->b_bcount / DEV_BSIZE);       /* end offset of transfer */
     status = REQUEST_DOWN;                                 /* assume the worst */
     for (plexno = 0; plexno < vol->plexes; plexno++) {
-       diskstart = bio->bio_blkno;                         /* start offset of transfer */
+       diskstart = (daddr_t)(bio->bio_offset >> DEV_BSHIFT);                       /* start offset of transfer */
        /*
         * Build requests for the plex.
         * We take the best possible result here (min,
@@ -830,7 +831,7 @@ build_rq_buffer(struct rqelement *rqe, struct plex *plex)
      */
     if ((rqe->flags & XFR_BAD_SUBDISK) == 0)               /* subdisk is accessible, */
        bp->b_bio1.bio_driver_info = DRIVE[rqe->driveno].dev; /* drive device */
-    bp->b_bio1.bio_blkno = rqe->sdoffset + sd->driveoffset;    /* start address */
+    bp->b_bio1.bio_offset = (off_t)(rqe->sdoffset + sd->driveoffset) << DEV_BSHIFT;    /* start address */
     bp->b_bcount = rqe->buflen << DEV_BSHIFT;              /* number of bytes to transfer */
     bp->b_resid = bp->b_bcount;                                    /* and it's still all waiting */
     bp->b_bufsize = bp->b_bcount;                          /* and buffer size */
@@ -952,12 +953,12 @@ sdio(struct bio *bio)
     BUF_LOCK(&sbp->b, LK_EXCLUSIVE);                       /* and lock it */
     BUF_KERNPROC(&sbp->b);
     initbufbio(&sbp->b);
-    sbp->b.b_bio1.bio_blkno = bio->bio_blkno + sd->driveoffset;
+    sbp->b.b_bio1.bio_offset = bio->bio_offset + ((off_t)sd->driveoffset << DEV_BSHIFT);
     sbp->b.b_bio1.bio_done = sdio_done;                            /* come here on completion */
     sbp->bio = bio;                                        /* note the address of the original header */
     sbp->sdno = sd->sdno;                                  /* note for statistics */
     sbp->driveno = sd->driveno;
-    endoffset = bio->bio_blkno + sbp->b.b_bcount / DEV_BSIZE;  /* final sector offset */
+    endoffset = (daddr_t)(bio->bio_offset >> DEV_BSHIFT) + sbp->b.b_bcount / DEV_BSIZE;  /* final sector offset */
     if (endoffset > sd->sectors) {                         /* beyond the end */
        sbp->b.b_bcount -= (endoffset - sd->sectors) * DEV_BSIZE; /* trim */
        if (sbp->b.b_bcount <= 0) {                         /* nothing to transfer */
@@ -972,13 +973,13 @@ sdio(struct bio *bio)
 #if VINUMDEBUG
     if (debug & DEBUG_ADDRESSES)
        log(LOG_DEBUG,
-           "  %s dev %d.%d, sd %d, offset 0x%x, devoffset 0x%x, length %ld\n",
+           "  %s dev %d.%d, sd %d, offset 0x%llx, devoffset 0x%llx, length %ld\n",
            sbp->b.b_flags & B_READ ? "Read" : "Write",
            major(sddev),
            minor(sddev),
            sbp->sdno,
-           (u_int) (sbp->b.b_bio1.bio_blkno - SD[sbp->sdno].driveoffset),
-           (int) sbp->b.b_bio1.bio_blkno,
+           sbp->b.b_bio1.bio_offset - ((off_t)SD[sbp->sdno].driveoffset << DEV_BSHIFT),
+           sbp->b.b_bio1.bio_offset,
            sbp->b.b_bcount);
 #endif
     crit_enter();
@@ -1013,11 +1014,12 @@ vinum_bounds_check(struct bio *bio, struct volume *vol)
     struct bio *nbio;
     int maxsize = vol->size;                               /* size of the partition (sectors) */
     int size = (bp->b_bcount + DEV_BSIZE - 1) >> DEV_BSHIFT; /* size of this request (sectors) */
+    daddr_t blkno = (daddr_t)(bio->bio_offset >> DEV_BSHIFT);
 
     /* Would this transfer overwrite the disk label? */
-    if (bio->bio_blkno <= LABELSECTOR                      /* starts before or at the label */
+    if (blkno <= LABELSECTOR                       /* starts before or at the label */
 #if LABELSECTOR != 0
-       && bio->bio_blkno + size > LABELSECTOR              /* and finishes after */
+       && blkno + size > LABELSECTOR               /* and finishes after */
 #endif
        && (!(vol->flags & VF_RAW))                         /* and it's not raw */
        &&((bp->b_flags & B_READ) == 0)                     /* and it's a write */
@@ -1029,15 +1031,15 @@ vinum_bounds_check(struct bio *bio, struct volume *vol)
     if (size == 0)                                         /* no transfer specified, */
        return 0;                                           /* treat as EOF */
     /* beyond partition? */
-    if (bio->bio_blkno < 0                                 /* negative start */
-       || bio->bio_blkno + size > maxsize) {               /* or goes beyond the end of the partition */
+    if (bio->bio_offset < 0                                /* negative start */
+       || blkno + size > maxsize) {                /* or goes beyond the end of the partition */
        /* if exactly at end of disk, return an EOF */
-       if (bio->bio_blkno == maxsize) {
+       if (blkno == maxsize) {
            bp->b_resid = bp->b_bcount;
            return (NULL);
        }
        /* or truncate if part of it fits */
-       size = maxsize - bio->bio_blkno;
+       size = maxsize - blkno;
        if (size <= 0) {                                    /* nothing to transfer */
            bp->b_error = EINVAL;
            bp->b_flags |= B_ERROR;
@@ -1046,7 +1048,7 @@ vinum_bounds_check(struct bio *bio, struct volume *vol)
        bp->b_bcount = size << DEV_BSHIFT;
     }
     nbio = push_bio(bio);
-    nbio->bio_blkno = bio->bio_blkno;
+    nbio->bio_offset = bio->bio_offset;
     return (nbio);
 }
 
index 1834078..19247b7 100644 (file)
@@ -39,7 +39,7 @@
  *
  * $Id: vinumrevive.c,v 1.14 2000/12/21 01:55:11 grog Exp grog $
  * $FreeBSD: src/sys/dev/vinum/vinumrevive.c,v 1.22.2.5 2001/03/13 02:59:43 grog Exp $
- * $DragonFly: src/sys/dev/raid/vinum/vinumrevive.c,v 1.6 2006/02/17 19:18:06 dillon Exp $
+ * $DragonFly: src/sys/dev/raid/vinum/vinumrevive.c,v 1.7 2006/03/24 18:35:32 dillon Exp $
  */
 
 #include "vinumhdr.h"
@@ -152,7 +152,7 @@ revive_block(int sdno)
         */
        bp->b_bcount = size;
        bp->b_resid = bp->b_bcount;
-       bp->b_bio1.bio_blkno = plexblkno;                   /* start here */
+       bp->b_bio1.bio_offset = (off_t)plexblkno << DEV_BSHIFT;             /* start here */
        if (isstriped(plex))                                /* we need to lock striped plexes */
            lock = lockrange(plexblkno << DEV_BSHIFT, bp, plex); /* lock it */
        if (vol != NULL)                                    /* it's part of a volume, */
@@ -177,7 +177,7 @@ revive_block(int sdno)
        dev = VINUM_SD(sdno);                       /* create the device number */
        bp->b_flags = B_ORDERED | B_WRITE;                  /* and make this an ordered write */
        bp->b_resid = bp->b_bcount;
-       bp->b_bio1.bio_blkno = sd->revived;                 /* write it to here */
+       bp->b_bio1.bio_offset = (off_t)sd->revived << DEV_BSHIFT;                   /* write it to here */
        bp->b_bio1.bio_driver_info = dev;
        sdio(&bp->b_bio1);                                  /* perform the I/O */
        biowait(bp);
@@ -203,13 +203,13 @@ revive_block(int sdno)
            if (debug & DEBUG_REVIVECONFLICT) {
                dev = rq->bio->bio_driver_info;
                log(LOG_DEBUG,
-                   "Relaunch revive conflict sd %d: %p\n%s dev %d.%d, offset 0x%x, length %ld\n",
+                   "Relaunch revive conflict sd %d: %p\n%s dev %d.%d, offset 0x%llx, length %ld\n",
                    rq->sdno,
                    rq,
                    rq->bio->bio_buf->b_flags & B_READ ? "Read" : "Write",
                    major(dev),
                    minor(dev),
-                   rq->bio->bio_blkno,
+                   rq->bio->bio_offset,
                    rq->bio->bio_buf->b_bcount);
            }
 #endif
@@ -416,7 +416,7 @@ parityrebuild(struct plex *plex,
            bpp[sdno]->b_flags = B_READ;                    /* either way, read it */
            bpp[sdno]->b_bcount = mysize;
            bpp[sdno]->b_resid = bpp[sdno]->b_bcount;
-           bpp[sdno]->b_bio1.bio_blkno = pstripe;          /* transfer from here */
+           bpp[sdno]->b_bio1.bio_offset = (off_t)pstripe << DEV_BSHIFT;            /* transfer from here */
        }
     }
 
@@ -550,7 +550,7 @@ initsd(int sdno, int verify)
 
        bp->b_bcount = size;
        bp->b_resid = bp->b_bcount;
-       bp->b_bio1.bio_blkno = sd->initialized;             /* write it to here */
+       bp->b_bio1.bio_offset = (off_t)sd->initialized << DEV_BSHIFT;               /* write it to here */
        bp->b_bio1.bio_driver_info = VINUM_SD(sdno);
        bzero(bp->b_data, bp->b_bcount);
        bp->b_flags &= ~B_READ;
@@ -572,7 +572,7 @@ initsd(int sdno, int verify)
            } else {
                bp->b_bcount = size;
                bp->b_resid = bp->b_bcount;
-               bp->b_bio1.bio_blkno = sd->initialized;     /* read from here */
+               bp->b_bio1.bio_offset = (off_t)sd->initialized << DEV_BSHIFT;       /* read from here */
                bp->b_bio1.bio_driver_info = VINUM_SD(sdno);
                bp->b_flags |= B_READ;                      /* read it back */
                crit_exit();
index 5155ad2..e9ec7ec 100644 (file)
@@ -39,7 +39,7 @@
  *     @(#)procfs_vnops.c      8.18 (Berkeley) 5/21/95
  *
  * $FreeBSD: src/sys/i386/linux/linprocfs/linprocfs_vnops.c,v 1.3.2.5 2001/08/12 14:29:19 rwatson Exp $
- * $DragonFly: src/sys/emulation/linux/i386/linprocfs/linprocfs_vnops.c,v 1.26 2006/01/31 02:15:10 corecode Exp $
+ * $DragonFly: src/sys/emulation/linux/i386/linprocfs/linprocfs_vnops.c,v 1.27 2006/03/24 18:35:32 dillon Exp $
  */
 
 /*
@@ -296,13 +296,14 @@ linprocfs_ioctl(struct vop_ioctl_args *ap)
 static int
 linprocfs_bmap(struct vop_bmap_args *ap)
 {
-
        if (ap->a_vpp != NULL)
                *ap->a_vpp = ap->a_vp;
-       if (ap->a_bnp != NULL)
-               *ap->a_bnp = ap->a_bn;
+       if (ap->a_doffsetp != NULL)
+               *ap->a_doffsetp = ap->a_loffset;
        if (ap->a_runp != NULL)
                *ap->a_runp = 0;
+       if (ap->a_runb != NULL)
+               *ap->a_runb = 0;
        return (0);
 }
 
index d9fa4bb..1cb6d38 100644 (file)
@@ -36,7 +36,7 @@
  *
  *     from: @(#)machdep.c     7.4 (Berkeley) 6/3/91
  * $FreeBSD: src/sys/i386/i386/machdep.c,v 1.385.2.30 2003/05/31 08:48:05 alc Exp $
- * $DragonFly: src/sys/i386/i386/Attic/machdep.c,v 1.87 2006/03/05 18:38:32 dillon Exp $
+ * $DragonFly: src/sys/i386/i386/Attic/machdep.c,v 1.88 2006/03/24 18:35:32 dillon Exp $
  */
 
 #include "use_apm.h"
@@ -2528,12 +2528,13 @@ bounds_check_with_label(dev_t dev, struct bio *bio,
         int labelsect = lp->d_partitions[0].p_offset;
         int maxsz = p->p_size,
                 sz = (bp->b_bcount + DEV_BSIZE - 1) >> DEV_BSHIFT;
+       daddr_t blkno = (daddr_t)(bio->bio_offset >> DEV_BSHIFT);
 
         /* overwriting disk label ? */
         /* XXX should also protect bootstrap in first 8K */
-        if (bio->bio_blkno + p->p_offset <= LABELSECTOR + labelsect &&
+        if (blkno + p->p_offset <= LABELSECTOR + labelsect &&
 #if LABELSECTOR != 0
-            bio->bio_blkno + p->p_offset + sz > LABELSECTOR + labelsect &&
+            blkno + p->p_offset + sz > LABELSECTOR + labelsect &&
 #endif
             (bp->b_flags & B_READ) == 0 && wlabel == 0) {
                 bp->b_error = EROFS;
@@ -2542,7 +2543,7 @@ bounds_check_with_label(dev_t dev, struct bio *bio,
 
 #if     defined(DOSBBSECTOR) && defined(notyet)
         /* overwriting master boot record? */
-        if (bio->bio_blkno + p->p_offset <= DOSBBSECTOR &&
+        if (blkno + p->p_offset <= DOSBBSECTOR &&
             (bp->b_flags & B_READ) == 0 && wlabel == 0) {
                 bp->b_error = EROFS;
                 goto bad;
@@ -2550,14 +2551,14 @@ bounds_check_with_label(dev_t dev, struct bio *bio,
 #endif
 
         /* beyond partition? */
-        if (bio->bio_blkno < 0 || bio->bio_blkno + sz > maxsz) {
+        if (bio->bio_offset < 0 || blkno + sz > maxsz) {
                 /* if exactly at end of disk, return an EOF */
-                if (bio->bio_blkno == maxsz) {
+                if (blkno == maxsz) {
                         bp->b_resid = bp->b_bcount;
                         return(0);
                 }
                 /* or truncate if part of it fits */
-                sz = maxsz - bio->bio_blkno;
+                sz = maxsz - blkno;
                 if (sz <= 0) {
                         bp->b_error = EINVAL;
                         goto bad;
@@ -2565,7 +2566,7 @@ bounds_check_with_label(dev_t dev, struct bio *bio,
                 bp->b_bcount = sz << DEV_BSHIFT;
         }
        nbio = push_bio(bio);
-        nbio->bio_blkno = bio->bio_blkno + p->p_offset;
+        nbio->bio_offset = bio->bio_offset + ((off_t)p->p_offset << DEV_BSHIFT);
        return (nbio);
 
 bad:
index 2548293..5edf042 100644 (file)
@@ -35,7 +35,7 @@
  *
  *     from: @(#)param.h       5.8 (Berkeley) 6/28/91
  * $FreeBSD: src/sys/i386/include/param.h,v 1.54.2.8 2002/08/31 21:15:55 dillon Exp $
- * $DragonFly: src/sys/i386/include/Attic/param.h,v 1.8 2006/03/08 04:54:05 reed Exp $
+ * $DragonFly: src/sys/i386/include/Attic/param.h,v 1.9 2006/03/24 18:35:33 dillon Exp $
  */
 
 #ifndef _MACHINE_PARAM_H_
 #define PDRMASK                (NBPDR-1)
 
 #define DEV_BSHIFT     9               /* log2(DEV_BSIZE) */
-#define DEV_BSIZE      (1<<DEV_BSHIFT)
+#define DEV_BSIZE      (1 << DEV_BSHIFT)
+#define DEV_BMASK      (DEV_BSIZE - 1)
 
 #ifndef BLKDEV_IOSIZE
 #define BLKDEV_IOSIZE  PAGE_SIZE       /* default block device I/O size */
index d64808f..67f43bd 100644 (file)
@@ -17,7 +17,7 @@
  *    are met.
  *
  * $FreeBSD: src/sys/kern/kern_physio.c,v 1.46.2.4 2003/11/14 09:51:47 simokawa Exp $
- * $DragonFly: src/sys/kern/kern_physio.c,v 1.14 2006/02/17 19:18:06 dillon Exp $
+ * $DragonFly: src/sys/kern/kern_physio.c,v 1.15 2006/03/24 18:35:33 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -45,7 +45,6 @@ physio(dev_t dev, struct uio *uio, int ioflag)
        int error;
        int chk_blockno;
        caddr_t sa;
-       off_t blockno;
        u_int iolen;
        struct buf *bp;
 
@@ -98,17 +97,6 @@ physio(dev_t dev, struct uio *uio, int ioflag)
                        }
                        bp->b_bufsize = bp->b_bcount;
 
-                       /*
-                        * XXX we shouldn't have to set the block
-                        * number.
-                        */
-                       blockno = bp->b_bio1.bio_offset >> DEV_BSHIFT;
-                       if (chk_blockno && (daddr_t)blockno != blockno) {
-                               error = EINVAL; /* blockno overflow */
-                               goto doerror;
-                       }
-                       bp->b_bio1.bio_blkno = blockno;
-
                        if (uio->uio_segflg == UIO_USERSPACE) {
                                if (vmapbuf(bp) < 0) {
                                        error = EFAULT;
index 1f8b307..c054ba9 100644 (file)
@@ -37,7 +37,7 @@
  *
  *     @(#)kern_shutdown.c     8.3 (Berkeley) 1/21/94
  * $FreeBSD: src/sys/kern/kern_shutdown.c,v 1.72.2.12 2002/02/21 19:15:10 dillon Exp $
- * $DragonFly: src/sys/kern/kern_shutdown.c,v 1.26 2006/03/07 15:48:11 corecode Exp $
+ * $DragonFly: src/sys/kern/kern_shutdown.c,v 1.27 2006/03/24 18:35:33 dillon Exp $
  */
 
 #include "opt_ddb.h"
@@ -325,10 +325,10 @@ boot(int howto)
                                nbusy++;
 #if defined(SHOW_BUSYBUFS) || defined(DIAGNOSTIC)
                                printf(
-                           "%p %d: dev:?, flags:%08lx, blkno:%ld, lblkno:%ld\n",
+                           "%p %d: dev:?, flags:%08lx, loffset:%lld, doffset:%lld\n",
                                    bp, nbusy,
-                                   bp->b_flags, (long)bp->b_bio1.bio_blkno,
-                                   (long)bp->b_lblkno);
+                                   bp->b_flags, bp->b_loffset,
+                                   bp->b_bio2.bio_offset);
 #endif
                        }
                }
index 63128a6..16ed7af 100644 (file)
@@ -77,7 +77,7 @@
  *     @(#)ufs_disksubr.c      8.5 (Berkeley) 1/21/94
  * $FreeBSD: src/sys/kern/subr_disk.c,v 1.20.2.6 2001/10/05 07:14:57 peter Exp $
  * $FreeBSD: src/sys/ufs/ufs/ufs_disksubr.c,v 1.44.2.3 2001/03/05 05:42:19 obrien Exp $
- * $DragonFly: src/sys/kern/subr_disk.c,v 1.21 2006/02/17 19:18:06 dillon Exp $
+ * $DragonFly: src/sys/kern/subr_disk.c,v 1.22 2006/03/24 18:35:33 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -469,7 +469,7 @@ diskstrategy(dev_t dev, struct bio *bio)
 
        /*
         * The dscheck() function will also transform the slice relative
-        * block number i.e. bio->bio_blkno into a block number that can be
+        * block number i.e. bio->bio_offset into a block number that can be
         * passed directly to the underlying raw device.
         */
        nbio = dscheck(dev, bio, dp->d_slice);
@@ -580,8 +580,7 @@ bioqdisksort(struct bio_queue_head *bioq, struct bio *bio)
                 * "locked" portion of the list, then we must add ourselves
                 * to the second request list.
                 */
-               if (bio->bio_blkno < bioq->last_blkno) {
-
+               if (bio->bio_offset < bioq->last_offset) {
                        bq = bioq->switch_point;
                        /*
                         * If we are starting a new secondary list,
@@ -597,7 +596,7 @@ bioqdisksort(struct bio_queue_head *bioq, struct bio *bio)
                         * insert us before the switch point and move
                         * the switch point.
                         */
-                       if (bio->bio_blkno < bq->bio_blkno) {
+                       if (bio->bio_offset < bq->bio_offset) {
                                bioq->switch_point = bio;
                                TAILQ_INSERT_BEFORE(bq, bio, bio_act);
                                return;
@@ -607,10 +606,10 @@ bioqdisksort(struct bio_queue_head *bioq, struct bio *bio)
                                be = TAILQ_PREV(bioq->switch_point,
                                                bio_queue, bio_act);
                        /*
-                        * If we lie between last_blkno and bq,
+                        * If we lie between last_offset and bq,
                         * insert before bq.
                         */
-                       if (bio->bio_blkno < bq->bio_blkno) {
+                       if (bio->bio_offset < bq->bio_offset) {
                                TAILQ_INSERT_BEFORE(bq, bio, bio_act);
                                return;
                        }
@@ -621,7 +620,7 @@ bioqdisksort(struct bio_queue_head *bioq, struct bio *bio)
         * Request is at/after our current position in the list.
         * Optimize for sequential I/O by seeing if we go at the tail.
         */
-       if (bio->bio_blkno > be->bio_blkno) {
+       if (bio->bio_offset > be->bio_offset) {
                TAILQ_INSERT_AFTER(&bioq->queue, be, bio, bio_act);
                return;
        }
@@ -635,7 +634,7 @@ bioqdisksort(struct bio_queue_head *bioq, struct bio *bio)
                 * larger cylinder than our request.
                 */
                if (bn == bioq->switch_point
-                || bio->bio_blkno < bn->bio_blkno)
+                || bio->bio_offset < bn->bio_offset)
                        break;
                bq = bn;
        }
@@ -658,7 +657,7 @@ readdisklabel(dev_t dev, struct disklabel *lp)
        char *msg = NULL;
 
        bp = geteblk((int)lp->d_secsize);
-       bp->b_bio1.bio_blkno = LABELSECTOR * ((int)lp->d_secsize/DEV_BSIZE);
+       bp->b_bio1.bio_offset = (off_t)LABELSECTOR * lp->d_secsize;
        bp->b_bcount = lp->d_secsize;
        bp->b_flags &= ~B_INVAL;
        bp->b_flags |= B_READ;
@@ -748,7 +747,7 @@ writedisklabel(dev_t dev, struct disklabel *lp)
        if (lp->d_partitions[RAW_PART].p_offset != 0)
                return (EXDEV);                 /* not quite right */
        bp = geteblk((int)lp->d_secsize);
-       bp->b_bio1.bio_blkno = LABELSECTOR * ((int)lp->d_secsize/DEV_BSIZE);
+       bp->b_bio1.bio_offset = (off_t)LABELSECTOR * lp->d_secsize;
        bp->b_bcount = lp->d_secsize;
 #if 1
        /*
@@ -810,7 +809,7 @@ hp0g: hard error reading fsbn 12345 of 12344-12347 (hp0 bn %d cn %d tn %d sn %d)
  */
 void
 diskerr(struct bio *bio, dev_t dev, const char *what, int pri, 
-       int blkdone, struct disklabel *lp)
+       int donecnt, struct disklabel *lp)
 {
        struct buf *bp = bio->bio_buf;
        int unit = dkunit(dev);
@@ -818,36 +817,12 @@ diskerr(struct bio *bio, dev_t dev, const char *what, int pri,
        int part = dkpart(dev);
        char partname[2];
        char *sname;
-       daddr_t sn;
 
        sname = dsname(dev, unit, slice, part, partname);
-       printf("%s%s: %s %sing fsbn ", sname, partname, what,
+       printf("%s%s: %s %sing ", sname, partname, what,
              bp->b_flags & B_READ ? "read" : "writ");
-       sn = bio->bio_blkno;
-       if (bp->b_bcount <= DEV_BSIZE) {
-               printf("%ld", (long)sn);
-       } else {
-               if (blkdone >= 0) {
-                       sn += blkdone;
-                       printf("%ld of ", (long)sn);
-               }
-               printf("%ld-%ld", (long)bio->bio_blkno,
-                   (long)(bio->bio_blkno + (bp->b_bcount - 1) / DEV_BSIZE));
-       }
-       if (lp && (blkdone >= 0 || bp->b_bcount <= lp->d_secsize)) {
-               sn += lp->d_partitions[part].p_offset;
-               /*
-                * XXX should add slice offset and not print the slice,
-                * but we don't know the slice pointer.
-                * XXX should print bio->bio_blkno so that this will work
-                * independent of slices, labels and bad sector remapping,
-                * but some drivers don't set bio->bio_blkno.
-                */
-               printf(" (%s bn %ld; cn %ld", sname, (long)sn,
-                   (long)(sn / lp->d_secpercyl));
-               sn %= (long)lp->d_secpercyl;
-               printf(" tn %ld sn %ld)", (long)(sn / lp->d_nsectors),
-                   (long)(sn % lp->d_nsectors));
-       }
+       printf("offset %012llx for %d", bio->bio_offset, bp->b_bcount);
+       if (donecnt)
+               printf(" (%d bytes completed)", donecnt);
 }
 
index b192d56..1a24769 100644 (file)
@@ -36,7 +36,7 @@
  *     from: @(#)ufs_disksubr.c        7.16 (Berkeley) 5/4/91
  *     from: ufs_disksubr.c,v 1.8 1994/06/07 01:21:39 phk Exp $
  * $FreeBSD: src/sys/kern/subr_diskmbr.c,v 1.45 2000/01/28 10:22:07 bde Exp $
- * $DragonFly: src/sys/kern/subr_diskmbr.c,v 1.11 2006/02/17 19:18:06 dillon Exp $
+ * $DragonFly: src/sys/kern/subr_diskmbr.c,v 1.12 2006/03/24 18:35:33 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -177,14 +177,14 @@ reread_mbr:
        /* Read master boot record. */
        wdev = dkmodpart(dkmodslice(dev, WHOLE_DISK_SLICE), RAW_PART);
        bp = geteblk((int)lp->d_secsize);
-       bp->b_bio1.bio_blkno = mbr_offset;
+       bp->b_bio1.bio_offset = (off_t)mbr_offset * lp->d_secsize;
        bp->b_bcount = lp->d_secsize;
        bp->b_flags |= B_READ;
        dev_dstrategy(wdev, &bp->b_bio1);
        if (biowait(bp) != 0) {
                diskerr(&bp->b_bio1, wdev, 
                        "reading primary partition table: error",
-                       LOG_PRINTF, 0, (struct disklabel *)NULL);
+                       LOG_PRINTF, 0, NULL);
                printf("\n");
                error = EIO;
                goto done;
@@ -386,14 +386,14 @@ mbr_extended(dev_t dev, struct disklabel *lp, struct diskslices *ssp,
 
        /* Read extended boot record. */
        bp = geteblk((int)lp->d_secsize);
-       bp->b_bio1.bio_blkno = ext_offset;
+       bp->b_bio1.bio_offset = (off_t)ext_offset * lp->d_secsize;
        bp->b_bcount = lp->d_secsize;
        bp->b_flags |= B_READ;
        dev_dstrategy(dev, &bp->b_bio1);
        if (biowait(bp) != 0) {
                diskerr(&bp->b_bio1, dev,
                        "reading extended partition table: error",
-                       LOG_PRINTF, 0, (struct disklabel *)NULL);
+                       LOG_PRINTF, 0, NULL);
                printf("\n");
                goto done;
        }
index 4e14d36..5ab5f04 100644 (file)
@@ -44,7 +44,7 @@
  *     from: @(#)ufs_disksubr.c        7.16 (Berkeley) 5/4/91
  *     from: ufs_disksubr.c,v 1.8 1994/06/07 01:21:39 phk Exp $
  * $FreeBSD: src/sys/kern/subr_diskslice.c,v 1.82.2.6 2001/07/24 09:49:41 dd Exp $
- * $DragonFly: src/sys/kern/subr_diskslice.c,v 1.13 2006/02/17 19:18:06 dillon Exp $
+ * $DragonFly: src/sys/kern/subr_diskslice.c,v 1.14 2006/03/24 18:35:33 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -142,7 +142,6 @@ dscheck(dev_t dev, struct bio *bio, struct diskslices *ssp)
 {
        struct buf *bp = bio->bio_buf;
        struct bio *nbio;
-       daddr_t blkno;
        u_long  endsecno;
        daddr_t labelsect;
        struct disklabel *lp;
@@ -152,34 +151,37 @@ dscheck(dev_t dev, struct bio *bio, struct diskslices *ssp)
        daddr_t secno;
        daddr_t slicerel_secno;
        struct diskslice *sp;
+       int shift;
+       int mask;
 
-       blkno = bio->bio_blkno;
-       if (blkno < 0) {
-               printf("dscheck(%s): negative bio_blkno %ld\n", 
-                   devtoname(dev), (long)blkno);
+       if (bio->bio_offset < 0) {
+               printf("dscheck(%s): negative bio_offset %lld\n", 
+                   devtoname(dev), bio->bio_offset);
                bp->b_error = EINVAL;
                goto bad;
        }
        sp = &ssp->dss_slices[dkslice(dev)];
        lp = sp->ds_label;
+
        if (ssp->dss_secmult == 1) {
-               if (bp->b_bcount % (u_long)DEV_BSIZE)
-                       goto bad_bcount;
-               secno = blkno;
-               nsec = bp->b_bcount >> DEV_BSHIFT;
+               shift = DEV_BSHIFT;
+               goto doshift;
        } else if (ssp->dss_secshift != -1) {
-               if (bp->b_bcount & (ssp->dss_secsize - 1))
+               shift = DEV_BSHIFT + ssp->dss_secshift;
+doshift:
+               mask = (1 << shift) - 1;
+               if ((int)bp->b_bcount & mask)
                        goto bad_bcount;
-               if (blkno & (ssp->dss_secmult - 1))
+               if ((int)bio->bio_offset & mask)
                        goto bad_blkno;
-               secno = blkno >> ssp->dss_secshift;
-               nsec = bp->b_bcount >> (DEV_BSHIFT + ssp->dss_secshift);
+               secno = (daddr_t)(bio->bio_offset >> shift);
+               nsec = bp->b_bcount >> shift;
        } else {
                if (bp->b_bcount % ssp->dss_secsize)
                        goto bad_bcount;
-               if (blkno % ssp->dss_secmult)
+               if (bio->bio_offset % ssp->dss_secsize)
                        goto bad_blkno;
-               secno = blkno / ssp->dss_secmult;
+               secno = (daddr_t)(bio->bio_offset / ssp->dss_secsize);
                nsec = bp->b_bcount / ssp->dss_secsize;
        }
        if (lp == NULL) {
@@ -232,7 +234,7 @@ dscheck(dev_t dev, struct bio *bio, struct diskslices *ssp)
        }
 
        nbio = push_bio(bio);
-       nbio->bio_blkno = sp->ds_offset + slicerel_secno;
+       nbio->bio_offset = (off_t)(sp->ds_offset + slicerel_secno) * ssp->dss_secsize;
 
        /*
         * Snoop on label accesses if the slice offset is nonzero.  Fudge
@@ -277,15 +279,15 @@ dscheck(dev_t dev, struct bio *bio, struct diskslices *ssp)
 
 bad_bcount:
        printf(
-       "dscheck(%s): b_bcount %ld is not on a sector boundary (ssize %d)\n",
+       "dscheck(%s): b_bcount %d is not on a sector boundary (ssize %d)\n",
            devtoname(dev), bp->b_bcount, ssp->dss_secsize);
        bp->b_error = EINVAL;
        goto bad;
 
 bad_blkno:
        printf(
-       "dscheck(%s): bio_blkno %ld is not on a sector boundary (ssize %d)\n",
-           devtoname(dev), (long)blkno, ssp->dss_secsize);
+       "dscheck(%s): bio_offset %lld is not on a sector boundary (ssize %d)\n",
+           devtoname(dev), bio->bio_offset, ssp->dss_secsize);
        bp->b_error = EINVAL;
        goto bad;
 
index f745152..b205993 100644 (file)
@@ -14,7 +14,7 @@
  * of the author.  This software is distributed AS-IS.
  *
  * $FreeBSD: src/sys/kern/vfs_aio.c,v 1.70.2.28 2003/05/29 06:15:35 alc Exp $
- * $DragonFly: src/sys/kern/vfs_aio.c,v 1.20 2006/02/17 19:18:06 dillon Exp $
+ * $DragonFly: src/sys/kern/vfs_aio.c,v 1.21 2006/03/24 18:35:33 dillon Exp $
  */
 
 /*
@@ -966,7 +966,7 @@ aio_qphysio(struct proc *p, struct aiocblist *aiocbe)
        bp->b_bio1.bio_done = aio_physwakeup;
        bp->b_saveaddr = bp->b_data;
        bp->b_data = (void *)(uintptr_t)cb->aio_buf;
-       bp->b_bio1.bio_blkno = btodb(cb->aio_offset);
+       bp->b_bio1.bio_offset = cb->aio_offset;
 
        /* Bring buffer into kernel space. */
        if (vmapbuf(bp) < 0) {
index 261df18..1b1fe29 100644 (file)
@@ -12,7 +12,7 @@
  *             John S. Dyson.
  *
  * $FreeBSD: src/sys/kern/vfs_bio.c,v 1.242.2.20 2003/05/28 18:38:10 alc Exp $
- * $DragonFly: src/sys/kern/vfs_bio.c,v 1.58 2006/03/05 18:38:34 dillon Exp $
+ * $DragonFly: src/sys/kern/vfs_bio.c,v 1.59 2006/03/24 18:35:33 dillon Exp $
  */
 
 /*
@@ -442,14 +442,12 @@ initbufbio(struct buf *bp)
 {
        bp->b_bio1.bio_buf = bp;
        bp->b_bio1.bio_prev = NULL;
-       bp->b_bio1.bio_blkno = (daddr_t)-1;
        bp->b_bio1.bio_offset = NOOFFSET;
        bp->b_bio1.bio_next = &bp->b_bio2;
        bp->b_bio1.bio_done = NULL;
 
        bp->b_bio2.bio_buf = bp;
        bp->b_bio2.bio_prev = &bp->b_bio1;
-       bp->b_bio2.bio_blkno = (daddr_t)-1;
        bp->b_bio2.bio_offset = NOOFFSET;
        bp->b_bio2.bio_next = NULL;
        bp->b_bio2.bio_done = NULL;
@@ -466,7 +464,6 @@ reinitbufbio(struct buf *bp)
 
        for (bio = &bp->b_bio1; bio; bio = bio->bio_next) {
                bio->bio_done = NULL;
-               bio->bio_blkno = (daddr_t)-1;
                bio->bio_offset = NOOFFSET;
        }
 }
@@ -490,7 +487,6 @@ push_bio(struct bio *bio)
                bio->bio_next = nbio;
                nbio->bio_prev = bio;
                nbio->bio_buf = bio->bio_buf;
-               nbio->bio_blkno = (daddr_t)-1;
                nbio->bio_offset = NOOFFSET;
                nbio->bio_done = NULL;
                nbio->bio_next = NULL;
@@ -509,7 +505,6 @@ void
 clearbiocache(struct bio *bio)
 {
        while (bio) {
-               bio->bio_blkno = (daddr_t)-1;
                bio->bio_offset = NOOFFSET;
                bio = bio->bio_next;
        }
@@ -600,11 +595,11 @@ bremfree(struct buf * bp)
  *     getblk() ).
  */
 int
-bread(struct vnode * vp, daddr_t blkno, int size, struct buf ** bpp)
+bread(struct vnode * vp, off_t loffset, int size, struct buf ** bpp)
 {
        struct buf *bp;
 
-       bp = getblk(vp, blkno, size, 0, 0);
+       bp = getblk(vp, loffset, size, 0, 0);
        *bpp = bp;
 
        /* if not found in cache, do some I/O */
@@ -628,14 +623,14 @@ bread(struct vnode * vp, daddr_t blkno, int size, struct buf ** bpp)
  *     and we do not have to do anything.
  */
 int
-breadn(struct vnode * vp, daddr_t blkno, int size, daddr_t * rablkno,
+breadn(struct vnode * vp, off_t loffset, int size, off_t *raoffset,
        int *rabsize, int cnt, struct buf ** bpp)
 {
        struct buf *bp, *rabp;
        int i;
        int rv = 0, readwait = 0;
 
-       *bpp = bp = getblk(vp, blkno, size, 0, 0);
+       *bpp = bp = getblk(vp, loffset, size, 0, 0);
 
        /* if not found in cache, do some I/O */
        if ((bp->b_flags & B_CACHE) == 0) {
@@ -646,10 +641,10 @@ breadn(struct vnode * vp, daddr_t blkno, int size, daddr_t * rablkno,
                ++readwait;
        }
 
-       for (i = 0; i < cnt; i++, rablkno++, rabsize++) {
-               if (inmem(vp, *rablkno))
+       for (i = 0; i < cnt; i++, raoffset++, rabsize++) {
+               if (inmem(vp, *raoffset))
                        continue;
-               rabp = getblk(vp, *rablkno, *rabsize, 0, 0);
+               rabp = getblk(vp, *raoffset, *rabsize, 0, 0);
 
                if ((rabp->b_flags & B_CACHE) == 0) {
                        rabp->b_flags |= B_READ | B_ASYNC;
@@ -790,8 +785,8 @@ bdwrite(struct buf *bp)
         * requesting a sync -- there might not be enough memory to do
         * the bmap then...  So, this is important to do.
         */
-       if (bp->b_bio2.bio_blkno == (daddr_t)-1) {
-               VOP_BMAP(bp->b_vp, bp->b_lblkno, NULL, &bp->b_bio2.bio_blkno,
+       if (bp->b_bio2.bio_offset == NOOFFSET) {
+               VOP_BMAP(bp->b_vp, bp->b_loffset, NULL, &bp->b_bio2.bio_offset,
                         NULL, NULL);
        }
 
@@ -1165,7 +1160,7 @@ brelse(struct buf * bp)
                if (bp->b_flags & (B_INVAL | B_RELBUF)) {
 #if 0
                        if (bp->b_vp)
-                               printf("brelse bp %p %08x/%08lx: Warning, caught and fixed brelvp bug\n", bp, saved_flags, bp->b_flags);
+                               printf("brelse bp %p %08x/%08x: Warning, caught and fixed brelvp bug\n", bp, saved_flags, bp->b_flags);
 #endif
                        if (bp->b_bufsize)
                                allocbuf(bp, 0);
@@ -1200,7 +1195,7 @@ brelse(struct buf * bp)
                 */
                bp->b_flags |= B_INVAL;
                bp->b_xflags &= ~BX_BKGRDWRITE;
-               KASSERT(bp->b_vp == NULL, ("bp1 %p flags %08x/%08lx vnode %p unexpectededly still associated!", bp, saved_flags, bp->b_flags, bp->b_vp));
+               KASSERT(bp->b_vp == NULL, ("bp1 %p flags %08x/%08x vnode %p unexpectededly still associated!", bp, saved_flags, bp->b_flags, bp->b_vp));
                KKASSERT((bp->b_flags & B_HASHED) == 0);
                if (bp->b_xflags & BX_BKGRDINPROG)
                        panic("losing buffer 1");
@@ -1215,7 +1210,7 @@ brelse(struct buf * bp)
                 * Buffers with junk contents.   Again these buffers had better
                 * already be disassociated from their vnode.
                 */
-               KASSERT(bp->b_vp == NULL, ("bp2 %p flags %08x/%08lx vnode %p unexpectededly still associated!", bp, saved_flags, bp->b_flags, bp->b_vp));
+               KASSERT(bp->b_vp == NULL, ("bp2 %p flags %08x/%08x vnode %p unexpectededly still associated!", bp, saved_flags, bp->b_flags, bp->b_vp));
                KKASSERT((bp->b_flags & B_HASHED) == 0);
                bp->b_flags |= B_INVAL;
                bp->b_xflags &= ~BX_BKGRDWRITE;
@@ -1436,13 +1431,12 @@ vfs_bio_awrite(struct buf *bp)
 {
        int i;
        int j;
-       daddr_t lblkno = bp->b_lblkno;
+       off_t loffset = bp->b_loffset;
        struct vnode *vp = bp->b_vp;
-       int ncl;
+       int nbytes;
        struct buf *bpa;
        int nwritten;
        int size;
-       int maxcl;
 
        crit_enter();
        /*
@@ -1450,53 +1444,52 @@ vfs_bio_awrite(struct buf *bp)
         * we find a clusterable block we could be in the middle of a cluster
         * rather then at the beginning.
         *
-        * NOTE: b_bio1 contains the logical loffset/lblkno and is aliased
-        * to b_lblkno and b_loffset.  b_bio2 contains the translated block
-        * number.
+        * NOTE: b_bio1 contains the logical loffset and is aliased
+        * to b_loffset.  b_bio2 contains the translated block number.
         */
        if ((vp->v_type == VREG) && 
            (vp->v_mount != 0) && /* Only on nodes that have the size info */
            (bp->b_flags & (B_CLUSTEROK | B_INVAL)) == B_CLUSTEROK) {
 
                size = vp->v_mount->mnt_stat.f_iosize;
-               maxcl = MAXPHYS / size;
 
-               for (i = 1; i < maxcl; i++) {
-                       if ((bpa = findblk(vp, lblkno + i)) &&
+               for (i = size; i < MAXPHYS; i += size) {
+                       if ((bpa = findblk(vp, loffset + i)) &&
                            BUF_REFCNT(bpa) == 0 &&
                            ((bpa->b_flags & (B_DELWRI | B_CLUSTEROK | B_INVAL)) ==
                            (B_DELWRI | B_CLUSTEROK)) &&
                            (bpa->b_bufsize == size)) {
-                               if ((bpa->b_bio2.bio_blkno == (daddr_t)-1) ||
-                                   (bpa->b_bio2.bio_blkno !=
-                                    bp->b_bio2.bio_blkno + ((i * size) >> DEV_BSHIFT)))
+                               if ((bpa->b_bio2.bio_offset == NOOFFSET) ||
+                                   (bpa->b_bio2.bio_offset !=
+                                    bp->b_bio2.bio_offset + i))
                                        break;
                        } else {
                                break;
                        }
                }
-               for (j = 1; i + j <= maxcl && j <= lblkno; j++) {
-                       if ((bpa = findblk(vp, lblkno - j)) &&
+               for (j = size; i + j <= MAXPHYS && j <= loffset; j += size) {
+                       if ((bpa = findblk(vp, loffset - j)) &&
                            BUF_REFCNT(bpa) == 0 &&
                            ((bpa->b_flags & (B_DELWRI | B_CLUSTEROK | B_INVAL)) ==
                            (B_DELWRI | B_CLUSTEROK)) &&
                            (bpa->b_bufsize == size)) {
-                               if ((bpa->b_bio2.bio_blkno == (daddr_t)-1) ||
-                                   (bpa->b_bio2.bio_blkno !=
-                                    bp->b_bio2.bio_blkno - ((j * size) >> DEV_BSHIFT)))
+                               if ((bpa->b_bio2.bio_offset == NOOFFSET) ||
+                                   (bpa->b_bio2.bio_offset !=
+                                    bp->b_bio2.bio_offset - j))
                                        break;
                        } else {
                                break;
                        }
                }
-               --j;
-               ncl = i + j;
+               j -= size;
+               nbytes = (i + j);
                /*
                 * this is a possible cluster write
                 */
-               if (ncl != 1) {
+               if (nbytes != size) {
                        BUF_UNLOCK(bp);
-                       nwritten = cluster_wbuild(vp, size, lblkno - j, ncl);
+                       nwritten = cluster_wbuild(vp, size,
+                                                 loffset - j, nbytes);
                        crit_exit();
                        return nwritten;
                }
@@ -1690,7 +1683,7 @@ restart:
                 * valid after this operation.
                 */
 
-               KASSERT(bp->b_vp == NULL, ("bp3 %p flags %08lx vnode %p qindex %d unexpectededly still associated!", bp, bp->b_flags, bp->b_vp, qindex));
+               KASSERT(bp->b_vp == NULL, ("bp3 %p flags %08x vnode %p qindex %d unexpectededly still associated!", bp, bp->b_flags, bp->b_vp, qindex));
                KKASSERT((bp->b_flags & B_HASHED) == 0);
                if (LIST_FIRST(&bp->b_dep) != NULL && bioops.io_deallocate)
                        (*bioops.io_deallocate)(bp);
@@ -1971,14 +1964,13 @@ flushbufqueues(void)
  *     be any more valid then otherwise once we exit the critical section.
  */
 int
-inmem(struct vnode * vp, daddr_t blkno)
+inmem(struct vnode *vp, off_t loffset)
 {
        vm_object_t obj;
        vm_offset_t toff, tinc, size;
        vm_page_t m;
-       vm_ooffset_t off;
 
-       if (findblk(vp, blkno))
+       if (findblk(vp, loffset))
                return 1;
        if (vp->v_mount == NULL)
                return 0;
@@ -1988,17 +1980,16 @@ inmem(struct vnode * vp, daddr_t blkno)
        size = PAGE_SIZE;
        if (size > vp->v_mount->mnt_stat.f_iosize)
                size = vp->v_mount->mnt_stat.f_iosize;
-       off = (vm_ooffset_t)blkno * (vm_ooffset_t)vp->v_mount->mnt_stat.f_iosize;
 
        for (toff = 0; toff < vp->v_mount->mnt_stat.f_iosize; toff += tinc) {
-               m = vm_page_lookup(obj, OFF_TO_IDX(off + toff));
-               if (!m)
+               m = vm_page_lookup(obj, OFF_TO_IDX(loffset + toff));
+               if (m == NULL)
                        return 0;
                tinc = size;
-               if (tinc > PAGE_SIZE - ((toff + off) & PAGE_MASK))
-                       tinc = PAGE_SIZE - ((toff + off) & PAGE_MASK);
+               if (tinc > PAGE_SIZE - ((toff + loffset) & PAGE_MASK))
+                       tinc = PAGE_SIZE - ((toff + loffset) & PAGE_MASK);
                if (vm_page_is_valid(m,
-                   (vm_offset_t) ((toff + off) & PAGE_MASK), tinc) == 0)
+                   (vm_offset_t) ((toff + loffset) & PAGE_MASK), tinc) == 0)
                        return 0;
        }
        return 1;
@@ -2105,12 +2096,12 @@ vfs_setdirty(struct buf *bp)
  *     obtain after locking it.
  */
 struct buf *
-findblk(struct vnode *vp, daddr_t blkno)
+findblk(struct vnode *vp, off_t loffset)
 {
        struct buf *bp;
 
        crit_enter();
-       bp = buf_rb_hash_RB_LOOKUP(&vp->v_rbhash_tree, blkno);
+       bp = buf_rb_hash_RB_LOOKUP(&vp->v_rbhash_tree, loffset);
        crit_exit();
        return(bp);
 }
@@ -2159,7 +2150,7 @@ findblk(struct vnode *vp, daddr_t blkno)
  *     prior to issuing the READ.  biodone() will *not* clear B_INVAL.
  */
 struct buf *
-getblk(struct vnode *vp, daddr_t blkno, int size, int slpflag, int slptimeo)
+getblk(struct vnode *vp, off_t loffset, int size, int slpflag, int slptimeo)
 {
        struct buf *bp;
 
@@ -2186,7 +2177,7 @@ loop:
                tsleep(&needsbuffer, slpflag, "newbuf", slptimeo);
        }
 
-       if ((bp = findblk(vp, blkno))) {
+       if ((bp = findblk(vp, loffset))) {
                /*
                 * The buffer was found in the cache, but we need to lock it.
                 * Even with LK_NOWAIT the lockmgr may break our critical
@@ -2211,8 +2202,8 @@ loop:
                 * will have b_vp == NULL, so this takes care of that check
                 * as well.
                 */
-               if (bp->b_vp != vp || bp->b_lblkno != blkno) {
-                       printf("Warning buffer %p (vp %p lblkno %d) was recycled\n", bp, vp, (int)blkno);
+               if (bp->b_vp != vp || bp->b_loffset != loffset) {
+                       printf("Warning buffer %p (vp %p loffset %lld) was recycled\n", bp, vp, loffset);
                        BUF_UNLOCK(bp);
                        goto loop;
                }
@@ -2221,8 +2212,8 @@ loop:
                 * Make sure that B_INVAL buffers do not have a cached
                 * block number translation.
                 */
-               if ((bp->b_flags & B_INVAL) && (bp->b_bio2.bio_blkno != (daddr_t)-1)) {
-                       printf("Warning invalid buffer %p (vp %p lblkno %d) did not have cleared bio_blkno cache\n", bp, vp, (int)blkno);
+               if ((bp->b_flags & B_INVAL) && (bp->b_bio2.bio_offset != NOOFFSET)) {
+                       printf("Warning invalid buffer %p (vp %p loffset %lld) did not have cleared bio_offset cache\n", bp, vp, loffset);
                        clearbiocache(&bp->b_bio2);
                }
 
@@ -2333,7 +2324,6 @@ loop:
                 * non-NULL v_mountedhere) is not a special case.
                 */
                int bsize, maxsize, vmio;
-               off_t offset;
 
                if (vp->v_type == VBLK || vp->v_type == VCHR)
                        bsize = DEV_BSIZE;
@@ -2342,9 +2332,8 @@ loop:
                else
                        bsize = size;
 
-               offset = (off_t)blkno * bsize;
                vmio = (VOP_GETVOBJECT(vp, NULL) == 0) && (vp->v_flag & VOBJBUF);
-               maxsize = vmio ? size + (offset & PAGE_MASK) : size;
+               maxsize = vmio ? size + (loffset & PAGE_MASK) : size;
                maxsize = imax(maxsize, bsize);
 
                if ((bp = getnewbuf(slpflag, slptimeo, size, maxsize)) == NULL) {
@@ -2365,7 +2354,7 @@ loop:
                 * from the point of the duplicate buffer creation through
                 * to here, and we've locked the buffer.
                 */
-               if (findblk(vp, blkno)) {
+               if (findblk(vp, loffset)) {
                        bp->b_flags |= B_INVAL;
                        brelse(bp);
                        goto loop;
@@ -2377,9 +2366,8 @@ loop:
                 *
                 * Make sure the translation layer has been cleared.
                 */
-               bp->b_lblkno = blkno;
-               bp->b_loffset = offset;
-               bp->b_bio2.bio_blkno = (daddr_t)-1;
+               bp->b_loffset = loffset;
+               bp->b_bio2.bio_offset = NOOFFSET;
                /* bp->b_bio2.bio_next = NULL; */
 
                bgetvp(vp, bp);
@@ -2984,13 +2972,13 @@ biodone(struct bio *bio)
                                    (int) m->pindex, (int)(foff >> 32),
                                                (int) foff & 0xffffffff, resid, i);
                                if (!vn_isdisk(vp, NULL))
-                                       printf(" iosize: %ld, lblkno: %d, flags: 0x%lx, npages: %d\n",
+                                       printf(" iosize: %ld, loffset: %lld, flags: 0x%08x, npages: %d\n",
                                            bp->b_vp->v_mount->mnt_stat.f_iosize,
-                                           (int) bp->b_lblkno,
+                                           bp->b_loffset,
                                            bp->b_flags, bp->b_xio.xio_npages);
                                else
-                                       printf(" VDEV, lblkno: %d, flags: 0x%lx, npages: %d\n",
-                                           (int) bp->b_lblkno,
+                                       printf(" VDEV, loffset: %lld, flags: 0x%08x, npages: %d\n",
+                                           bp->b_loffset,
                                            bp->b_flags, bp->b_xio.xio_npages);
                                printf(" valid: 0x%x, dirty: 0x%x, wired: %d\n",
                                    m->valid, m->dirty, m->wire_count);
@@ -3402,8 +3390,8 @@ vm_hold_free_pages(struct buf *bp, vm_offset_t from, vm_offset_t to)
                p = bp->b_xio.xio_pages[index];
                if (p && (index < bp->b_xio.xio_npages)) {
                        if (p->busy) {
-                               printf("vm_hold_free_pages: blkno: %d, lblkno: %d\n",
-                                       bp->b_bio2.bio_blkno, bp->b_lblkno);
+                               printf("vm_hold_free_pages: doffset: %lld, loffset: %lld\n",
+                                       bp->b_bio2.bio_offset, bp->b_loffset);
                        }
                        bp->b_xio.xio_pages[index] = NULL;
                        pmap_kremove(pg);
@@ -3559,11 +3547,11 @@ DB_SHOW_COMMAND(buffer, db_show_buffer)
        }
 
        db_printf("b_flags = 0x%b\n", (u_int)bp->b_flags, PRINT_BUF_FLAGS);
-       db_printf("b_error = %d, b_bufsize = %ld, b_bcount = %ld, "
-                 "b_resid = %ld\n, b_data = %p, "
-                 "bio_blkno(disk) = %d, bio_blkno(phys) = %d\n",
+       db_printf("b_error = %d, b_bufsize = %d, b_bcount = %d, "
+                 "b_resid = %d\n, b_data = %p, "
+                 "bio_offset(disk) = %lld, bio_offset(phys) = %lld\n",
                  bp->b_error, bp->b_bufsize, bp->b_bcount, bp->b_resid,
-                 bp->b_data, bp->b_bio2.bio_blkno, (bp->b_bio2.bio_next ? bp->b_bio2.bio_next->bio_blkno : (daddr_t)-1));
+                 bp->b_data, bp->b_bio2.bio_offset, (bp->b_bio2.bio_next ? bp->b_bio2.bio_next->bio_offset : (off_t)-1));
        if (bp->b_xio.xio_npages) {
                int i;
                db_printf("b_xio.xio_npages = %d, pages(OBJ, IDX, PA): ",
index f605489..a9c541f 100644 (file)
@@ -34,7 +34,7 @@
  *
  *     @(#)vfs_cluster.c       8.7 (Berkeley) 2/13/94
  * $FreeBSD: src/sys/kern/vfs_cluster.c,v 1.92.2.9 2001/11/18 07:10:59 dillon Exp $
- * $DragonFly: src/sys/kern/vfs_cluster.c,v 1.18 2006/03/10 17:51:54 dillon Exp $
+ * $DragonFly: src/sys/kern/vfs_cluster.c,v 1.19 2006/03/24 18:35:33 dillon Exp $
  */
 
 #include "opt_debug_cluster.h"
@@ -65,10 +65,11 @@ SYSCTL_INT(_debug, OID_AUTO, rcluster, CTLFLAG_RW, &rcluster, 0, "");
 static MALLOC_DEFINE(M_SEGMENT, "cluster_save", "cluster_save buffer");
 
 static struct cluster_save *
-       cluster_collectbufs (struct vnode *vp, struct buf *last_bp);
+       cluster_collectbufs (struct vnode *vp, struct buf *last_bp,
+                           int lblocksize);
 static struct buf *
-       cluster_rbuild (struct vnode *vp, u_quad_t filesize, daddr_t lbn,
-                           daddr_t blkno, long size, int run, struct buf *fbp);
+       cluster_rbuild (struct vnode *vp, off_t filesize, off_t loffset,
+                           off_t doffset, int size, int run, struct buf *fbp);
 static void cluster_callback (struct bio *);
 
 
@@ -88,15 +89,15 @@ extern int cluster_pbuf_freecnt;
  * This replaces bread.
  */
 int
-cluster_read(struct vnode *vp, u_quad_t filesize, daddr_t lblkno
-       long size, long totread, int seqcount, struct buf **bpp)
+cluster_read(struct vnode *vp, off_t filesize, off_t loffset
+            int size, int totread, int seqcount, struct buf **bpp)
 {
        struct buf *bp, *rbp, *reqbp;
-       daddr_t blkno, origblkno;
-       int error, num_ra;
+       off_t origoffset;
+       off_t doffset;
+       int error;
        int i;
        int maxra, racluster;
-       long origtotread;
 
        error = 0;
 
@@ -114,9 +115,8 @@ cluster_read(struct vnode *vp, u_quad_t filesize, daddr_t lblkno,
        /*
         * get the requested block
         */
-       *bpp = reqbp = bp = getblk(vp, lblkno, size, 0, 0);
-       origblkno = lblkno;
-       origtotread = totread;
+       *bpp = reqbp = bp = getblk(vp, loffset, size, 0, 0);
+       origoffset = loffset;
 
        /*
         * if it is in the cache, then check to see if the reads have been
@@ -139,8 +139,7 @@ cluster_read(struct vnode *vp, u_quad_t filesize, daddr_t lblkno,
                         */
                        crit_enter();
                        for (i = 1; i < maxra; i++) {
-
-                               if (!(tbp = findblk(vp, lblkno+i))) {
+                               if (!(tbp = findblk(vp, loffset + i * size))) {
                                        break;
                                }
 
@@ -156,42 +155,38 @@ cluster_read(struct vnode *vp, u_quad_t filesize, daddr_t lblkno,
                        if (i >= maxra) {
                                return 0;
                        }
-                       lblkno += i;
+                       loffset += i * size;
                }
                reqbp = bp = NULL;
        } else {
                off_t firstread = bp->b_loffset;
+               int nblks;
 
                KASSERT(firstread != NOOFFSET, 
                        ("cluster_read: no buffer offset"));
                if (firstread + totread > filesize)
-                       totread = filesize - firstread;
-               if (totread > size) {
-                       int nblks = 0;
-                       int ncontigafter;
-                       while (totread > 0) {
-                               nblks++;
-                               totread -= size;
-                       }
-                       if (nblks == 1)
-                               goto single_block_read;
+                       totread = (int)(filesize - firstread);
+               nblks = totread / size;
+               if (nblks) {
+                       int burstbytes;
+
                        if (nblks > racluster)
                                nblks = racluster;
 
-                       error = VOP_BMAP(vp, lblkno, NULL,
-                                        &blkno, &ncontigafter, NULL);
+                       error = VOP_BMAP(vp, loffset, NULL,
+                                        &doffset, &burstbytes, NULL);
                        if (error)
                                goto single_block_read;
-                       if (blkno == -1)
+                       if (doffset == NOOFFSET)
                                goto single_block_read;
-                       if (ncontigafter == 0)
+                       if (burstbytes < size * 2)
                                goto single_block_read;
-                       if (ncontigafter + 1 < nblks)
-                               nblks = ncontigafter + 1;
+                       if (nblks > burstbytes / size)
+                               nblks = burstbytes / size;
 
-                       bp = cluster_rbuild(vp, filesize, lblkno,
-                                           blkno, size, nblks, bp);
-                       lblkno += (bp->b_bufsize / size);
+                       bp = cluster_rbuild(vp, filesize, loffset,
+                                           doffset, size, nblks, bp);
+                       loffset += bp->b_bufsize;
                } else {
 single_block_read:
                        /*
@@ -199,7 +194,7 @@ single_block_read:
                         * disk if sequential, otherwise just get the block.
                         */
                        bp->b_flags |= B_READ | B_RAM;
-                       lblkno += 1;
+                       loffset += size;
                }
        }
 
@@ -208,35 +203,37 @@ single_block_read:
         */
        rbp = NULL;
        if (seqcount &&
-           lblkno < origblkno + seqcount &&
-           (u_quad_t)(lblkno + 1) * size <= filesize
+           loffset < origoffset + seqcount * size &&
+           loffset + size <= filesize
        ) {
-               rbp = getblk(vp, lblkno, size, 0, 0);
+               rbp = getblk(vp, loffset, size, 0, 0);
                if ((rbp->b_flags & B_CACHE) == 0) {
                        int nblksread;
                        int ntoread;
+                       int burstbytes;
 
-                       error = VOP_BMAP(vp, lblkno, NULL,
-                                        &blkno, &num_ra, NULL);
-                       if (error || blkno == (daddr_t)-1) {
+                       error = VOP_BMAP(vp, loffset, NULL,
+                                        &doffset, &burstbytes, NULL);
+                       if (error || doffset == NOOFFSET) {
                                rbp->b_flags &= ~(B_ASYNC | B_READ);
                                brelse(rbp);
                                rbp = NULL;
                                goto no_read_ahead;
                        }
-                       ntoread = num_ra + 1;
-                       nblksread = (origtotread + size - 1) / size;
+                       ntoread = burstbytes / size;
+                       nblksread = (totread + size - 1) / size;
                        if (seqcount < nblksread)
                                seqcount = nblksread;
                        if (seqcount < ntoread)
                                ntoread = seqcount;
 
                        rbp->b_flags |= B_READ | B_ASYNC | B_RAM;
-                       if (num_ra) {
-                               rbp = cluster_rbuild(vp, filesize, lblkno,
-                                                    blkno, size, ntoread, rbp);
+                       if (burstbytes) {
+                               rbp = cluster_rbuild(vp, filesize, loffset,
+                                                    doffset, size, 
+                                                    ntoread, rbp);
                        } else {
-                               rbp->b_bio2.bio_blkno = blkno;
+                               rbp->b_bio2.bio_offset = doffset;
                        }
                }
        }
@@ -248,8 +245,8 @@ no_read_ahead:
        if (bp) {
 #if defined(CLUSTERDEBUG)
                if (rcluster)
-                       printf("S(%ld,%ld,%d) ",
-                           (long)bp->b_lblkno, bp->b_bcount, seqcount);
+                       printf("S(%lld,%ld,%d) ",
+                           bp->b_loffset, bp->b_bcount, seqcount);
 #endif
                if ((bp->b_flags & B_CLUSTER) == 0) {
                        vfs_busy_pages(bp, 0);
@@ -275,14 +272,14 @@ no_read_ahead:
 #if defined(CLUSTERDEBUG)
                        if (rcluster) {
                                if (bp)
-                                       printf("A+(%ld,%ld,%ld,%d) ",
-                                           (long)rbp->b_lblkno, rbp->b_bcount,
-                                           (long)(rbp->b_lblkno - origblkno),
+                                       printf("A+(%lld,%ld,%lld,%d) ",
+                                           rbp->b_loffset, rbp->b_bcount,
+                                           rbp->b_loffset - origoffset,
                                            seqcount);
                                else
-                                       printf("A(%ld,%ld,%ld,%d) ",
-                                           (long)rbp->b_lblkno, rbp->b_bcount,
-                                           (long)(rbp->b_lblkno - origblkno),
+                                       printf("A(%lld,%ld,%lld,%d) ",
+                                           rbp->b_loffset, rbp->b_bcount,
+                                           rbp->b_loffset - origoffset,
                                            seqcount);
                        }
 #endif
@@ -308,27 +305,27 @@ no_read_ahead:
  * and then parcel them up into logical blocks in the buffer hash table.
  */
 static struct buf *
-cluster_rbuild(struct vnode *vp, u_quad_t filesize, daddr_t lbn
-       daddr_t blkno, long size, int run, struct buf *fbp)
+cluster_rbuild(struct vnode *vp, off_t filesize, off_t loffset
+       off_t doffset, int size, int run, struct buf *fbp)
 {
        struct buf *bp, *tbp;
-       daddr_t bn;
-       int i, inc, j;
+       off_t boffset;
+       int i, j;
 
        KASSERT(size == vp->v_mount->mnt_stat.f_iosize,
-           ("cluster_rbuild: size %ld != filesize %ld\n",
+           ("cluster_rbuild: size %d != filesize %ld\n",
            size, vp->v_mount->mnt_stat.f_iosize));
 
        /*
         * avoid a division
         */
-       while ((u_quad_t) size * (lbn + run) > filesize) {
+       while (loffset + run * size > filesize) {
                --run;
        }
 
        tbp = fbp;
        tbp->b_flags |= B_READ; 
-       tbp->b_bio2.bio_blkno = blkno;
+       tbp->b_bio2.bio_offset = doffset;
        if( (tbp->b_flags & B_MALLOC) ||
                ((tbp->b_flags & B_VMIO) == 0) || (run <= 1) )
                return tbp;
@@ -349,9 +346,8 @@ cluster_rbuild(struct vnode *vp, u_quad_t filesize, daddr_t lbn,
        bp->b_bio1.bio_done = cluster_callback;
        bp->b_bio1.bio_caller_info1.cluster_head = NULL;
        bp->b_bio1.bio_caller_info2.cluster_tail = NULL;
-       bp->b_lblkno = lbn;
-       bp->b_loffset = tbp->b_loffset;
-       bp->b_bio2.bio_blkno = (daddr_t)-1;
+       bp->b_loffset = loffset;
+       bp->b_bio2.bio_offset = NOOFFSET;
        KASSERT(bp->b_loffset != NOOFFSET,
                ("cluster_rbuild: no buffer offset"));
        pbgetvp(vp, bp);
@@ -360,8 +356,7 @@ cluster_rbuild(struct vnode *vp, u_quad_t filesize, daddr_t lbn,
        bp->b_bufsize = 0;
        bp->b_xio.xio_npages = 0;
 
-       inc = btodb(size);
-       for (bn = blkno, i = 0; i < run; ++i, bn += inc) {
+       for (boffset = doffset, i = 0; i < run; ++i, boffset += size) {
                if (i != 0) {
                        if ((bp->b_xio.xio_npages * PAGE_SIZE) +
                            round_page(size) > vp->v_mount->mnt_iosize_max) {
@@ -373,7 +368,7 @@ cluster_rbuild(struct vnode *vp, u_quad_t filesize, daddr_t lbn,
                         * would block in the lock.  The same checks have to
                         * be made again after we officially get the buffer.
                         */
-                       if ((tbp = findblk(vp, lbn + i)) != NULL) {
+                       if ((tbp = findblk(vp, loffset + i * size)) != NULL) {
                                if (BUF_LOCK(tbp, LK_EXCLUSIVE | LK_NOWAIT))
                                        break;
                                BUF_UNLOCK(tbp);
@@ -390,7 +385,7 @@ cluster_rbuild(struct vnode *vp, u_quad_t filesize, daddr_t lbn,
                                        break;
                        }
 
-                       tbp = getblk(vp, lbn + i, size, 0, 0);
+                       tbp = getblk(vp, loffset + i * size, size, 0, 0);
 
                        /*
                         * Stop scanning if the buffer is fuly valid 
@@ -433,9 +428,9 @@ cluster_rbuild(struct vnode *vp, u_quad_t filesize, daddr_t lbn,
                         * expect.
                         */
                        tbp->b_flags |= B_READ | B_ASYNC;
-                       if (tbp->b_bio2.bio_blkno == (daddr_t)-1) {
-                               tbp->b_bio2.bio_blkno = bn;
-                       } else if (tbp->b_bio2.bio_blkno != bn) {
+                       if (tbp->b_bio2.bio_offset == NOOFFSET) {
+                               tbp->b_bio2.bio_offset = boffset;
+                       } else if (tbp->b_bio2.bio_offset != boffset) {
                                brelse(tbp);
                                break;
                        }
@@ -446,7 +441,7 @@ cluster_rbuild(struct vnode *vp, u_quad_t filesize, daddr_t lbn,
                 */
                BUF_KERNPROC(tbp);
                cluster_append(&bp->b_bio1, tbp);
-               for (j = 0; j < tbp->b_xio.xio_npages; j += 1) {
+               for (j = 0; j < tbp->b_xio.xio_npages; ++j) {
                        vm_page_t m;
                        m = tbp->b_xio.xio_pages[j];
                        vm_page_io_start(m);
@@ -468,9 +463,9 @@ cluster_rbuild(struct vnode *vp, u_quad_t filesize, daddr_t lbn,
                 * 'size'.
                 */
                if (tbp->b_bcount != size)
-                   printf("warning: tbp->b_bcount wrong %ld vs %ld\n", tbp->b_bcount, size);
+                   printf("warning: tbp->b_bcount wrong %d vs %d\n", tbp->b_bcount, size);
                if (tbp->b_bufsize != size)
-                   printf("warning: tbp->b_bufsize wrong %ld vs %ld\n", tbp->b_bufsize, size);
+                   printf("warning: tbp->b_bufsize wrong %d vs %d\n", tbp->b_bufsize, size);
                bp->b_bcount += size;
                bp->b_bufsize += size;
        }
@@ -486,7 +481,7 @@ cluster_rbuild(struct vnode *vp, u_quad_t filesize, daddr_t lbn,
                }
        }
        if (bp->b_bufsize > bp->b_kvasize)
-               panic("cluster_rbuild: b_bufsize(%ld) > b_kvasize(%d)",
+               panic("cluster_rbuild: b_bufsize(%d) > b_kvasize(%d)",
                    bp->b_bufsize, bp->b_kvasize);
        bp->b_kvasize = bp->b_bufsize;
 
@@ -556,18 +551,18 @@ cluster_callback(struct bio *bio)
  */
 
 static __inline int
-cluster_wbuild_wb(struct vnode *vp, long size, daddr_t start_lbn, int len)
+cluster_wbuild_wb(struct vnode *vp, int size, off_t start_loffset, int len)
 {
        int r = 0;
 
        switch(write_behind) {
        case 2:
-               if (start_lbn < len)
+               if (start_loffset < len)
                        break;
-               start_lbn -= len;
+               start_loffset -= len;
                /* fall through */
        case 1:
-               r = cluster_wbuild(vp, size, start_lbn, len);
+               r = cluster_wbuild(vp, size, start_loffset, len);
                /* fall through */
        default:
                /* fall through */
@@ -587,10 +582,10 @@ cluster_wbuild_wb(struct vnode *vp, long size, daddr_t start_lbn, int len)
  *     4.      end of a cluster - asynchronously write cluster
  */
 void
-cluster_write(struct buf *bp, u_quad_t filesize, int seqcount)
+cluster_write(struct buf *bp, off_t filesize, int seqcount)
 {
        struct vnode *vp;
-       daddr_t lbn;
+       off_t loffset;
        int maxclen, cursize;
        int lblocksize;
        int async;
@@ -603,18 +598,18 @@ cluster_write(struct buf *bp, u_quad_t filesize, int seqcount)
                async = 0;
                lblocksize = bp->b_bufsize;
        }
-       lbn = bp->b_lblkno;
+       loffset = bp->b_loffset;
        KASSERT(bp->b_loffset != NOOFFSET, 
                ("cluster_write: no buffer offset"));
 
        /* Initialize vnode to beginning of file. */
-       if (lbn == 0)
+       if (loffset == 0)
                vp->v_lasta = vp->v_clen = vp->v_cstart = vp->v_lastw = 0;
 
-       if (vp->v_clen == 0 || lbn != vp->v_lastw + 1 ||
-           bp->b_bio2.bio_blkno == (daddr_t)-1 ||
-           (bp->b_bio2.bio_blkno != vp->v_lasta + btodb(lblocksize))) {
-               maxclen = vp->v_mount->mnt_iosize_max / lblocksize - 1;
+       if (vp->v_clen == 0 || loffset != vp->v_lastw + lblocksize ||
+           bp->b_bio2.bio_offset == NOOFFSET ||
+           (bp->b_bio2.bio_offset != vp->v_lasta + lblocksize)) {
+               maxclen = vp->v_mount->mnt_iosize_max;
                if (vp->v_clen != 0) {
                        /*
                         * Next block is not sequential.
@@ -632,9 +627,9 @@ cluster_write(struct buf *bp, u_quad_t filesize, int seqcount)
                         * later on in the buf_daemon or update daemon
                         * flush.
                         */
-                       cursize = vp->v_lastw - vp->v_cstart + 1;
-                       if (((u_quad_t) bp->b_loffset + lblocksize) != filesize ||
-                           lbn != vp->v_lastw + 1 || vp->v_clen <= cursize) {
+                       cursize = vp->v_lastw - vp->v_cstart + lblocksize;
+                       if (bp->b_loffset + lblocksize != filesize ||
+                           loffset != vp->v_lastw + lblocksize || vp->v_clen <= cursize) {
                                if (!async && seqcount > 0) {
                                        cluster_wbuild_wb(vp, lblocksize,
                                                vp->v_cstart, cursize);
@@ -643,7 +638,8 @@ cluster_write(struct buf *bp, u_quad_t filesize, int seqcount)
                                struct buf **bpp, **endbp;
                                struct cluster_save *buflist;
 
-                               buflist = cluster_collectbufs(vp, bp);
+                               buflist = cluster_collectbufs(vp, bp,
+                                                             lblocksize);
                                endbp = &buflist->bs_children
                                    [buflist->bs_nchildren - 1];
                                if (VOP_REALLOCBLKS(vp, buflist)) {
@@ -672,8 +668,8 @@ cluster_write(struct buf *bp, u_quad_t filesize, int seqcount)
                                             bpp <= endbp; bpp++)
                                                bdwrite(*bpp);
                                        free(buflist, M_SEGMENT);
-                                       vp->v_lastw = lbn;
-                                       vp->v_lasta = bp->b_bio2.bio_blkno;
+                                       vp->v_lastw = loffset;
+                                       vp->v_lasta = bp->b_bio2.bio_offset;
                                        return;
                                }
                        }
@@ -684,26 +680,29 @@ cluster_write(struct buf *bp, u_quad_t filesize, int seqcount)
                 * existing cluster.
                 */
                if ((vp->v_type == VREG) &&
-                       ((u_quad_t) bp->b_loffset + lblocksize) != filesize &&
-                   (bp->b_bio2.bio_blkno == (daddr_t)-1) &&
-                   (VOP_BMAP(vp, lbn, NULL, &bp->b_bio2.bio_blkno, &maxclen, NULL) ||
-                    bp->b_bio2.bio_blkno == (daddr_t)-1)) {
+                   bp->b_loffset + lblocksize != filesize &&
+                   (bp->b_bio2.bio_offset == NOOFFSET) &&
+                   (VOP_BMAP(vp, loffset, NULL, &bp->b_bio2.bio_offset, &maxclen, NULL) ||
+                    bp->b_bio2.bio_offset == NOOFFSET)) {
                        bawrite(bp);
                        vp->v_clen = 0;
-                       vp->v_lasta = bp->b_bio2.bio_blkno;
-                       vp->v_cstart = lbn + 1;
-                       vp->v_lastw = lbn;
+                       vp->v_lasta = bp->b_bio2.bio_offset;
+                       vp->v_cstart = loffset + lblocksize;
+                       vp->v_lastw = loffset;
                        return;
                }
-               vp->v_clen = maxclen;
-               if (!async && maxclen == 0) {   /* I/O not contiguous */
-                       vp->v_cstart = lbn + 1;
+               if (maxclen > lblocksize)
+                       vp->v_clen = maxclen - lblocksize;
+               else
+                       vp->v_clen = 0;
+               if (!async && vp->v_clen == 0) { /* I/O not contiguous */
+                       vp->v_cstart = loffset + lblocksize;
                        bawrite(bp);
                } else {        /* Wait for rest of cluster */
-                       vp->v_cstart = lbn;
+                       vp->v_cstart = loffset;
                        bdwrite(bp);
                }
-       } else if (lbn == vp->v_cstart + vp->v_clen) {
+       } else if (loffset == vp->v_cstart + vp->v_clen) {
                /*
                 * At end of cluster, write it out if seqcount tells us we
                 * are operating sequentially, otherwise let the buf or
@@ -711,9 +710,10 @@ cluster_write(struct buf *bp, u_quad_t filesize, int seqcount)
                 */
                bdwrite(bp);
                if (seqcount > 1)
-                       cluster_wbuild_wb(vp, lblocksize, vp->v_cstart, vp->v_clen + 1);
+                       cluster_wbuild_wb(vp, lblocksize, vp->v_cstart,
+                                         vp->v_clen + lblocksize);
                vp->v_clen = 0;
-               vp->v_cstart = lbn + 1;
+               vp->v_cstart = loffset + lblocksize;
        } else if (vm_page_count_severe()) {
                /*
                 * We are low on memory, get it going NOW
@@ -725,8 +725,8 @@ cluster_write(struct buf *bp, u_quad_t filesize, int seqcount)
                 */
                bdwrite(bp);
        }
-       vp->v_lastw = lbn;
-       vp->v_lasta = bp->b_bio2.bio_blkno;
+       vp->v_lastw = loffset;
+       vp->v_lasta = bp->b_bio2.bio_offset;
 }
 
 
@@ -737,25 +737,24 @@ cluster_write(struct buf *bp, u_quad_t filesize, int seqcount)
  * the current block (if last_bp == NULL).
  */
 int
-cluster_wbuild(struct vnode *vp, long size, daddr_t start_lbn, int len)
+cluster_wbuild(struct vnode *vp, int size, off_t start_loffset, int bytes)
 {
        struct buf *bp, *tbp;
        int i, j;
        int totalwritten = 0;
-       int dbsize = btodb(size);
 
-       while (len > 0) {
+       while (bytes > 0) {
                crit_enter();
                /*
                 * If the buffer is not delayed-write (i.e. dirty), or it 
                 * is delayed-write but either locked or inval, it cannot 
                 * partake in the clustered write.
                 */
-               if (((tbp = findblk(vp, start_lbn)) == NULL) ||
+               if (((tbp = findblk(vp, start_loffset)) == NULL) ||
                  ((tbp->b_flags & (B_LOCKED | B_INVAL | B_DELWRI)) != B_DELWRI) ||
                  BUF_LOCK(tbp, LK_EXCLUSIVE | LK_NOWAIT)) {
-                       ++start_lbn;
-                       --len;
+                       start_loffset += size;
+                       bytes -= size;
                        crit_exit();
                        continue;
                }
@@ -774,12 +773,12 @@ cluster_wbuild(struct vnode *vp, long size, daddr_t start_lbn, int len)
                if (((tbp->b_flags & (B_CLUSTEROK|B_MALLOC)) != B_CLUSTEROK) ||
                  (tbp->b_bcount != tbp->b_bufsize) ||
                  (tbp->b_bcount != size) ||
-                 (len == 1) ||
+                 (bytes == size) ||
                  ((bp = getpbuf(&cluster_pbuf_freecnt)) == NULL)) {
                        totalwritten += tbp->b_bufsize;
                        bawrite(tbp);
-                       ++start_lbn;
-                       --len;
+                       start_loffset += size;
+                       bytes -= size;
                        continue;
                }
 
@@ -790,9 +789,8 @@ cluster_wbuild(struct vnode *vp, long size, daddr_t start_lbn, int len)
                bp->b_bcount = 0;
                bp->b_bufsize = 0;
                bp->b_xio.xio_npages = 0;
-               bp->b_lblkno = tbp->b_lblkno;
                bp->b_loffset = tbp->b_loffset;
-               bp->b_bio2.bio_blkno = tbp->b_bio2.bio_blkno;
+               bp->b_bio2.bio_offset = tbp->b_bio2.bio_offset;
 
                /*
                 * We are synthesizing a buffer out of vm_page_t's, but
@@ -813,14 +811,14 @@ cluster_wbuild(struct vnode *vp, long size, daddr_t start_lbn, int len)
                 * if there are buffers with adjacent data that need to
                 * be written as well.
                 */
-               for (i = 0; i < len; ++i, ++start_lbn) {
+               for (i = 0; i < bytes; (i += size), (start_loffset += size)) {
                        if (i != 0) { /* If not the first buffer */
                                crit_enter();
                                /*
                                 * If the adjacent data is not even in core it
                                 * can't need to be written.
                                 */
-                               if ((tbp = findblk(vp, start_lbn)) == NULL) {
+                               if ((tbp = findblk(vp, start_loffset)) == NULL) {
                                        crit_exit();
                                        break;
                                }
@@ -848,8 +846,8 @@ cluster_wbuild(struct vnode *vp, long size, daddr_t start_lbn, int len)
                                 * and would not be too large
                                 */
                                if ((tbp->b_bcount != size) ||
-                                 ((bp->b_bio2.bio_blkno + (dbsize * i)) !=
-                                   tbp->b_bio2.bio_blkno) ||
+                                 ((bp->b_bio2.bio_offset + i) !=
+                                   tbp->b_bio2.bio_offset) ||
                                  ((tbp->b_xio.xio_npages + bp->b_xio.xio_npages) >
                                    (vp->v_mount->mnt_iosize_max / PAGE_SIZE))) {
                                        BUF_UNLOCK(tbp);
@@ -878,7 +876,7 @@ cluster_wbuild(struct vnode *vp, long size, daddr_t start_lbn, int len)
                                vm_page_t m;
 
                                if (i != 0) { /* if not first buffer */
-                                       for (j = 0; j < tbp->b_xio.xio_npages; j += 1) {
+                                       for (j = 0; j < tbp->b_xio.xio_npages; ++j) {
                                                m = tbp->b_xio.xio_pages[j];
                                                if (m->flags & PG_BUSY) {
                                                        bqrelse(tbp);
@@ -887,7 +885,7 @@ cluster_wbuild(struct vnode *vp, long size, daddr_t start_lbn, int len)
                                        }
                                }
                                        
-                               for (j = 0; j < tbp->b_xio.xio_npages; j += 1) {
+                               for (j = 0; j < tbp->b_xio.xio_npages; ++j) {
                                        m = tbp->b_xio.xio_pages[j];
                                        vm_page_io_start(m);
                                        vm_object_pip_add(m->object, 1);
@@ -921,7 +919,7 @@ cluster_wbuild(struct vnode *vp, long size, daddr_t start_lbn, int len)
                        (vm_page_t *) bp->b_xio.xio_pages, bp->b_xio.xio_npages);
                if (bp->b_bufsize > bp->b_kvasize)
                        panic(
-                           "cluster_wbuild: b_bufsize(%ld) > b_kvasize(%d)\n",
+                           "cluster_wbuild: b_bufsize(%d) > b_kvasize(%d)\n",
                            bp->b_bufsize, bp->b_kvasize);
                bp->b_kvasize = bp->b_bufsize;
                totalwritten += bp->b_bufsize;
@@ -929,7 +927,7 @@ cluster_wbuild(struct vnode *vp, long size, daddr_t start_lbn, int len)
                bp->b_dirtyend = bp->b_bufsize;
                bawrite(bp);
 
-               len -= i;
+               bytes -= i;
        }
        return totalwritten;
 }
@@ -939,29 +937,31 @@ cluster_wbuild(struct vnode *vp, long size, daddr_t start_lbn, int len)
  * Plus add one additional buffer.
  */
 static struct cluster_save *
-cluster_collectbufs(struct vnode *vp, struct buf *last_bp)
+cluster_collectbufs(struct vnode *vp, struct buf *last_bp, int lblocksize)
 {
        struct cluster_save *buflist;
        struct buf *bp;
-       daddr_t lbn;
+       off_t loffset;
        int i, len;
 
-       len = vp->v_lastw - vp->v_cstart + 1;
+       len = (int)(vp->v_lastw - vp->v_cstart + lblocksize) / lblocksize;
        buflist = malloc(sizeof(struct buf *) * (len + 1) + sizeof(*buflist),
-           M_SEGMENT, M_WAITOK);
+                        M_SEGMENT, M_WAITOK);
        buflist->bs_nchildren = 0;
        buflist->bs_children = (struct buf **) (buflist + 1);
-       for (lbn = vp->v_cstart, i = 0; i < len; lbn++, i++) {
-               (void) bread(vp, lbn, last_bp->b_bcount, &bp);
+       for (loffset = vp->v_cstart, i = 0; i < len; (loffset += lblocksize), i++) {
+               (void) bread(vp, loffset, last_bp->b_bcount, &bp);
                buflist->bs_children[i] = bp;
-               if (bp->b_bio2.bio_blkno == (daddr_t)-1)
-                       VOP_BMAP(bp->b_vp, bp->b_lblkno, NULL, &bp->b_bio2.bio_blkno,
-                               NULL, NULL);
+               if (bp->b_bio2.bio_offset == NOOFFSET) {
+                       VOP_BMAP(bp->b_vp, bp->b_loffset, NULL,
+                               &bp->b_bio2.bio_offset, NULL, NULL);
+               }
        }
        buflist->bs_children[i] = bp = last_bp;
-       if (bp->b_bio2.bio_blkno == (daddr_t)-1)
-               VOP_BMAP(bp->b_vp, bp->b_lblkno, NULL, &bp->b_bio2.bio_blkno,
-                       NULL, NULL);
+       if (bp->b_bio2.bio_offset == NOOFFSET) {
+               VOP_BMAP(bp->b_vp, bp->b_loffset, NULL,
+                        &bp->b_bio2.bio_offset, NULL, NULL);
+       }
        buflist->bs_nchildren = i + 1;
        return (buflist);
 }
index 903212d..9b6c2aa 100644 (file)
@@ -70,7 +70,7 @@
  *
  *     @(#)vfs_init.c  8.3 (Berkeley) 1/4/94
  * $FreeBSD: src/sys/kern/vfs_init.c,v 1.59 2002/04/30 18:44:32 dillon Exp $
- * $DragonFly: src/sys/kern/vfs_init.c,v 1.10 2005/09/17 07:43:00 dillon Exp $
+ * $DragonFly: src/sys/kern/vfs_init.c,v 1.11 2006/03/24 18:35:33 dillon Exp $
  */
 /*
  * Manage vnode VOP operations vectors
@@ -132,6 +132,7 @@ vfs_add_vnodeops(struct mount *mp, struct vop_ops **vops_pp,
        struct vop_ops *ops;
 
        node = malloc(sizeof(*node), M_VNODEOP, M_ZERO|M_WAITOK);
+       KKASSERT(*vops_pp == NULL);
        if ((ops = *vops_pp) == NULL) {
                ops = malloc(sizeof(struct vop_ops),
                                M_VNODEOP, M_ZERO|M_WAITOK);
index ff25457..ef7460b 100644 (file)
@@ -37,7 +37,7 @@
  *
  *     @(#)vfs_subr.c  8.31 (Berkeley) 5/26/95
  * $FreeBSD: src/sys/kern/vfs_subr.c,v 1.249.2.30 2003/04/04 20:35:57 tegge Exp $
- * $DragonFly: src/sys/kern/vfs_subr.c,v 1.70 2006/03/05 18:38:34 dillon Exp $
+ * $DragonFly: src/sys/kern/vfs_subr.c,v 1.71 2006/03/24 18:35:33 dillon Exp $
  */
 
 /*
@@ -136,15 +136,15 @@ extern struct vnodeopv_entry_desc spec_vnodeop_entries[];
  * Red black tree functions
  */
 static int rb_buf_compare(struct buf *b1, struct buf *b2);
-RB_GENERATE2(buf_rb_tree, buf, b_rbnode, rb_buf_compare, daddr_t, b_lblkno);
-RB_GENERATE2(buf_rb_hash, buf, b_rbhash, rb_buf_compare, daddr_t, b_lblkno);
+RB_GENERATE2(buf_rb_tree, buf, b_rbnode, rb_buf_compare, off_t, b_loffset);
+RB_GENERATE2(buf_rb_hash, buf, b_rbhash, rb_buf_compare, off_t, b_loffset);
 
 static int
 rb_buf_compare(struct buf *b1, struct buf *b2)
 {
-       if (b1->b_lblkno < b2->b_lblkno)
+       if (b1->b_loffset < b2->b_loffset)
                return(-1);
-       if (b1->b_lblkno > b2->b_lblkno)
+       if (b1->b_loffset > b2->b_loffset)
                return(1);
        return(0);
 }
@@ -428,24 +428,27 @@ static int vtruncbuf_bp_metasync(struct buf *bp, void *data);
 int
 vtruncbuf(struct vnode *vp, struct thread *td, off_t length, int blksize)
 {
-       daddr_t trunclbn;
+       off_t truncloffset;
        int count;
 
        /*
-        * Round up to the *next* lbn, then destroy the buffers in question.  
+        * Round up to the *next* block, then destroy the buffers in question.  
         * Since we are only removing some of the buffers we must rely on the
         * scan count to determine whether a loop is necessary.
         */
-       trunclbn = (length + blksize - 1) / blksize;
+       if ((count = (int)(length % blksize)) != 0)
+               truncloffset = length + (blksize - count);
+       else
+               truncloffset = length;
 
        crit_enter();
        do {
                count = RB_SCAN(buf_rb_tree, &vp->v_rbclean_tree, 
                                vtruncbuf_bp_trunc_cmp,
-                               vtruncbuf_bp_trunc, &trunclbn);
+                               vtruncbuf_bp_trunc, &truncloffset);
                count += RB_SCAN(buf_rb_tree, &vp->v_rbdirty_tree,
                                vtruncbuf_bp_trunc_cmp,
-                               vtruncbuf_bp_trunc, &trunclbn);
+                               vtruncbuf_bp_trunc, &truncloffset);
        } while(count);
 
        /*
@@ -485,7 +488,7 @@ static
 int
 vtruncbuf_bp_trunc_cmp(struct buf *bp, void *data)
 {
-       if (bp->b_lblkno >= *(daddr_t *)data)
+       if (bp->b_loffset >= *(off_t *)data)
                return(0);
        return(-1);
 }
@@ -513,13 +516,13 @@ vtruncbuf_bp_trunc(struct buf *bp, void *data)
 
 /*
  * Fsync all meta-data after truncating a file to be non-zero.  Only metadata
- * blocks (with a negative lblkno) are scanned.
+ * blocks (with a negative loffset) are scanned.
  * Note that the compare function must conform to the RB_SCAN's requirements.
  */
 static int
 vtruncbuf_bp_metasync_cmp(struct buf *bp, void *data)
 {
-       if (bp->b_lblkno < 0)
+       if (bp->b_loffset < 0)
                return(0);
        return(1);
 }
@@ -578,12 +581,13 @@ struct vfsync_info {
        int syncdeps;
        int lazycount;
        int lazylimit;
-       daddr_t lbn;
+       int skippedbufs;
+       off_t loffset;
        int (*checkdef)(struct buf *);
 };
 
 int
-vfsync(struct vnode *vp, int waitfor, int passes, daddr_t lbn,
+vfsync(struct vnode *vp, int waitfor, int passes, off_t loffset,
        int (*checkdef)(struct buf *),
        int (*waitoutput)(struct vnode *, struct thread *))
 {
@@ -592,7 +596,7 @@ vfsync(struct vnode *vp, int waitfor, int passes, daddr_t lbn,
 
        bzero(&info, sizeof(info));
        info.vp = vp;
-       info.lbn = lbn;
+       info.loffset = loffset;
        if ((info.checkdef = checkdef) == NULL)
                info.syncdeps = 1;
 
@@ -638,9 +642,12 @@ vfsync(struct vnode *vp, int waitfor, int passes, daddr_t lbn,
                        vfsync_bp, &info);
                error = vfsync_wait_output(vp, waitoutput);
                if (error == 0) {
+                       info.skippedbufs = 0;
                        RB_SCAN(buf_rb_tree, &vp->v_rbdirty_tree, NULL,
                                vfsync_bp, &info);
                        error = vfsync_wait_output(vp, waitoutput);
+                       if (info.skippedbufs)
+                               printf("Warning: vfsync skipped %d dirty bufs in pass2!\n", info.skippedbufs);
                }
                while (error == 0 && passes > 0 &&
                    !RB_EMPTY(&vp->v_rbdirty_tree)) {
@@ -679,7 +686,7 @@ vfsync_wait_output(struct vnode *vp, int (*waitoutput)(struct vnode *, struct th
 static int
 vfsync_data_only_cmp(struct buf *bp, void *data)
 {
-       if (bp->b_lblkno < 0)
+       if (bp->b_loffset < 0)
                return(-1);
        return(0);
 }
@@ -687,7 +694,7 @@ vfsync_data_only_cmp(struct buf *bp, void *data)
 static int
 vfsync_meta_only_cmp(struct buf *bp, void *data)
 {
-       if (bp->b_lblkno < 0)
+       if (bp->b_loffset < 0)
                return(0);
        return(1);
 }
@@ -696,7 +703,7 @@ static int
 vfsync_lazy_range_cmp(struct buf *bp, void *data)
 {
        struct vfsync_info *info = data;
-       if (bp->b_lblkno < info->vp->v_lazyw)
+       if (bp->b_loffset < info->vp->v_lazyw)
                return(-1);
        return(0);
 }
@@ -718,8 +725,11 @@ vfsync_bp(struct buf *bp, void *data)
        /*
         * Ignore buffers that we cannot immediately lock.  XXX
         */
-       if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT))
+       if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT)) {
+               printf("Warning: vfsync_bp skipping dirty buffer %p\n", bp);
+               ++info->skippedbufs;
                return(0);
+       }
        if ((bp->b_flags & B_DELWRI) == 0)
                panic("vfsync_bp: buffer not dirty");
        if (vp != bp->b_vp)
@@ -740,8 +750,8 @@ vfsync_bp(struct buf *bp, void *data)
         * (LEGACY FROM UFS, REMOVE WHEN POSSIBLE) - invalidate any dirty
         * buffers beyond the file EOF. 
         */
-       if (info->lbn != (daddr_t)-1 && vp->v_type == VREG && 
-           bp->b_lblkno >= info->lbn) {
+       if (info->loffset != NOOFFSET && vp->v_type == VREG && 
+           bp->b_loffset >= info->loffset) {
                bremfree(bp);
                bp->b_flags |= B_INVAL | B_NOCACHE;
                crit_exit();
@@ -763,7 +773,7 @@ vfsync_bp(struct buf *bp, void *data)
                 * stops the scan and is not considered an error.  We use
                 * this to support limited MNT_LAZY flushes.
                 */
-               vp->v_lazyw = bp->b_lblkno;
+               vp->v_lazyw = bp->b_loffset;
                if ((vp->v_flag & VOBJBUF) && (bp->b_flags & B_CLUSTEROK)) {
                        info->lazycount += vfs_bio_awrite(bp);
                } else {
index 0bc1599..1bc66fe 100644 (file)
@@ -32,7 +32,7 @@
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  * 
- * $DragonFly: src/sys/kern/vfs_vopops.c,v 1.17 2006/02/17 19:18:06 dillon Exp $
+ * $DragonFly: src/sys/kern/vfs_vopops.c,v 1.18 2006/03/24 18:35:33 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -863,8 +863,8 @@ vop_unlock(struct vop_ops *ops, struct vnode *vp, int flags, struct thread *td)
 }
 
 int
-vop_bmap(struct vop_ops *ops, struct vnode *vp, daddr_t bn, struct vnode **vpp,
-       daddr_t *bnp, int *runp, int *runb)
+vop_bmap(struct vop_ops *ops, struct vnode *vp, off_t loffset,
+       struct vnode **vpp, off_t *doffsetp, int *runp, int *runb)
 {
        struct vop_bmap_args ap;
        int error;
@@ -872,9 +872,9 @@ vop_bmap(struct vop_ops *ops, struct vnode *vp, daddr_t bn, struct vnode **vpp,
        ap.a_head.a_desc = &vop_bmap_desc;
        ap.a_head.a_ops = ops;
        ap.a_vp = vp;
-       ap.a_bn = bn;
+       ap.a_loffset = loffset;
        ap.a_vpp = vpp;
-       ap.a_bnp = bnp;
+       ap.a_doffsetp = doffsetp;
        ap.a_runp = runp;
        ap.a_runb = runb;
 
@@ -1028,8 +1028,7 @@ vop_putpages(struct vop_ops *ops, struct vnode *vp, vm_page_t *m, int count,
 }
 
 int
-vop_freeblks(struct vop_ops *ops, struct vnode *vp,
-       daddr_t addr, daddr_t length)
+vop_freeblks(struct vop_ops *ops, struct vnode *vp, off_t offset, int length)
 {
        struct vop_freeblks_args ap;
        int error;
@@ -1037,7 +1036,7 @@ vop_freeblks(struct vop_ops *ops, struct vnode *vp,
        ap.a_head.a_desc = &vop_freeblks_desc;
        ap.a_head.a_ops = ops;
        ap.a_vp = vp;
-       ap.a_addr = addr;
+       ap.a_offset = offset;
        ap.a_length = length;
 
        DO_OPS(ops, error, &ap, vop_freeblks);
index 5531088..4aaf854 100644 (file)
@@ -36,7 +36,7 @@
  *
  *     from: @(#)machdep.c     7.4 (Berkeley) 6/3/91
  * $FreeBSD: src/sys/i386/i386/machdep.c,v 1.385.2.30 2003/05/31 08:48:05 alc Exp $
- * $DragonFly: src/sys/platform/pc32/i386/machdep.c,v 1.87 2006/03/05 18:38:32 dillon Exp $
+ * $DragonFly: src/sys/platform/pc32/i386/machdep.c,v 1.88 2006/03/24 18:35:32 dillon Exp $
  */
 
 #include "use_apm.h"
@@ -2528,12 +2528,13 @@ bounds_check_with_label(dev_t dev, struct bio *bio,
         int labelsect = lp->d_partitions[0].p_offset;
         int maxsz = p->p_size,
                 sz = (bp->b_bcount + DEV_BSIZE - 1) >> DEV_BSHIFT;
+       daddr_t blkno = (daddr_t)(bio->bio_offset >> DEV_BSHIFT);
 
         /* overwriting disk label ? */
         /* XXX should also protect bootstrap in first 8K */
-        if (bio->bio_blkno + p->p_offset <= LABELSECTOR + labelsect &&
+        if (blkno + p->p_offset <= LABELSECTOR + labelsect &&
 #if LABELSECTOR != 0
-            bio->bio_blkno + p->p_offset + sz > LABELSECTOR + labelsect &&
+            blkno + p->p_offset + sz > LABELSECTOR + labelsect &&
 #endif
             (bp->b_flags & B_READ) == 0 && wlabel == 0) {
                 bp->b_error = EROFS;
@@ -2542,7 +2543,7 @@ bounds_check_with_label(dev_t dev, struct bio *bio,
 
 #if     defined(DOSBBSECTOR) && defined(notyet)
         /* overwriting master boot record? */
-        if (bio->bio_blkno + p->p_offset <= DOSBBSECTOR &&
+        if (blkno + p->p_offset <= DOSBBSECTOR &&
             (bp->b_flags & B_READ) == 0 && wlabel == 0) {
                 bp->b_error = EROFS;
                 goto bad;
@@ -2550,14 +2551,14 @@ bounds_check_with_label(dev_t dev, struct bio *bio,
 #endif
 
         /* beyond partition? */
-        if (bio->bio_blkno < 0 || bio->bio_blkno + sz > maxsz) {
+        if (bio->bio_offset < 0 || blkno + sz > maxsz) {
                 /* if exactly at end of disk, return an EOF */
-                if (bio->bio_blkno == maxsz) {
+                if (blkno == maxsz) {
                         bp->b_resid = bp->b_bcount;
                         return(0);
                 }
                 /* or truncate if part of it fits */
-                sz = maxsz - bio->bio_blkno;
+                sz = maxsz - blkno;
                 if (sz <= 0) {
                         bp->b_error = EINVAL;
                         goto bad;
@@ -2565,7 +2566,7 @@ bounds_check_with_label(dev_t dev, struct bio *bio,
                 bp->b_bcount = sz << DEV_BSHIFT;
         }
        nbio = push_bio(bio);
-        nbio->bio_blkno = bio->bio_blkno + p->p_offset;
+        nbio->bio_offset = bio->bio_offset + ((off_t)p->p_offset << DEV_BSHIFT);
        return (nbio);
 
 bad:
index 616d965..9344022 100644 (file)
@@ -31,7 +31,7 @@
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- * $DragonFly: src/sys/sys/bio.h,v 1.3 2006/02/17 19:18:07 dillon Exp $
+ * $DragonFly: src/sys/sys/bio.h,v 1.4 2006/03/24 18:35:33 dillon Exp $
  */
 
 #ifndef _SYS_BIO_H_
@@ -62,7 +62,6 @@ struct bio {
        struct bio      *bio_next;      /* BIO stack / cached translations */
        struct buf      *bio_buf;       /* High-level buffer back-pointer. */
        biodone_t       *bio_done;      /* Caller completion function */
-       daddr_t         bio_blkno;      /* Block number relative to device */
        off_t           bio_offset;     /* Logical offset relative to device */
        void            *bio_driver_info;
        union {
index 7e337c9..2cd77a1 100644 (file)
@@ -37,7 +37,7 @@
  *
  *     @(#)buf.h       8.9 (Berkeley) 3/30/95
  * $FreeBSD: src/sys/sys/buf.h,v 1.88.2.10 2003/01/25 19:02:23 dillon Exp $
- * $DragonFly: src/sys/sys/buf.h,v 1.24 2006/03/05 18:38:36 dillon Exp $
+ * $DragonFly: src/sys/sys/buf.h,v 1.25 2006/03/24 18:35:33 dillon Exp $
  */
 
 #ifndef _SYS_BUF_H_
@@ -76,8 +76,8 @@ struct xio;
 
 struct buf_rb_tree;
 struct buf_rb_hash;
-RB_PROTOTYPE2(buf_rb_tree, buf, b_rbnode, rb_buf_compare, daddr_t, b_lblkno);
-RB_PROTOTYPE2(buf_rb_hash, buf, b_rbhash, rb_buf_compare, daddr_t, b_lblkno);
+RB_PROTOTYPE2(buf_rb_tree, buf, b_rbnode, rb_buf_compare, off_t, b_loffset);
+RB_PROTOTYPE2(buf_rb_hash, buf, b_rbhash, rb_buf_compare, off_t, b_loffset);
 
 /*
  * To avoid including <ufs/ffs/softdep.h> 
@@ -144,16 +144,17 @@ struct buf {
        RB_ENTRY(buf) b_rbhash;         /* RB node in vnode hash tree */
        TAILQ_ENTRY(buf) b_freelist;    /* Free list position if not active. */
        struct buf *b_cluster_next;     /* Next buffer (cluster code) */
-       struct vnode *b_vp;             /* (vp, lblkno) index */
+       struct vnode *b_vp;             /* (vp, loffset) index */
        struct bio b_bio_array[NBUF_BIO]; /* BIO translation layers */ 
-       long    b_flags;                /* B_* flags. */
+       u_int32_t b_flags;              /* B_* flags. */
        unsigned short b_qindex;        /* buffer queue index */
        unsigned char b_xflags;         /* extra flags */
+       unsigned char b_unused01;
        struct lock b_lock;             /* Buffer lock */
-       long    b_bufsize;              /* Allocated buffer size. */
-       long    b_runningbufspace;      /* when I/O is running, pipelining */
-       long    b_bcount;               /* Valid bytes in buffer. */
-       long    b_resid;                /* Remaining I/O */
+       int     b_bufsize;              /* Allocated buffer size. */
+       int     b_runningbufspace;      /* when I/O is running, pipelining */
+       int     b_bcount;               /* Valid bytes in buffer. */
+       int     b_resid;                /* Remaining I/O */
        int     b_error;                /* Error return */
        caddr_t b_data;                 /* Memory, superblocks, indirect etc. */
        caddr_t b_kvabase;              /* base kva for buffer */
@@ -171,7 +172,6 @@ struct buf {
 #define b_bio1         b_bio_array[0]  /* logical layer */
 #define b_bio2         b_bio_array[1]  /* (typically) the disk layer */
 #define b_loffset      b_bio1.bio_offset
-#define b_lblkno       b_bio1.bio_blkno
 
 /*
  * These flags are kept in b_flags.
@@ -288,21 +288,15 @@ extern char *buf_wmesg;                   /* Default buffer lock message */
 
 struct bio_queue_head {
        TAILQ_HEAD(bio_queue, bio) queue;
-       daddr_t last_blkno;
+       off_t   last_offset;
        struct  bio *insert_point;
        struct  bio *switch_point;
 };
 
 /*
- * This structure describes a clustered I/O.  It is stored in the b_saveaddr
- * field of the buffer on which I/O is done.  At I/O completion, cluster
- * callback uses the structure to parcel I/O's to individual buffers, and
- * then free's this structure.
+ * This structure describes a clustered I/O.
  */
 struct cluster_save {
-       long    bs_bcount;              /* Saved b_bcount. */
-       long    bs_bufsize;             /* Saved b_bufsize. */
-       void    *bs_saveaddr;           /* Saved b_addr. */
        int     bs_nchildren;           /* Number of associated buffers. */
        struct buf **bs_children;       /* List of associated buffers. */
 };
@@ -348,8 +342,8 @@ void        initbufbio(struct buf *);
 void   reinitbufbio(struct buf *);
 void   clearbiocache(struct bio *);
 void   bremfree (struct buf *);
-int    bread (struct vnode *, daddr_t, int, struct buf **);
-int    breadn (struct vnode *, daddr_t, int, daddr_t *, int *, int,
+int    bread (struct vnode *, off_t, int, struct buf **);
+int    breadn (struct vnode *, off_t, int, off_t *, int *, int,
            struct buf **);
 int    bwrite (struct buf *);
 void   bdwrite (struct buf *);
@@ -361,9 +355,9 @@ void        brelse (struct buf *);
 void   bqrelse (struct buf *);
 int    vfs_bio_awrite (struct buf *);
 struct buf *getpbuf (int *);
-int    inmem (struct vnode *, daddr_t);
-struct buf *findblk (struct vnode *, daddr_t);
-struct buf *getblk (struct vnode *, daddr_t, int, int, int);
+int    inmem (struct vnode *, off_t);
+struct buf *findblk (struct vnode *, off_t);
+struct buf *getblk (struct vnode *, off_t, int, int, int);
 struct buf *geteblk (int);
 struct bio *push_bio(struct bio *);
 void pop_bio(struct bio *);
@@ -371,10 +365,10 @@ int       biowait (struct buf *);
 void   biodone (struct bio *);
 
 void   cluster_append(struct bio *, struct buf *);
-int    cluster_read (struct vnode *, u_quad_t, daddr_t, long,
-           long, int, struct buf **);
-int    cluster_wbuild (struct vnode *, long, daddr_t, int);
-void   cluster_write (struct buf *, u_quad_t, int);
+int    cluster_read (struct vnode *, off_t, off_t, int,
+           int, int, struct buf **);
+int    cluster_wbuild (struct vnode *, int, off_t, int);
+void   cluster_write (struct buf *, off_t, int);
 int    physio (dev_t dev, struct uio *uio, int ioflag);
 #define physread physio
 #define physwrite physio
index 7749fd6..769e538 100644 (file)
@@ -37,7 +37,7 @@
  *
  *     @(#)buf.h       8.9 (Berkeley) 3/30/95
  * $FreeBSD: src/sys/sys/buf.h,v 1.88.2.10 2003/01/25 19:02:23 dillon Exp $
- * $DragonFly: src/sys/sys/buf2.h,v 1.14 2006/03/02 19:26:17 dillon Exp $
+ * $DragonFly: src/sys/sys/buf2.h,v 1.15 2006/03/24 18:35:33 dillon Exp $
  */
 
 #ifndef _SYS_BUF2_H_
@@ -144,7 +144,7 @@ static __inline void
 bioq_init(struct bio_queue_head *head)
 {
        TAILQ_INIT(&head->queue);
-       head->last_blkno = 0;
+       head->last_offset = 0;
        head->insert_point = NULL;
        head->switch_point = NULL;
 }
@@ -167,9 +167,9 @@ bioq_remove(struct bio_queue_head *head, struct bio *bio)
        if (bio == head->insert_point) {
                head->insert_point = TAILQ_PREV(bio, bio_queue, bio_act);
                if (head->insert_point == NULL)
-                       head->last_blkno = 0;
+                       head->last_offset = 0;
        } else if (bio == TAILQ_FIRST(&head->queue))
-               head->last_blkno = bio->bio_blkno;
+               head->last_offset = bio->bio_offset;
        TAILQ_REMOVE(&head->queue, bio, bio_act);
        if (TAILQ_FIRST(&head->queue) == head->switch_point)
                head->switch_point = NULL;
index 7762fb5..4b47dc2 100644 (file)
@@ -1,5 +1,5 @@
 /* $FreeBSD: src/sys/sys/ccdvar.h,v 1.11.2.1 2001/09/11 09:49:54 kris Exp $ */
-/* $DragonFly: src/sys/sys/ccdvar.h,v 1.2 2003/06/17 04:28:58 dillon Exp $ */
+/* $DragonFly: src/sys/sys/ccdvar.h,v 1.3 2006/03/24 18:35:33 dillon Exp $ */
 
 /*     $NetBSD: ccdvar.h,v 1.7.2.1 1995/10/12 21:30:18 thorpej Exp $   */
 
@@ -193,7 +193,7 @@ struct ccd_softc {
        struct disklabel sc_label;              /* generic disk device info */
        int              sc_openmask;
        int              sc_pick;               /* side of mirror picked */
-       daddr_t          sc_blk[2];             /* mirror localization */
+       off_t            sc_blk[2];             /* mirror localization */
 };
 
 /* sc_flags */
index ea199cb..1b7a03c 100644 (file)
@@ -32,7 +32,7 @@
  *
  *     @(#)disklabel.h 8.2 (Berkeley) 7/10/94
  * $FreeBSD: src/sys/sys/disklabel.h,v 1.49.2.7 2001/05/27 05:58:26 jkh Exp $
- * $DragonFly: src/sys/sys/disklabel.h,v 1.12 2006/02/17 19:18:07 dillon Exp $
+ * $DragonFly: src/sys/sys/disklabel.h,v 1.13 2006/03/24 18:35:33 dillon Exp $
  */
 
 #ifndef _SYS_DISKLABEL_H_
@@ -429,7 +429,7 @@ struct      bio_queue_head;
 struct bio *bounds_check_with_label (dev_t dev, struct bio *bio,
                                     struct disklabel *lp, int wlabel);
 void   diskerr (struct bio *bio, dev_t dev, const char *what, int pri,
-                    int blkdone, struct disklabel *lp);
+                    int donecnt, struct disklabel *lp);
 void   disksort (struct buf *ap, struct buf *bp);
 char   *readdisklabel (dev_t dev, struct disklabel *lp);
 void   bioqdisksort (struct bio_queue_head *ap, struct bio *bio);
index 87fb20f..8e605ca 100644 (file)
@@ -32,7 +32,7 @@
  *
  *     @(#)disklabel.h 8.2 (Berkeley) 7/10/94
  * $FreeBSD: src/sys/sys/disklabel.h,v 1.49.2.7 2001/05/27 05:58:26 jkh Exp $
- * $DragonFly: src/sys/sys/disklabel32.h,v 1.12 2006/02/17 19:18:07 dillon Exp $
+ * $DragonFly: src/sys/sys/disklabel32.h,v 1.13 2006/03/24 18:35:33 dillon Exp $
  */
 
 #ifndef _SYS_DISKLABEL_H_
@@ -429,7 +429,7 @@ struct      bio_queue_head;
 struct bio *bounds_check_with_label (dev_t dev, struct bio *bio,
                                     struct disklabel *lp, int wlabel);
 void   diskerr (struct bio *bio, dev_t dev, const char *what, int pri,
-                    int blkdone, struct disklabel *lp);
+                    int donecnt, struct disklabel *lp);
 void   disksort (struct buf *ap, struct buf *bp);
 char   *readdisklabel (dev_t dev, struct disklabel *lp);
 void   bioqdisksort (struct bio_queue_head *ap, struct bio *bio);
index 991a7be..69b8219 100644 (file)
@@ -32,7 +32,7 @@
  *
  *     @(#)disklabel.h 8.2 (Berkeley) 7/10/94
  * $FreeBSD: src/sys/sys/disklabel.h,v 1.49.2.7 2001/05/27 05:58:26 jkh Exp $
- * $DragonFly: src/sys/sys/Attic/odisklabel.h,v 1.12 2006/02/17 19:18:07 dillon Exp $
+ * $DragonFly: src/sys/sys/Attic/odisklabel.h,v 1.13 2006/03/24 18:35:33 dillon Exp $
  */
 
 #ifndef _SYS_DISKLABEL_H_
@@ -429,7 +429,7 @@ struct      bio_queue_head;
 struct bio *bounds_check_with_label (dev_t dev, struct bio *bio,
                                     struct disklabel *lp, int wlabel);
 void   diskerr (struct bio *bio, dev_t dev, const char *what, int pri,
-                    int blkdone, struct disklabel *lp);
+                    int donecnt, struct disklabel *lp);
 void   disksort (struct buf *ap, struct buf *bp);
 char   *readdisklabel (dev_t dev, struct disklabel *lp);
 void   bioqdisksort (struct bio_queue_head *ap, struct bio *bio);
index c65c22b..12405db 100644 (file)
@@ -31,7 +31,7 @@
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- * $DragonFly: src/sys/sys/vfsops.h,v 1.15 2006/02/17 19:18:07 dillon Exp $
+ * $DragonFly: src/sys/sys/vfsops.h,v 1.16 2006/03/24 18:35:33 dillon Exp $
  */
 
 /*
@@ -327,9 +327,9 @@ struct vop_unlock_args {
 struct vop_bmap_args {
        struct vop_generic_args a_head;
        struct vnode *a_vp;
-       daddr_t a_bn;
+       off_t a_loffset;
        struct vnode **a_vpp;
-       daddr_t *a_bnp;
+       off_t *a_doffsetp;
        int *a_runp;
        int *a_runb;
 };
@@ -399,8 +399,8 @@ struct vop_putpages_args {
 struct vop_freeblks_args {
        struct vop_generic_args a_head;
        struct vnode *a_vp;
-       daddr_t a_addr;
-       daddr_t a_length;
+       off_t a_offset;
+       int a_length;
 };
 
 struct vop_bwrite_args {
@@ -818,8 +818,8 @@ int vop_lock(struct vop_ops *ops, struct vnode *vp,
                int flags, struct thread *td);
 int vop_unlock(struct vop_ops *ops, struct vnode *vp,
                int flags, struct thread *td);
-int vop_bmap(struct vop_ops *ops, struct vnode *vp, daddr_t bn,
-               struct vnode **vpp, daddr_t *bnp, int *runp, int *runb);
+int vop_bmap(struct vop_ops *ops, struct vnode *vp, off_t loffset,
+               struct vnode **vpp, off_t *doffsetp, int *runp, int *runb);
 int vop_strategy(struct vop_ops *ops, struct vnode *vp, struct bio *bio);
 int vop_print(struct vop_ops *ops, struct vnode *vp);
 int vop_pathconf(struct vop_ops *ops, struct vnode *vp, int name,
@@ -836,7 +836,7 @@ int vop_getpages(struct vop_ops *ops, struct vnode *vp, struct vm_page **m,
 int vop_putpages(struct vop_ops *ops, struct vnode *vp, struct vm_page **m,
                int count, int sync, int *rtvals, vm_ooffset_t offset);
 int vop_freeblks(struct vop_ops *ops, struct vnode *vp,
-               daddr_t addr, daddr_t length);
+               off_t offset, int length);
 int vop_bwrite(struct vop_ops *ops, struct vnode *vp, struct buf *bp);
 int vop_getacl(struct vop_ops *ops, struct vnode *vp, acl_type_t type,
                struct acl *aclp, struct ucred *cred, struct thread *td);
@@ -1073,8 +1073,8 @@ extern struct vnodeop_desc vop_nrename_desc;
        vop_lock(*(vp)->v_ops, vp, flags, td)
 #define VOP_UNLOCK(vp, flags, td)                      \
        vop_unlock(*(vp)->v_ops, vp, flags, td)
-#define VOP_BMAP(vp, bn, vpp, bnp, runp, runb)         \
-       vop_bmap(*(vp)->v_ops, vp, bn, vpp, bnp, runp, runb)
+#define VOP_BMAP(vp, loff, vpp, doffp, runp, runb)     \
+       vop_bmap(*(vp)->v_ops, vp, loff, vpp, doffp, runp, runb)
 #define VOP_PRINT(vp)                                  \
        vop_print(*(vp)->v_ops, vp)
 #define VOP_PATHCONF(vp, name, retval)                 \
@@ -1089,8 +1089,8 @@ extern struct vnodeop_desc vop_nrename_desc;
        vop_getpages(*(vp)->v_ops, vp, m, count, reqpage, off)
 #define VOP_PUTPAGES(vp, m, count, sync, rtvals, off)  \
        vop_putpages(*(vp)->v_ops, vp, m, count, sync, rtvals, off)
-#define VOP_FREEBLKS(vp, addr, length)                 \
-       vop_freeblks(*(vp)->v_ops, vp, addr, length)
+#define VOP_FREEBLKS(vp, offset, length)               \
+       vop_freeblks(*(vp)->v_ops, vp, offset, length)
 #define VOP_BWRITE(vp, bp)                             \
        vop_bwrite(*(vp)->v_ops, vp, bp)
 #define VOP_GETACL(vp, type, aclp, cred, td)           \
index 2b45030..49ce96b 100644 (file)
@@ -32,7 +32,7 @@
  *
  *     @(#)vnode.h     8.7 (Berkeley) 2/4/94
  * $FreeBSD: src/sys/sys/vnode.h,v 1.111.2.19 2002/12/29 18:19:53 dillon Exp $
- * $DragonFly: src/sys/sys/vnode.h,v 1.41 2006/03/05 18:38:36 dillon Exp $
+ * $DragonFly: src/sys/sys/vnode.h,v 1.42 2006/03/24 18:35:33 dillon Exp $
  */
 
 #ifndef _SYS_VNODE_H_
@@ -186,10 +186,10 @@ struct vnode {
                struct fifoinfo *vu_fifoinfo;   /* fifo (VFIFO) */
        } v_un;
        struct  nqlease *v_lease;               /* Soft reference to lease */
-       daddr_t v_lazyw;                        /* lazy write iterator */
-       daddr_t v_lastw;                        /* last write (write cluster) */
-       daddr_t v_cstart;                       /* start block of cluster */
-       daddr_t v_lasta;                        /* last allocation */
+       off_t   v_lazyw;                        /* lazy write iterator */
+       off_t   v_lastw;                        /* last write (write cluster) */
+       off_t   v_cstart;                       /* start block of cluster */
+       off_t   v_lasta;                        /* last allocation */
        int     v_clen;                         /* length of current cluster */
        struct vm_object *v_object;             /* Place to store VM object */
        struct  lock v_lock;                    /* file/dir ops lock */
@@ -621,7 +621,7 @@ int vinvalbuf (struct vnode *vp, int save,
            struct thread *td, int slpflag, int slptimeo);
 int    vtruncbuf (struct vnode *vp, struct thread *td,
                off_t length, int blksize);
-int    vfsync(struct vnode *vp, int waitfor, int passes, daddr_t lbn,
+int    vfsync(struct vnode *vp, int waitfor, int passes, off_t loffset,
                int (*checkdef)(struct buf *),
                int (*waitoutput)(struct vnode *, struct thread *));
 void   vprint (char *label, struct vnode *vp);
index 0707492..44965e6 100644 (file)
@@ -28,7 +28,7 @@
  * 
  *     @(#) src/sys/coda/coda_vnops.c,v 1.1.1.1 1998/08/29 21:14:52 rvb Exp $
  * $FreeBSD: src/sys/coda/coda_vnops.c,v 1.22.2.1 2001/06/29 16:26:22 shafeeq Exp $
- * $DragonFly: src/sys/vfs/coda/Attic/coda_vnops.c,v 1.29 2006/02/17 19:18:07 dillon Exp $
+ * $DragonFly: src/sys/vfs/coda/Attic/coda_vnops.c,v 1.30 2006/03/24 18:35:33 dillon Exp $
  * 
  */
 
@@ -1615,33 +1615,25 @@ int
 coda_bmap(void *v)
 {
     /* XXX on the global proc */
-/* true args */
     struct vop_bmap_args *ap = v;
-    struct vnode *vp __attribute__((unused)) = ap->a_vp;       /* file's vnode */
-    daddr_t bn __attribute__((unused)) = ap->a_bn;     /* fs block number */
-    struct vnode **vpp = ap->a_vpp;                    /* RETURN vp of device */
-    daddr_t *bnp __attribute__((unused)) = ap->a_bnp;  /* RETURN device block number */
-/* upcall decl */
-/* locals */
-
-       int ret = 0;
-       struct cnode *cp;
+    int ret = 0;
+    struct cnode *cp;
 
-       cp = VTOC(vp);
-       if (cp->c_ovp) {
-               return EINVAL;
-               ret =  VOP_BMAP(cp->c_ovp, bn, vpp, bnp, ap->a_runp, ap->a_runb);
-#if    0
-               printf("VOP_BMAP(cp->c_ovp %p, bn %p, vpp %p, bnp %p, ap->a_runp %p, ap->a_runb %p) = %d\n",
-                       cp->c_ovp, bn, vpp, bnp, ap->a_runp, ap->a_runb, ret);
+    cp = VTOC(ap->a_vp);
+    if (cp->c_ovp) {
+           return EINVAL;
+#if 0
+           ret =  VOP_BMAP(cp->c_ovp, bn, vpp, bnp, ap->a_runp, ap->a_runb);
+           printf("VOP_BMAP(cp->c_ovp %p, bn %p, vpp %p, bnp %p, ap->a_runp %p, ap->a_runb %p) = %d\n",
+                   cp->c_ovp, bn, vpp, bnp, ap->a_runp, ap->a_runb, ret);
 #endif
-               return ret;
-       } else {
-#if    0
-               printf("coda_bmap: no container\n");
+           return ret;
+    } else {
+#if 0
+           printf("coda_bmap: no container\n");
 #endif
-               return(EOPNOTSUPP);
-       }
+           return(EOPNOTSUPP);
+    }
 }
 
 /*
index 00e9fa6..9a048f9 100644 (file)
@@ -32,7 +32,7 @@
  *
  *     @(#)dead_vnops.c        8.1 (Berkeley) 6/10/93
  * $FreeBSD: src/sys/miscfs/deadfs/dead_vnops.c,v 1.26 1999/08/28 00:46:42 peter Exp $
- * $DragonFly: src/sys/vfs/deadfs/dead_vnops.c,v 1.14 2005/09/17 07:43:02 dillon Exp $
+ * $DragonFly: src/sys/vfs/deadfs/dead_vnops.c,v 1.15 2006/03/24 18:35:33 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -179,8 +179,8 @@ dead_lock(struct vop_lock_args *ap)
 /*
  * Wait until the vnode has finished changing state.
  *
- * dead_bmap(struct vnode *a_vp, daddr_t a_bn, struct vnode **a_vpp,
- *          daddr_t *a_bnp, int *a_runp, int *a_runb)
+ * dead_bmap(struct vnode *a_vp, off_t a_loffset, struct vnode **a_vpp,
+ *          off_t *a_doffsetp, int *a_runp, int *a_runb)
  */
 static int
 dead_bmap(struct vop_bmap_args *ap)
index ba09cce..1660e15 100644 (file)
@@ -32,7 +32,7 @@
  *
  *     @(#)fifo_vnops.c        8.10 (Berkeley) 5/27/95
  * $FreeBSD: src/sys/miscfs/fifofs/fifo_vnops.c,v 1.45.2.4 2003/04/22 10:11:24 bde Exp $
- * $DragonFly: src/sys/vfs/fifofs/fifo_vnops.c,v 1.22 2006/01/13 21:09:27 swildner Exp $
+ * $DragonFly: src/sys/vfs/fifofs/fifo_vnops.c,v 1.23 2006/03/24 18:35:33 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -496,16 +496,16 @@ fifo_inactive(struct vop_inactive_args *ap)
 /*
  * This is a noop, simply returning what one has been given.
  *
- * fifo_bmap(struct vnode *a_vp, daddr_t a_bn, struct vnode **a_vpp,
- *          daddr_t *a_bnp, int *a_runp, int *a_runb)
+ * fifo_bmap(struct vnode *a_vp, off_t a_loffset, struct vnode **a_vpp,
+ *          off_t *a_doffsetp, int *a_runp, int *a_runb)
  */
 static int
 fifo_bmap(struct vop_bmap_args *ap)
 {
        if (ap->a_vpp != NULL)
                *ap->a_vpp = ap->a_vp;
-       if (ap->a_bnp != NULL)
-               *ap->a_bnp = ap->a_bn;
+       if (ap->a_doffsetp != NULL)
+               *ap->a_doffsetp = ap->a_loffset;
        if (ap->a_runp != NULL)
                *ap->a_runp = 0;
        if (ap->a_runb != NULL)
index 4a7b369..e573fa0 100644 (file)
@@ -38,7 +38,7 @@
  *
  *     @(#)ext2_alloc.c        8.8 (Berkeley) 2/21/94
  * $FreeBSD: src/sys/gnu/ext2fs/ext2_alloc.c,v 1.28.2.2 2002/07/01 00:18:51 iedowse Exp $
- * $DragonFly: src/sys/vfs/gnu/ext2fs/ext2_alloc.c,v 1.9 2006/02/17 19:18:07 dillon Exp $
+ * $DragonFly: src/sys/vfs/gnu/ext2fs/ext2_alloc.c,v 1.10 2006/03/24 18:35:33 dillon Exp $
  */
 
 #include "opt_quota.h"
@@ -241,20 +241,21 @@ return ENOSPC;
 #endif
        buflist = ap->a_buflist;
        len = buflist->bs_nchildren;
-       start_lbn = buflist->bs_children[0]->b_lblkno;
+       start_lbn = lblkno(fs, buflist->bs_children[0]->b_loffset);
        end_lbn = start_lbn + len - 1;
 #if DIAGNOSTIC
-       for (i = 1; i < len; i++)
-               if (buflist->bs_children[i]->b_lblkno != start_lbn + i)
+       for (i = 1; i < len; i++) {
+               if (buflist->bs_children[i]->b_loffset != lblktodoff(fs, start_lbn) + lblktodoff(fs, i))
                        panic("ext2_reallocblks: non-cluster");
+       }
 #endif
        /*
         * If the latest allocation is in a new cylinder group, assume that
         * the filesystem has decided to move and do not force it back to
         * the previous cylinder group.
         */
-       if (dtog(fs, dbtofsb(fs, buflist->bs_children[0]->b_bio2.bio_blkno)) !=
-           dtog(fs, dbtofsb(fs, buflist->bs_children[len - 1]->b_bio2.bio_blkno)))
+       if (dtog(fs, dofftofsb(fs, buflist->bs_children[0]->b_bio2.bio_offset)) !=
+           dtog(fs, dofftofsb(fs, buflist->bs_children[len - 1]->b_bio2.bio_offset)))
                return (ENOSPC);
        if (ufs_getlbns(vp, start_lbn, start_ap, &start_lvl) ||
            ufs_getlbns(vp, end_lbn, end_ap, &end_lvl))
@@ -267,7 +268,7 @@ return ENOSPC;
                soff = start_lbn;
        } else {
                idp = &start_ap[start_lvl - 1];
-               if (bread(vp, idp->in_lbn, (int)fs->s_blocksize, NOCRED, &sbp)) {
+               if (bread(vp, lblktodoff(fs, idp->in_lbn), (int)fs->s_blocksize, NOCRED, &sbp)) {
                        brelse(sbp);
                        return (ENOSPC);
                }
@@ -289,7 +290,7 @@ return ENOSPC;
                        panic("ext2_reallocblk: start == end");
 #endif
                ssize = len - (idp->in_off + 1);
-               if (bread(vp, idp->in_lbn, (int)fs->s_blocksize, NOCRED, &ebp))
+               if (bread(vp, lblktodoff(fs, idp->in_lbn), (int)fs->s_blocksize, NOCRED, &ebp))
                        goto fail;
                ebap = (daddr_t *)ebp->b_data;
        }
@@ -311,7 +312,7 @@ return ENOSPC;
                if (i == ssize)
                        bap = ebap;
 #if DIAGNOSTIC
-               if (buflist->bs_children[i]->b_bio2.bio_blkno != fsbtodb(fs, *bap))
+               if (buflist->bs_children[i]->b_bio2.bio_offset != fsbtodoff(fs, *bap))
                        panic("ext2_reallocblks: alloc mismatch");
 #endif
                *bap++ = blkno;
@@ -349,9 +350,9 @@ return ENOSPC;
         * Last, free the old blocks and assign the new blocks to the buffers.
         */
        for (blkno = newblk, i = 0; i < len; i++, blkno += fs->s_frags_per_block) {
-               ext2_blkfree(ip, dbtofsb(fs, buflist->bs_children[i]->b_bio2.bio_blkno),
+               ext2_blkfree(ip, dofftofsb(fs, buflist->bs_children[i]->b_bio2.bio_offset),
                    fs->s_blocksize);
-               buflist->bs_children[i]->b_bio2.bio_blkno = fsbtodb(fs, blkno);
+               buflist->bs_children[i]->b_bio2.bio_offset = fsbtodoff(fs, blkno);
        }
        return (0);
 
index dad2245..abbb21c 100644 (file)
@@ -38,7 +38,7 @@
  *
  *     @(#)ffs_balloc.c        8.4 (Berkeley) 9/23/93
  * $FreeBSD: src/sys/gnu/ext2fs/ext2_balloc.c,v 1.9.2.1 2000/08/03 00:52:57 peter Exp $
- * $DragonFly: src/sys/vfs/gnu/ext2fs/ext2_balloc.c,v 1.7 2006/02/17 19:18:07 dillon Exp $
+ * $DragonFly: src/sys/vfs/gnu/ext2fs/ext2_balloc.c,v 1.8 2006/03/24 18:35:33 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -101,7 +101,8 @@ ext2_debug("ext2_balloc called (%d, %d, %d)\n",
                /* no new block is to be allocated, and no need to expand
                   the file */
                if (nb != 0 && ip->i_size >= (bn + 1) * fs->s_blocksize) {
-                       error = bread(vp, bn, fs->s_blocksize, &bp);
+                       error = bread(vp, lblktodoff(fs, bn), 
+                                     fs->s_blocksize, &bp);
                        if (error) {
                                brelse(bp);
                                return (error);
@@ -116,7 +117,8 @@ ext2_debug("ext2_balloc called (%d, %d, %d)\n",
                        osize = fragroundup(fs, blkoff(fs, ip->i_size));
                        nsize = fragroundup(fs, size);
                        if (nsize <= osize) {
-                               error = bread(vp, bn, osize, &bp);
+                               error = bread(vp, lblktodoff(fs, bn),
+                                             osize, &bp);
                                if (error) {
                                        brelse(bp);
                                        return (error);
@@ -143,12 +145,12 @@ ext2_debug("ext2_balloc called (%d, %d, %d)\n",
                            nsize, cred, &newb);
                        if (error)
                                return (error);
-                       bp = getblk(vp, bn, nsize, 0, 0);
-                       bp->b_bio2.bio_blkno = fsbtodb(fs, newb);
+                       bp = getblk(vp, lblktodoff(fs, bn), nsize, 0, 0);
+                       bp->b_bio2.bio_offset = fsbtodoff(fs, newb);
                        if (flags & B_CLRBUF)
                                vfs_bio_clrbuf(bp);
                }
-               ip->i_db[bn] = dbtofsb(fs, bp->b_bio2.bio_blkno);
+               ip->i_db[bn] = dofftofsb(fs, bp->b_bio2.bio_offset);
                ip->i_flag |= IN_CHANGE | IN_UPDATE;
                *bpp = bp;
                return (0);
@@ -190,8 +192,9 @@ ext2_debug("ext2_balloc called (%d, %d, %d)\n",
                    cred, &newb)) != 0)
                        return (error);
                nb = newb;
-               bp = getblk(vp, indirs[1].in_lbn, fs->s_blocksize, 0, 0);
-               bp->b_bio2.bio_blkno = fsbtodb(fs, newb);
+               bp = getblk(vp, lblktodoff(fs, indirs[1].in_lbn),
+                           fs->s_blocksize, 0, 0);
+               bp->b_bio2.bio_offset = fsbtodoff(fs, newb);
                vfs_bio_clrbuf(bp);
                /*
                 * Write synchronously so that indirect blocks
@@ -209,7 +212,8 @@ ext2_debug("ext2_balloc called (%d, %d, %d)\n",
         */
        for (i = 1;;) {
                error = bread(vp,
-                   indirs[i].in_lbn, (int)fs->s_blocksize, &bp);
+                             lblktodoff(fs, indirs[i].in_lbn), 
+                             (int)fs->s_blocksize, &bp);
                if (error) {
                        brelse(bp);
                        return (error);
@@ -232,7 +236,7 @@ ext2_debug("ext2_balloc called (%d, %d, %d)\n",
                         * Also, will it ever succeed ?
                         */
                        pref = ext2_blkpref(ip, lbn, indirs[i].in_off, bap,
-                                               bp->b_lblkno);
+                                               lblkno(fs, bp->b_loffset));
 #else
                        pref = ext2_blkpref(ip, lbn, 0, (daddr_t *)0, 0);
 #endif
@@ -242,8 +246,9 @@ ext2_debug("ext2_balloc called (%d, %d, %d)\n",
                        return (error);
                }
                nb = newb;
-               nbp = getblk(vp, indirs[i].in_lbn, fs->s_blocksize, 0, 0);
-               nbp->b_bio2.bio_blkno = fsbtodb(fs, nb);
+               nbp = getblk(vp, lblktodoff(fs, indirs[i].in_lbn),
+                            fs->s_blocksize, 0, 0);
+               nbp->b_bio2.bio_offset = fsbtodoff(fs, nb);
                vfs_bio_clrbuf(nbp);
                /*
                 * Write synchronously so that indirect blocks
@@ -270,15 +275,15 @@ ext2_debug("ext2_balloc called (%d, %d, %d)\n",
         */
        if (nb == 0) {
                pref = ext2_blkpref(ip, lbn, indirs[i].in_off, &bap[0], 
-                               bp->b_lblkno);
+                               lblkno(fs, bp->b_loffset));
                if ((error = ext2_alloc(ip,
                    lbn, pref, (int)fs->s_blocksize, cred, &newb)) != 0) {
                        brelse(bp);
                        return (error);
                }
                nb = newb;
-               nbp = getblk(vp, lbn, fs->s_blocksize, 0, 0);
-               nbp->b_bio2.bio_blkno = fsbtodb(fs, nb);
+               nbp = getblk(vp, lblktodoff(fs, lbn), fs->s_blocksize, 0, 0);
+               nbp->b_bio2.bio_offset = fsbtodoff(fs, nb);
                if (flags & B_CLRBUF)
                        vfs_bio_clrbuf(nbp);
                bap[indirs[i].in_off] = nb;
@@ -296,14 +301,15 @@ ext2_debug("ext2_balloc called (%d, %d, %d)\n",
        }
        brelse(bp);
        if (flags & B_CLRBUF) {
-               error = bread(vp, lbn, (int)fs->s_blocksize, &nbp);
+               error = bread(vp, lblktodoff(fs, lbn),
+                             (int)fs->s_blocksize, &nbp);
                if (error) {
                        brelse(nbp);
                        return (error);
                }
        } else {
-               nbp = getblk(vp, lbn, fs->s_blocksize, 0, 0);
-               nbp->b_bio2.bio_blkno = fsbtodb(fs, nb);
+               nbp = getblk(vp, lblktodoff(fs, lbn), fs->s_blocksize, 0, 0);
+               nbp->b_bio2.bio_offset = fsbtodoff(fs, nb);
        }
        *bpp = nbp;
        return (0);
index 48d58f3..11d6605 100644 (file)
@@ -38,7 +38,7 @@
  *
  *     @(#)ext2_inode.c        8.5 (Berkeley) 12/30/93
  * $FreeBSD: src/sys/gnu/ext2fs/ext2_inode.c,v 1.24.2.1 2000/08/03 00:52:57 peter Exp $
- * $DragonFly: src/sys/vfs/gnu/ext2fs/ext2_inode.c,v 1.11 2006/02/17 19:18:07 dillon Exp $
+ * $DragonFly: src/sys/vfs/gnu/ext2fs/ext2_inode.c,v 1.12 2006/03/24 18:35:33 dillon Exp $
  */
 
 #include "opt_quota.h"
@@ -63,8 +63,8 @@
 #include "fs.h"
 #include "ext2_extern.h"
 
-static int ext2_indirtrunc (struct inode *, daddr_t, daddr_t, daddr_t, int,
-           long *);
+static int ext2_indirtrunc (struct inode *, daddr_t, off_t, daddr_t,
+                           int, long *);
 
 /*
  * Update the access, modified, and inode change times as specified by the
@@ -91,9 +91,10 @@ ext2_update(struct vnode *vp, int waitfor)
        if (vp->v_mount->mnt_flag & MNT_RDONLY)
                return (0);
        fs = ip->i_e2fs;
-       if ((error = bread(ip->i_devvp,
-           fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),
-               (int)fs->s_blocksize, &bp)) != 0) {
+       error = bread(ip->i_devvp,
+                     fsbtodoff(fs, ino_to_fsba(fs, ip->i_number)),
+                     (int)fs->s_blocksize, &bp);
+       if (error) {
                brelse(bp);
                return (error);
        }
@@ -268,7 +269,7 @@ printf("ext2_truncate called %d to %d\n", VTOI(ovp)->i_number, length);
                bn = oip->i_ib[level];
                if (bn != 0) {
                        error = ext2_indirtrunc(oip, indir_lbn[level],
-                           fsbtodb(fs, bn), lastiblock[level], level, &count);
+                           fsbtodoff(fs, bn), lastiblock[level], level, &count);
                        if (error)
                                allerror = error;
                        blocksreleased += count;
@@ -365,7 +366,7 @@ done:
  */
 
 static int
-ext2_indirtrunc(struct inode *ip, daddr_t lbn, daddr_t dbn, daddr_t lastbn,
+ext2_indirtrunc(struct inode *ip, daddr_t lbn, off_t doffset, daddr_t lastbn,
                int level, long *countp)
 {
        int i;
@@ -395,17 +396,18 @@ ext2_indirtrunc(struct inode *ip, daddr_t lbn, daddr_t dbn, daddr_t lastbn,
         * to blocks to be free'd, and update on disk copy first.  Since
         * double(triple) indirect before single(double) indirect, calls
         * to bmap on these blocks will fail.  However, we already have
-        * the on disk address, so we have to set the bio_blkno field
+        * the on disk address, so we have to set the bio_offset field
         * explicitly instead of letting bread do everything for us.
         */
        vp = ITOV(ip);
-       bp = getblk(vp, lbn, (int)fs->s_blocksize, 0, 0);
+       bp = getblk(vp, lblktodoff(fs, lbn), (int)fs->s_blocksize, 0, 0);
        if (bp->b_flags & (B_DONE | B_DELWRI)) {
+               /* nop */
        } else {
                bp->b_flags |= B_READ;
                if (bp->b_bcount > bp->b_bufsize)
                        panic("ext2_indirtrunc: bad buffer size");
-               bp->b_bio2.bio_blkno = dbn;
+               bp->b_bio2.bio_offset = doffset;
                vfs_busy_pages(bp, 0);
                vn_strategy(vp, &bp->b_bio1);
                error = biowait(bp);
@@ -438,7 +440,7 @@ ext2_indirtrunc(struct inode *ip, daddr_t lbn, daddr_t dbn, daddr_t lastbn,
                        continue;
                if (level > SINGLE) {
                        if ((error = ext2_indirtrunc(ip, nlbn,
-                           fsbtodb(fs, nb), (daddr_t)-1, level - 1, &blkcount)) != 0)
+                           fsbtodoff(fs, nb), (daddr_t)-1, level - 1, &blkcount)) != 0)
                                allerror = error;
                        blocksreleased += blkcount;
                }
@@ -453,8 +455,9 @@ ext2_indirtrunc(struct inode *ip, daddr_t lbn, daddr_t dbn, daddr_t lastbn,
                last = lastbn % factor;
                nb = bap[i];
                if (nb != 0) {
-                       if ((error = ext2_indirtrunc(ip, nlbn, fsbtodb(fs, nb),
-                           last, level - 1, &blkcount)) != 0)
+                       error = ext2_indirtrunc(ip, nlbn, fsbtodoff(fs, nb),
+                                               last, level - 1, &blkcount);
+                       if (error)
                                allerror = error;
                        blocksreleased += blkcount;
                }
index 5235dd9..e1063b9 100644 (file)
@@ -5,7 +5,7 @@
  *  University of Utah, Department of Computer Science
  *
  * $FreeBSD: src/sys/gnu/ext2fs/ext2_linux_balloc.c,v 1.11.2.3 2001/08/14 18:03:19 gallatin Exp $
- * $DragonFly: src/sys/vfs/gnu/ext2fs/ext2_linux_balloc.c,v 1.6 2006/01/13 21:09:27 swildner Exp $
+ * $DragonFly: src/sys/vfs/gnu/ext2fs/ext2_linux_balloc.c,v 1.7 2006/03/24 18:35:33 dillon Exp $
  */
 /*
  *  linux/fs/ext2/balloc.c
@@ -69,12 +69,15 @@ read_block_bitmap(struct mount *mp, unsigned int block_group,
        int    error;
        
        gdp = get_group_desc (mp, block_group, NULL);
-       if ((error = bread (VFSTOUFS(mp)->um_devvp, 
-               fsbtodb(sb, gdp->bg_block_bitmap),sb->s_blocksize, &bh)) != 0)
+       error = bread(VFSTOUFS(mp)->um_devvp, 
+                     fsbtodoff(sb, gdp->bg_block_bitmap),
+                     sb->s_blocksize, &bh);
+       if (error) {
                panic ( "read_block_bitmap: "
                            "Cannot read block bitmap - "
                            "block_group = %d, block_bitmap = %lu",
                            block_group, (unsigned long) gdp->bg_block_bitmap);
+       }
        sb->s_block_bitmap_number[bitmap_nr] = block_group;
        sb->s_block_bitmap[bitmap_nr] = bh;
        LCK_BUF(bh)
index d7b1f8c..e095948 100644 (file)
@@ -5,7 +5,7 @@
  *  University of Utah, Department of Computer Science
  *
  * $FreeBSD: src/sys/gnu/ext2fs/ext2_linux_ialloc.c,v 1.13.2.2 2001/08/14 18:03:19 gallatin Exp $
- * $DragonFly: src/sys/vfs/gnu/ext2fs/ext2_linux_ialloc.c,v 1.7 2006/01/13 21:09:27 swildner Exp $
+ * $DragonFly: src/sys/vfs/gnu/ext2fs/ext2_linux_ialloc.c,v 1.8 2006/03/24 18:35:33 dillon Exp $
  */
 /*
  *  linux/fs/ext2/ialloc.c
@@ -106,7 +106,7 @@ read_inode_bitmap(struct mount *mp, unsigned long block_group,
 
        gdp = get_group_desc (mp, block_group, NULL);
        if ((error = bread (VFSTOUFS(mp)->um_devvp, 
-                           fsbtodb(sb, gdp->bg_inode_bitmap), 
+                           fsbtodoff(sb, gdp->bg_inode_bitmap), 
                            sb->s_blocksize, &bh)) != 0)
                panic ( "read_inode_bitmap:"
                            "Cannot read inode bitmap - "
@@ -266,7 +266,7 @@ inc_inode_version(struct inode *inode, struct ext2_group_desc *gdp, int mode)
        inode_block = gdp->bg_inode_table + (((inode->i_number - 1) %
                        EXT2_INODES_PER_GROUP(inode->i_sb)) /
                        EXT2_INODES_PER_BLOCK(inode->i_sb));
-       bh = bread (inode->i_sb->s_dev, inode_block, inode->i_sb->s_blocksize);
+       bh = bread (inode->i_sb->s_dev, dbtob(inode_block), inode->i_sb->s_blocksize);
        if (!bh) {
                printf ("inc_inode_version Cannot load inode table block - "
                            "inode=%lu, inode_block=%lu\n",
index 2919633..94b3a31 100644 (file)
@@ -38,7 +38,7 @@
  *
  *     @(#)ufs_readwrite.c     8.7 (Berkeley) 1/21/94
  * $FreeBSD: src/sys/gnu/ext2fs/ext2_readwrite.c,v 1.18.2.2 2000/12/22 18:44:33 dillon Exp $
- * $DragonFly: src/sys/vfs/gnu/ext2fs/ext2_readwrite.c,v 1.8 2006/01/13 21:09:27 swildner Exp $
+ * $DragonFly: src/sys/vfs/gnu/ext2fs/ext2_readwrite.c,v 1.9 2006/03/24 18:35:33 dillon Exp $
  */
 
 #define        BLKSIZE(a, b, c)        blksize(a, b, c)
@@ -61,6 +61,7 @@ ext2_read(struct vop_read_args *ap)
        FS *fs;
        struct buf *bp;
        daddr_t lbn, nextlbn;
+       off_t nextloffset;
        off_t bytesinfile;
        long size, xfersize, blkoffset;
        int error, orig_resid;
@@ -94,6 +95,7 @@ ext2_read(struct vop_read_args *ap)
                        break;
                lbn = lblkno(fs, uio->uio_offset);
                nextlbn = lbn + 1;
+               nextloffset = lblktodoff(fs, nextlbn);
                size = BLKSIZE(fs, ip, lbn);
                blkoffset = blkoff(fs, uio->uio_offset);
 
@@ -103,17 +105,20 @@ ext2_read(struct vop_read_args *ap)
                if (bytesinfile < xfersize)
                        xfersize = bytesinfile;
 
-               if (lblktosize(fs, nextlbn) >= ip->i_size)
-                       error = bread(vp, lbn, size, &bp);
-               else if ((vp->v_mount->mnt_flag & MNT_NOCLUSTERR) == 0)
-                       error = cluster_read(vp, ip->i_size, lbn, size, 
-                               uio->uio_resid, (ap->a_ioflag >> 16), &bp);
-               else if (seqcount > 1) {
+               if (nextloffset >= ip->i_size) {
+                       error = bread(vp, lblktodoff(fs, lbn), size, &bp);
+               } else if ((vp->v_mount->mnt_flag & MNT_NOCLUSTERR) == 0) {
+                       error = cluster_read(vp, (off_t)ip->i_size,
+                                            lblktodoff(fs, lbn), size, 
+                                            uio->uio_resid, 
+                                            (ap->a_ioflag >> 16), &bp);
+               } else if (seqcount > 1) {
                        int nextsize = BLKSIZE(fs, ip, nextlbn);
-                       error = breadn(vp, lbn,
-                           size, &nextlbn, &nextsize, 1, &bp);
-               } else
-                       error = bread(vp, lbn, size, &bp);
+                       error = breadn(vp, lblktodoff(fs, lbn),
+                                       size, &nextloffset, &nextsize, 1, &bp);
+               } else {
+                       error = bread(vp, lblktodoff(fs, lbn), size, &bp);
+               }
                if (error) {
                        brelse(bp);
                        bp = NULL;
@@ -266,7 +271,7 @@ ext2_write(struct vop_write_args *ap)
                } else if (xfersize + blkoffset == fs->s_frag_size) {
                        if ((vp->v_mount->mnt_flag & MNT_NOCLUSTERW) == 0) {
                                bp->b_flags |= B_CLUSTEROK;
-                               cluster_write(bp, ip->i_size, seqcount);
+                               cluster_write(bp, (off_t)ip->i_size, seqcount);
                        } else {
                                bawrite(bp);
                        }
index fee027a..bd52470 100644 (file)
@@ -38,7 +38,7 @@
  *
  *     @(#)ext2_subr.c 8.2 (Berkeley) 9/21/93
  * $FreeBSD: src/sys/gnu/ext2fs/ext2_subr.c,v 1.13.2.2 2000/08/03 18:48:27 peter Exp $
- * $DragonFly: src/sys/vfs/gnu/ext2fs/ext2_subr.c,v 1.9 2006/02/17 19:18:07 dillon Exp $
+ * $DragonFly: src/sys/vfs/gnu/ext2fs/ext2_subr.c,v 1.10 2006/03/24 18:35:33 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -80,7 +80,7 @@ ext2_blkatoff(struct vnode *vp, off_t offset, char **res, struct buf **bpp)
        bsize = blksize(fs, ip, lbn);
 
        *bpp = NULL;
-       if ((error = bread(vp, lbn, bsize, &bp)) != 0) {
+       if ((error = bread(vp, lblktodoff(fs, lbn), bsize, &bp)) != 0) {
                brelse(bp);
                return (error);
        }
@@ -95,28 +95,29 @@ void
 ext2_checkoverlap(struct buf *bp, struct inode *ip)
 {
        struct buf *ebp, *ep;
-       daddr_t start, last;
+       off_t start;
+       off_t last;
        struct vnode *vp;
 
        ebp = &buf[nbuf];
-       start = bp->b_bio2.bio_blkno;
-       last = start + btodb(bp->b_bcount) - 1;
+       start = bp->b_bio2.bio_offset;
+       last = start + bp->b_bcount - 1;
        for (ep = buf; ep < ebp; ep++) {
                if (ep == bp || (ep->b_flags & B_INVAL) ||
-                   ep->b_vp == NULLVP || ep->b_bio2.bio_blkno == (daddr_t)-1)
+                   ep->b_vp == NULLVP || ep->b_bio2.bio_offset == NOOFFSET)
                        continue;
-               if (VOP_BMAP(ep->b_vp, (daddr_t)0, &vp, NULL, NULL, NULL))
+               if (VOP_BMAP(ep->b_vp, (off_t)0, &vp, NULL, NULL, NULL))
                        continue;
                if (vp != ip->i_devvp)
                        continue;
                /* look for overlap */
-               if (ep->b_bcount == 0 || ep->b_bio2.bio_blkno > last ||
-                   ep->b_bio2.bio_blkno + btodb(ep->b_bcount) <= start)
+               if (ep->b_bcount == 0 || ep->b_bio2.bio_offset > last ||
+                   ep->b_bio2.bio_offset + ep->b_bcount <= start)
                        continue;
                vprint("Disk overlap", vp);
-               printf("\tstart %d, end %d overlap start %d, end %d\n",
-                       start, last, ep->b_bio2.bio_blkno,
-                       ep->b_bio2.bio_blkno + btodb(ep->b_bcount) - 1);
+               printf("\tstart %lld, end %lld overlap start %lld, end %lld\n",
+                       start, last, ep->b_bio2.bio_offset,
+                       ep->b_bio2.bio_offset + ep->b_bcount - 1);
                panic("Disk buffer overlap");
        }
 }
index 9424ffa..625d866 100644 (file)
@@ -38,7 +38,7 @@
  *
  *     @(#)ffs_vfsops.c        8.8 (Berkeley) 4/18/94
  *     $FreeBSD: src/sys/gnu/ext2fs/ext2_vfsops.c,v 1.63.2.7 2002/07/01 00:18:51 iedowse Exp $
- *     $DragonFly: src/sys/vfs/gnu/ext2fs/ext2_vfsops.c,v 1.32 2006/01/13 21:09:27 swildner Exp $
+ *     $DragonFly: src/sys/vfs/gnu/ext2fs/ext2_vfsops.c,v 1.33 2006/03/24 18:35:33 dillon Exp $
  */
 
 #include "opt_quota.h"
@@ -416,8 +416,8 @@ compute_sb_data(struct vnode *devvp, struct ext2_super_block *es,
         logic_sb_block = 0;
     
     for (i = 0; i < db_count; i++) {
-       error = bread(devvp , fsbtodb(fs, logic_sb_block + i + 1), 
-               fs->s_blocksize, &fs->s_group_desc[i]);
+       error = bread(devvp, fsbtodoff(fs, logic_sb_block + i + 1), 
+                     fs->s_blocksize, &fs->s_group_desc[i]);
        if(error) {
            for (j = 0; j < i; j++)
                brelse(fs->s_group_desc[j]);
@@ -495,7 +495,7 @@ ext2_reload(struct mount *mountp, struct ucred *cred, struct thread *td)
         * Step 2: re-read superblock from disk.
         * constants have been adjusted for ext2
         */
-       if ((error = bread(devvp, SBLOCK, SBSIZE, &bp)) != 0)
+       if ((error = bread(devvp, dbtob(SBLOCK), SBSIZE, &bp)) != 0)
                return (error);
        es = (struct ext2_super_block *)bp->b_data;
        if (ext2_check_sb_compat(es, devvp->v_rdev, 0) != 0) {
@@ -558,8 +558,9 @@ ext2_reload_scan2(struct mount *mp, struct vnode *vp, void *data)
         * Step 6: re-read inode data for all active vnodes.
         */
        ip = VTOI(vp);
-       error = bread(info->devvp, fsbtodb(info->fs, ino_to_fsba(info->fs, ip->i_number)),
-                   (int)info->fs->s_blocksize, &bp);
+       error = bread(info->devvp, 
+                     fsbtodoff(info->fs, ino_to_fsba(info->fs, ip->i_number)),
+                     (int)info->fs->s_blocksize, &bp);
        if (error)
                return (error);
        ext2_ei2di((struct ext2_inode *) ((char *)bp->b_data + 
@@ -622,7 +623,7 @@ ext2_mountfs(struct vnode *devvp, struct mount *mp, struct thread *td)
 
        bp = NULL;
        ump = NULL;
-       if ((error = bread(devvp, SBLOCK, SBSIZE, &bp)) != 0)
+       if ((error = bread(devvp, dbtob(SBLOCK), SBSIZE, &bp)) != 0)
                goto out;
        es = (struct ext2_super_block *)bp->b_data;
        if (ext2_check_sb_compat(es, dev, ronly) != 0) {
@@ -1014,8 +1015,9 @@ restart:
 #if 0
 printf("ext2_vget(%d) dbn= %d ", ino, fsbtodb(fs, ino_to_fsba(fs, ino)));
 #endif
-       if ((error = bread(ump->um_devvp, fsbtodb(fs, ino_to_fsba(fs, ino)),
-           (int)fs->s_blocksize, &bp)) != 0) {
+       error = bread(ump->um_devvp, fsbtodoff(fs, ino_to_fsba(fs, ino)),
+                     (int)fs->s_blocksize, &bp);
+       if (error) {
                /*
                 * The inode does not contain anything useful, so it would
                 * be misleading to leave it on its hash chain. With mode
@@ -1134,7 +1136,7 @@ ext2_sbupdate(struct ufsmount *mp, int waitfor)
 /*
 printf("\nupdating superblock, waitfor=%s\n", waitfor == MNT_WAIT ? "yes":"no");
 */
-       bp = getblk(mp->um_devvp, SBLOCK, SBSIZE, 0, 0);
+       bp = getblk(mp->um_devvp, lblktodoff(fs, SBLOCK), SBSIZE, 0, 0);
        bcopy((caddr_t)es, bp->b_data, (u_int)sizeof(struct ext2_super_block));
        if (waitfor == MNT_WAIT)
                error = bwrite(bp);
index aca2144..611a53f 100644 (file)
@@ -38,7 +38,7 @@
  *
  *     @(#)fs.h        8.7 (Berkeley) 4/19/94
  * $FreeBSD: src/sys/gnu/ext2fs/fs.h,v 1.5.2.1 2000/11/11 13:12:45 bde Exp $
- * $DragonFly: src/sys/vfs/gnu/ext2fs/fs.h,v 1.6 2005/06/06 15:09:38 drhodus Exp $
+ * $DragonFly: src/sys/vfs/gnu/ext2fs/fs.h,v 1.7 2006/03/24 18:35:33 dillon Exp $
  */
 
 /*
 #define lblktosize(fs, blk)    /* calculates (blk * fs->fs_bsize) */ \
        ((blk) << (fs->s_bshift))
 
+/*
+ * Used when converting logical blocks to offsets for getblk, bread,
+ * etc.
+ */
+#define lblktodoff(fs, blk)    /* calculates (blk * fs->fs_bsize) */ \
+       ((off_t)(blk) << (fs)->s_bshift)
+#define fsbtodoff(fs, blk)     /* calculates (blk * fs->fs_fsize) */ \
+       ((off_t)(blk) * (fs)->s_frag_size)
+#define dofftofsb(fs, blk)     /* calculates blk / fs->fs_fsize */   \
+       ((daddr_t)((blk) / (fs)->s_frag_size))
+
 #define lblkno(fs, loc)                /* calculates (loc / fs->fs_bsize) */ \
        ((loc) >> (fs->s_bshift))
 
index c2b510a..8336b0e 100644 (file)
@@ -24,7 +24,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/fs/hpfs/hpfs.h,v 1.1 1999/12/09 19:09:58 semenu Exp $
- * $DragonFly: src/sys/vfs/hpfs/hpfs.h,v 1.14 2004/10/12 19:20:56 dillon Exp $
+ * $DragonFly: src/sys/vfs/hpfs/hpfs.h,v 1.15 2006/03/24 18:35:33 dillon Exp $
  */
 
 /*#define HPFS_DEBUG 10*/
@@ -383,6 +383,7 @@ MALLOC_DECLARE(M_HPFSNO);
 #define        VTOHP(v)        ((struct hpfsnode *)((v)->v_data))
 #define        HPTOV(h)        ((struct vnode *)((h)->h_vp))
 #define        FID(f)          (*((lsn_t *)(f)->fid_data))
+#define dbtodoff(dbn)  ((off_t)(dbn) << DEV_BSHIFT)
 
 #if defined(__NetBSD__)
 #define MALLOC_DEFINE(a, b, c)
index 88f5b38..3dafa12 100644 (file)
@@ -24,7 +24,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/fs/hpfs/hpfs_alsubr.c,v 1.1 1999/12/09 19:09:58 semenu Exp $
- * $DragonFly: src/sys/vfs/hpfs/hpfs_alsubr.c,v 1.6 2006/01/13 21:09:27 swildner Exp $
+ * $DragonFly: src/sys/vfs/hpfs/hpfs_alsubr.c,v 1.7 2006/03/24 18:35:33 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -86,7 +86,8 @@ dive:
 
                                if (bp)
                                        brelse(bp);
-                               error = bread(hp->h_devvp, anp->an_lsn, 
+                               error = bread(hp->h_devvp,
+                                             dbtodoff(anp->an_lsn), 
                                              DEV_BSIZE, &bp);
                                if (error) {
                                        printf("hpfs_hpbmap: bread error\n");
@@ -174,7 +175,7 @@ hpfs_allocalsec(struct hpfsmount *hpmp, lsn_t parlsn, struct buf **bpp)
        if (error) 
                return (error);
 
-       bp = getblk(hpmp->hpm_devvp, lsn, DEV_BSIZE, 0, 0);
+       bp = getblk(hpmp->hpm_devvp, dbtodoff(lsn), DEV_BSIZE, 0, 0);
        clrbuf(bp);
 
        /* Fill AlSec info */
index 1fa0bf8..725398d 100644 (file)
@@ -24,7 +24,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/fs/hpfs/hpfs_subr.c,v 1.1 1999/12/09 19:09:59 semenu Exp $
- * $DragonFly: src/sys/vfs/hpfs/hpfs_subr.c,v 1.6 2003/08/15 07:26:15 dillon Exp $
+ * $DragonFly: src/sys/vfs/hpfs/hpfs_subr.c,v 1.7 2006/03/24 18:35:33 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -74,7 +74,8 @@ hpfs_bmdeinit(
                for (i=0; i<hpmp->hpm_dbnum; i++) {
                        dprintf(("[%d: 0x%x] ", i, hpmp->hpm_bmind[i]));
 
-                       bp = getblk(hpmp->hpm_devvp, hpmp->hpm_bmind[i],
+                       bp = getblk(hpmp->hpm_devvp,
+                                   dbtodoff(hpmp->hpm_bmind[i]),
                                    BMSIZE, 0, 0);
                        clrbuf(bp);
 
@@ -115,7 +116,7 @@ hpfs_bminit(
        MALLOC(hpmp->hpm_bitmap, u_int8_t *, hpmp->hpm_dbnum * BMSIZE,
                M_HPFSMNT, M_WAITOK);
 
-       error = bread(hpmp->hpm_devvp, hpmp->hpm_su.su_bitmap.lsn1,
+       error = bread(hpmp->hpm_devvp, dbtodoff(hpmp->hpm_su.su_bitmap.lsn1),
                ((hpmp->hpm_dbnum + 0x7F) & ~(0x7F)) << 2, &bp);
        if (error) {
                brelse(bp);
@@ -134,7 +135,7 @@ hpfs_bminit(
        for (i=0; i<hpmp->hpm_dbnum; i++) {
                dprintf(("[%d: 0x%x] ", i, hpmp->hpm_bmind[i]));
 
-               error = bread(hpmp->hpm_devvp, hpmp->hpm_bmind[i],
+               error = bread(hpmp->hpm_devvp, dbtodoff(hpmp->hpm_bmind[i]),
                                BMSIZE, &bp);
                if (error) {
                        brelse(bp);
@@ -216,7 +217,7 @@ hpfs_cpload (
        struct cpdsec * cpdsp;
        int error, i;
 
-       error = bread(hpmp->hpm_devvp, cpibp->b_cpdsec, DEV_BSIZE, &bp);
+       error = bread(hpmp->hpm_devvp, dbtodoff(cpibp->b_cpdsec), DEV_BSIZE, &bp);
        if (error) {
                brelse(bp);
                return (error);
@@ -279,7 +280,7 @@ hpfs_cpinit (
        lsn = hpmp->hpm_sp.sp_cpi;
 
        while (cpicnt > 0) {
-               error = bread(hpmp->hpm_devvp, lsn, DEV_BSIZE, &bp);
+               error = bread(hpmp->hpm_devvp, dbtodoff(lsn), DEV_BSIZE, &bp);
                if (error) {
                        brelse(bp);
                        return (error);
@@ -552,7 +553,7 @@ dive:
        dprintf(("[dive 0x%x] ", lsn));
        if (bp != NULL)
                brelse(bp);
-       error = bread(dhp->h_devvp, lsn, D_BSIZE, &bp);
+       error = bread(dhp->h_devvp, dbtodoff(lsn), D_BSIZE, &bp);
        if (error)
                goto failed;
 
@@ -731,7 +732,7 @@ hpfs_update (
        if (!(hp->h_flag & H_CHANGE))
                return (0);
 
-       bp = getblk(hp->h_devvp, hp->h_no, FNODESIZE, 0, 0);
+       bp = getblk(hp->h_devvp, dbtodoff(hp->h_no), FNODESIZE, 0, 0);
        clrbuf(bp);
 
        bcopy (&hp->h_fn, bp->b_data, sizeof(struct fnode));
@@ -842,7 +843,7 @@ hpfs_breadstruct (
 
        *bpp = NULL;
 
-       error = bread(hpmp->hpm_devvp, lsn, len, &bp);
+       error = bread(hpmp->hpm_devvp, dbtodoff(lsn), len, &bp);
        if (error) {
                brelse(bp);
                return (error);
index a6c5898..5fb57f6 100644 (file)
@@ -24,7 +24,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/fs/hpfs/hpfs_vfsops.c,v 1.3.2.2 2001/12/25 01:44:45 dillon Exp $
- * $DragonFly: src/sys/vfs/hpfs/hpfs_vfsops.c,v 1.31 2006/01/13 21:09:27 swildner Exp $
+ * $DragonFly: src/sys/vfs/hpfs/hpfs_vfsops.c,v 1.32 2006/03/24 18:35:33 dillon Exp $
  */
 
 
@@ -269,14 +269,14 @@ hpfs_mountfs(struct vnode *devvp, struct mount *mp, struct hpfs_args *argsp,
        bzero(hpmp, sizeof(struct hpfsmount));
 
        /* Read in SuperBlock */
-       error = bread(devvp, SUBLOCK, SUSIZE, &bp);
+       error = bread(devvp, dbtodoff(SUBLOCK), SUSIZE, &bp);
        if (error)
                goto failed;
        bcopy(bp->b_data, &hpmp->hpm_su, sizeof(struct sublock));
        brelse(bp); bp = NULL;
 
        /* Read in SpareBlock */
-       error = bread(devvp, SPBLOCK, SPSIZE, &bp);
+       error = bread(devvp, dbtodoff(SPBLOCK), SPSIZE, &bp);
        if (error)
                goto failed;
        bcopy(bp->b_data, &hpmp->hpm_sp, sizeof(struct spblock));
@@ -531,7 +531,7 @@ hpfs_vget(struct mount *mp, ino_t ino, struct vnode **vpp)
 
        LOCKMGR(&hpfs_hphash_lock, LK_RELEASE, NULL, NULL);
 
-       error = bread(hpmp->hpm_devvp, ino, FNODESIZE, &bp);
+       error = bread(hpmp->hpm_devvp, dbtodoff(ino), FNODESIZE, &bp);
        if (error) {
                printf("hpfs_vget: can't read ino %"PRId64"\n",ino);
                vx_put(vp);
index 4b26ea2..ece5f55 100644 (file)
@@ -24,7 +24,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/fs/hpfs/hpfs_vnops.c,v 1.2.2.2 2002/01/15 18:35:09 semenu Exp $
- * $DragonFly: src/sys/vfs/hpfs/hpfs_vnops.c,v 1.29 2006/02/17 19:18:07 dillon Exp $
+ * $DragonFly: src/sys/vfs/hpfs/hpfs_vnops.c,v 1.30 2006/03/24 18:35:33 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -126,7 +126,7 @@ hpfs_fsync(struct vop_fsync_args *ap)
 #ifdef DIAGNOSTIC
 loop:
 #endif
-       vfsync(vp, ap->a_waitfor, 0, (daddr_t)-1, NULL, NULL);
+       vfsync(vp, ap->a_waitfor, 0, NOOFFSET, NULL, NULL);
 #ifdef DIAGNOSTIC
        if (ap->a_waitfor == MNT_WAIT && !RB_EMPTY(&vp->v_rbdirty_tree)) {
                vprint("hpfs_fsync: dirty", vp);
@@ -275,28 +275,35 @@ hpfs_ioctl(struct vop_ioctl_args *ap)
 /*
  * Map file offset to disk offset.
  *
- * hpfs_bmap(struct vnode *a_vp, daddr_t a_bn, struct vnode **a_vpp,
- *          daddr_t *a_bnp, int *a_runp, int *a_runb)
+ * hpfs_bmap(struct vnode *a_vp, off_t a_loffset, struct vnode **a_vpp,
+ *          off_t *a_doffsetp, int *a_runp, int *a_runb)
  */
 int
 hpfs_bmap(struct vop_bmap_args *ap)
 {
        struct hpfsnode *hp = VTOHP(ap->a_vp);
        int error;
+       daddr_t lbn;
+       daddr_t dbn;
 
        if (ap->a_vpp != NULL) 
                *ap->a_vpp = hp->h_devvp;
-#if defined(__DragonFly__)
        if (ap->a_runb != NULL)
                *ap->a_runb = 0;
-#endif
-       if (ap->a_bnp == NULL)
+       if (ap->a_doffsetp == NULL)
                return (0);
 
        dprintf(("hpfs_bmap(0x%x, 0x%x): ",hp->h_no, ap->a_bn));
 
-       error = hpfs_hpbmap (hp, ap->a_bn, ap->a_bnp, ap->a_runp);
+       lbn = ap->a_loffset >> DEV_BSHIFT;
+       KKASSERT(((int)ap->a_loffset & DEV_BMASK) == 0);
 
+       error = hpfs_hpbmap (hp, lbn, &dbn, ap->a_runp);
+       if (error || dbn == (daddr_t)-1) {
+               *ap->a_doffsetp = NOOFFSET;
+       } else {
+               *ap->a_doffsetp = (off_t)dbn << DEV_BSHIFT;
+       }
        return (error);
 }
 
@@ -339,7 +346,7 @@ hpfs_read(struct vop_read_args *ap)
                if (toread == 0) 
                        break;
 
-               error = bread(hp->h_devvp, bn, xfersz, &bp);
+               error = bread(hp->h_devvp, dbtodoff(bn), xfersz, &bp);
                if (error) {
                        brelse(bp);
                        break;
@@ -403,10 +410,10 @@ hpfs_write(struct vop_write_args *ap)
                        bn, runl, towrite, xfersz));
 
                if ((off == 0) && (towrite == xfersz)) {
-                       bp = getblk(hp->h_devvp, bn, xfersz, 0, 0);
+                       bp = getblk(hp->h_devvp, dbtodoff(bn), xfersz, 0, 0);
                        clrbuf(bp);
                } else {
-                       error = bread(hp->h_devvp, bn, xfersz, &bp);
+                       error = bread(hp->h_devvp, dbtodoff(bn), xfersz, &bp);
                        if (error) {
                                brelse(bp);
                                return (error);
@@ -690,8 +697,8 @@ hpfs_strategy(struct vop_strategy_args *ap)
                panic("hpfs_strategy: spec");
 
        nbio = push_bio(bio);
-       if (nbio->bio_blkno == (daddr_t)-1) {
-               error = VOP_BMAP(vp, bio->bio_blkno, NULL, &nbio->bio_blkno,
+       if (nbio->bio_offset == NOOFFSET) {
+               error = VOP_BMAP(vp, bio->bio_offset, NULL, &nbio->bio_offset,
                                 NULL, NULL);
                if (error) {
                        printf("hpfs_strategy: VOP_BMAP FAILED %d\n", error);
@@ -701,10 +708,10 @@ hpfs_strategy(struct vop_strategy_args *ap)
                        biodone(bio);
                        return (error);
                }
-               if (nbio->bio_blkno == (daddr_t)-1)
+               if (nbio->bio_offset == NOOFFSET)
                        vfs_bio_clrbuf(bp);
        }
-       if (nbio->bio_blkno == (daddr_t)-1) {
+       if (nbio->bio_offset == NOOFFSET) {
                /* I/O was never started on nbio, must biodone(bio) */
                biodone(bio);
                return (0);
@@ -924,7 +931,7 @@ hpfs_readdir(struct vop_readdir_args *ap)
 
 dive:
        dprintf(("[dive 0x%x] ", lsn));
-       error = bread(hp->h_devvp, lsn, D_BSIZE, &bp);
+       error = bread(hp->h_devvp, dbtodoff(lsn), D_BSIZE, &bp);
        if (error) {
                brelse(bp);
                return (error);
index d76a8e5..d7f0743 100644 (file)
  *
  *     @(#)cd9660_bmap.c       8.3 (Berkeley) 1/23/94
  * $FreeBSD: src/sys/isofs/cd9660/cd9660_bmap.c,v 1.8 1999/08/28 00:46:06 peter Exp $
- * $DragonFly: src/sys/vfs/isofs/cd9660/cd9660_bmap.c,v 1.4 2004/04/12 23:18:55 cpressey Exp $
+ * $DragonFly: src/sys/vfs/isofs/cd9660/cd9660_bmap.c,v 1.5 2006/03/24 18:35:33 dillon Exp $
  */
 
 #include <sys/param.h>
+#include <sys/systm.h>
 #include <sys/vnode.h>
 #include <sys/mount.h>
 
  * number on the disk. The conversion is done by using the logical block
  * number to index into the data block (extent) for the file.
  *
- * cd9660_bmap(struct vnode *a_vp, daddr_t a_bn, struct vnode **a_vpp,
- *             daddr_t *a_bnp, int *a_runp,