21 files changed, 206 insertions, 171 deletions

diff --git a/sys/dev/aac/aac.c b/sys/dev/aac/aac.c
index 2fec4cf846ec..57017bbc2cd5 100644
--- a/sys/dev/aac/aac.c
+++ b/sys/dev/aac/aac.c
@@ -2875,7 +2875,7 @@ aac_query_disk(struct aac_softc *sc, caddr_t uptr)
 		query_disk.Lun = 0;
 		query_disk.UnMapped = 0;
 		sprintf(&query_disk.diskDeviceName[0], "%s%d",
-		        disk->ad_disk.d_name, disk->ad_disk.d_unit);
+		        disk->ad_disk->d_name, disk->ad_disk->d_unit);
 	}
 	AAC_LOCK_RELEASE(&sc->aac_container_lock);
 
diff --git a/sys/dev/aac/aac_disk.c b/sys/dev/aac/aac_disk.c
index 382b64494861..2231a0e0d7c6 100644
--- a/sys/dev/aac/aac_disk.c
+++ b/sys/dev/aac/aac_disk.c
@@ -357,18 +357,20 @@ aac_disk_attach(device_t dev)
 
 	/* attach a generic disk device to ourselves */
 	sc->unit = device_get_unit(dev);
-	sc->ad_disk.d_drv1 = sc;
-	sc->ad_disk.d_name = "aacd";
-	sc->ad_disk.d_maxsize = aac_iosize_max;
-	sc->ad_disk.d_open = aac_disk_open;
-	sc->ad_disk.d_close = aac_disk_close;
-	sc->ad_disk.d_strategy = aac_disk_strategy;
-	sc->ad_disk.d_dump = aac_disk_dump;
-	sc->ad_disk.d_sectorsize = AAC_BLOCK_SIZE;
-	sc->ad_disk.d_mediasize = (off_t)sc->ad_size * AAC_BLOCK_SIZE;
-	sc->ad_disk.d_fwsectors = sc->ad_sectors;
-	sc->ad_disk.d_fwheads = sc->ad_heads;
-	disk_create(sc->unit, &sc->ad_disk, DISKFLAG_NOGIANT, NULL, NULL);
+	sc->ad_disk = disk_alloc();
+	sc->ad_disk->d_drv1 = sc;
+	sc->ad_disk->d_name = "aacd";
+	sc->ad_disk->d_maxsize = aac_iosize_max;
+	sc->ad_disk->d_open = aac_disk_open;
+	sc->ad_disk->d_close = aac_disk_close;
+	sc->ad_disk->d_strategy = aac_disk_strategy;
+	sc->ad_disk->d_dump = aac_disk_dump;
+	sc->ad_disk->d_sectorsize = AAC_BLOCK_SIZE;
+	sc->ad_disk->d_mediasize = (off_t)sc->ad_size * AAC_BLOCK_SIZE;
+	sc->ad_disk->d_fwsectors = sc->ad_sectors;
+	sc->ad_disk->d_fwheads = sc->ad_heads;
+	sc->ad_disk->d_unit = sc->unit;
+	disk_create(sc->ad_disk, DISK_VERSION);
 
 	return (0);
 }
@@ -388,7 +390,7 @@ aac_disk_detach(device_t dev)
 	if (sc->ad_flags & AAC_DISK_OPEN)
 		return(EBUSY);
 
-	disk_destroy(&sc->ad_disk);
+	disk_destroy(sc->ad_disk);
 
 	return(0);
 }
diff --git a/sys/dev/aac/aacvar.h b/sys/dev/aac/aacvar.h
index f2ee0f3b1b44..a4b30c396746 100644
--- a/sys/dev/aac/aacvar.h
+++ b/sys/dev/aac/aacvar.h
@@ -125,7 +125,7 @@ struct aac_disk
 	device_t			ad_dev;
 	struct aac_softc		*ad_controller;
 	struct aac_container		*ad_container;
-	struct disk			ad_disk;
+	struct disk			*ad_disk;
 	int				ad_flags;
 #define AAC_DISK_OPEN	(1<<0)
 	int				ad_cylinders;
diff --git a/sys/dev/amr/amr_disk.c b/sys/dev/amr/amr_disk.c
index 42d09a239a83..a93e1edd0f9e 100644
--- a/sys/dev/amr/amr_disk.c
+++ b/sys/dev/amr/amr_disk.c
@@ -134,10 +134,10 @@ amrd_open(struct disk *dp)
     label->d_secpercyl  = sc->amrd_drive->al_sectors * sc->amrd_drive->al_heads;
     label->d_secperunit = sc->amrd_drive->al_size;
 #else
-    sc->amrd_disk.d_sectorsize = AMR_BLKSIZE;
-    sc->amrd_disk.d_mediasize = (off_t)sc->amrd_drive->al_size * AMR_BLKSIZE;
-    sc->amrd_disk.d_fwsectors = sc->amrd_drive->al_sectors;
-    sc->amrd_disk.d_fwheads = sc->amrd_drive->al_heads;
+    sc->amrd_disk->d_sectorsize = AMR_BLKSIZE;
+    sc->amrd_disk->d_mediasize = (off_t)sc->amrd_drive->al_size * AMR_BLKSIZE;
+    sc->amrd_disk->d_fwsectors = sc->amrd_drive->al_sectors;
+    sc->amrd_disk->d_fwheads = sc->amrd_drive->al_heads;
 #endif
 
     return (0);
@@ -247,13 +247,16 @@ amrd_attach(device_t dev)
 		  sc->amrd_drive->al_size, sc->amrd_drive->al_properties & AMR_DRV_RAID_MASK, 
 		  amr_describe_code(amr_table_drvstate, AMR_DRV_CURSTATE(sc->amrd_drive->al_state)));
 
-    sc->amrd_disk.d_drv1 = sc;
-    sc->amrd_disk.d_maxsize = (AMR_NSEG - 1) * PAGE_SIZE;
-    sc->amrd_disk.d_open = amrd_open;
-    sc->amrd_disk.d_strategy = amrd_strategy;
-    sc->amrd_disk.d_name = "amrd";
-    sc->amrd_disk.d_dump = (dumper_t *)amrd_dump;
-    disk_create(sc->amrd_unit, &sc->amrd_disk, 0, NULL, NULL);
+    sc->amrd_disk = disk_alloc();
+    sc->amrd_disk->d_drv1 = sc;
+    sc->amrd_disk->d_maxsize = (AMR_NSEG - 1) * PAGE_SIZE;
+    sc->amrd_disk->d_open = amrd_open;
+    sc->amrd_disk->d_strategy = amrd_strategy;
+    sc->amrd_disk->d_name = "amrd";
+    sc->amrd_disk->d_dump = (dumper_t *)amrd_dump;
+    sc->amrd_disk->d_unit = sc->amrd_unit;
+    sc->amrd_disk->d_flags = DISKFLAG_NEEDSGIANT;
+    disk_create(sc->amrd_disk, DISK_VERSION);
 #ifdef FREEBSD_4
     disks_registered++;
 #endif
@@ -268,14 +271,14 @@ amrd_detach(device_t dev)
 
     debug_called(1);
 
-    if (sc->amrd_disk.d_flags & DISKFLAG_OPEN)
+    if (sc->amrd_disk->d_flags & DISKFLAG_OPEN)
 	return(EBUSY);
 
 #ifdef FREEBSD_4
     if (--disks_registered == 0)
 	cdevsw_remove(&amrddisk_cdevsw);
 #else
-    disk_destroy(&sc->amrd_disk);
+    disk_destroy(sc->amrd_disk);
 #endif
     return(0);
 }
diff --git a/sys/dev/amr/amrvar.h b/sys/dev/amr/amrvar.h
index 1191954a6ede..2378c97dd8ad 100644
--- a/sys/dev/amr/amrvar.h
+++ b/sys/dev/amr/amrvar.h
@@ -253,7 +253,7 @@ struct amrd_softc
     device_t		amrd_dev;
     struct amr_softc	*amrd_controller;
     struct amr_logdrive	*amrd_drive;
-    struct disk		amrd_disk;
+    struct disk		*amrd_disk;
     int			amrd_unit;
 };
 
diff --git a/sys/dev/ata/ata-disk.c b/sys/dev/ata/ata-disk.c
index 25b9ef9dcb40..504049f3219c 100644
--- a/sys/dev/ata/ata-disk.c
+++ b/sys/dev/ata/ata-disk.c
@@ -131,20 +131,22 @@ ad_attach(struct ata_device *atadev)
     ad_config(atadev);
 
     /* lets create the disk device */
-    adp->disk.d_open = adopen;
-    adp->disk.d_strategy = adstrategy;
-    adp->disk.d_dump = addump;
-    adp->disk.d_name = "ad";
-    adp->disk.d_drv1 = adp;
+    adp->disk = disk_alloc();
+    adp->disk->d_open = adopen;
+    adp->disk->d_strategy = adstrategy;
+    adp->disk->d_dump = addump;
+    adp->disk->d_name = "ad";
+    adp->disk->d_drv1 = adp;
     if (atadev->channel->dma)
-	adp->disk.d_maxsize = atadev->channel->dma->max_iosize;
+	adp->disk->d_maxsize = atadev->channel->dma->max_iosize;
     else
-	adp->disk.d_maxsize = DFLTPHYS;
-    adp->disk.d_sectorsize = DEV_BSIZE;
-    adp->disk.d_mediasize = DEV_BSIZE * (off_t)adp->total_secs;
-    adp->disk.d_fwsectors = adp->sectors;
-    adp->disk.d_fwheads = adp->heads;
-    disk_create(adp->lun, &adp->disk, DISKFLAG_NOGIANT, NULL, NULL);
+	adp->disk->d_maxsize = DFLTPHYS;
+    adp->disk->d_sectorsize = DEV_BSIZE;
+    adp->disk->d_mediasize = DEV_BSIZE * (off_t)adp->total_secs;
+    adp->disk->d_fwsectors = adp->sectors;
+    adp->disk->d_fwheads = adp->heads;
+    adp->disk->d_unit = adp->lun;
+    disk_create(adp->disk, DISK_VERSION);
 
     /* announce we are here */
     ad_print(adp);
@@ -167,7 +169,7 @@ ad_detach(struct ata_device *atadev)
     mtx_lock(&adp->queue_mtx);
     bioq_flush(&adp->queue, NULL, ENXIO);
     mtx_unlock(&adp->queue_mtx);
-    disk_destroy(&adp->disk);
+    disk_destroy(adp->disk);
     ata_prtdev(atadev, "WARNING - removed from configuration\n");
     ata_free_name(atadev);
     ata_free_lun(&adp_lun_map, adp->lun);
@@ -208,7 +210,7 @@ adopen(struct disk *dp)
 {
     struct ad_softc *adp = dp->d_drv1;
 
-    if (adp->device->flags & ATA_D_DETACHING)
+    if (adp == NULL || adp->device->flags & ATA_D_DETACHING)
 	return ENXIO;
     return 0;
 }
diff --git a/sys/dev/ata/ata-disk.h b/sys/dev/ata/ata-disk.h
index 1373fd2acc47..778169c83979 100644
--- a/sys/dev/ata/ata-disk.h
+++ b/sys/dev/ata/ata-disk.h
@@ -47,5 +47,5 @@ struct ad_softc {
 
     struct mtx			queue_mtx;	/* queue lock */
     struct bio_queue_head	queue;		/* head of request queue */
-    struct disk			disk;		/* disklabel/slice stuff */
+    struct disk			*disk;		/* disklabel/slice stuff */
 };
diff --git a/sys/dev/ata/ata-raid.c b/sys/dev/ata/ata-raid.c
index ba720af4953c..be57886d5b9d 100644
--- a/sys/dev/ata/ata-raid.c
+++ b/sys/dev/ata/ata-raid.c
@@ -177,16 +177,19 @@ ar_attach_raid(struct ar_softc *rdp, int update)
     int disk;
 
     ar_config_changed(rdp, update);
-    rdp->disk.d_strategy = arstrategy;
-    rdp->disk.d_dump = ardump;
-    rdp->disk.d_name = "ar";
-    rdp->disk.d_sectorsize = DEV_BSIZE;
-    rdp->disk.d_mediasize = (off_t)rdp->total_sectors * DEV_BSIZE;
-    rdp->disk.d_fwsectors = rdp->sectors;
-    rdp->disk.d_fwheads = rdp->heads;
-    rdp->disk.d_maxsize = 128 * DEV_BSIZE;
-    rdp->disk.d_drv1 = rdp;
-    disk_create(rdp->lun, &rdp->disk, 0, NULL, NULL);
+    rdp->disk = disk_alloc();
+    rdp->disk->d_strategy = arstrategy;
+    rdp->disk->d_dump = ardump;
+    rdp->disk->d_name = "ar";
+    rdp->disk->d_sectorsize = DEV_BSIZE;
+    rdp->disk->d_mediasize = (off_t)rdp->total_sectors * DEV_BSIZE;
+    rdp->disk->d_fwsectors = rdp->sectors;
+    rdp->disk->d_fwheads = rdp->heads;
+    rdp->disk->d_maxsize = 128 * DEV_BSIZE;
+    rdp->disk->d_drv1 = rdp;
+    rdp->disk->d_unit = rdp->lun;
+    rdp->disk->d_flags = DISKFLAG_NEEDSGIANT;
+    disk_create(rdp->disk, DISK_VERSION);
 
     printf("ar%d: %lluMB <ATA ", rdp->lun, (unsigned long long)
 	   (rdp->total_sectors / ((1024L * 1024L) / DEV_BSIZE)));
@@ -457,7 +460,7 @@ ata_raid_delete(int array)
 	ar_promise_write_conf(rdp);
     else
 	ar_highpoint_write_conf(rdp);
-    disk_destroy(&rdp->disk);
+    disk_destroy(rdp->disk);
     free(rdp, M_AR);
     ar_table[array] = NULL;
     return 0;
@@ -538,7 +541,7 @@ ardump(void *arg, void *virtual, vm_offset_t physical,
     if (length == 0) {
 	for (drv = 0; drv < rdp->total_disks; drv++) {
 	    if (rdp->disks[drv].flags & AR_DF_ONLINE) {
-		ap = &AD_SOFTC(rdp->disks[drv])->disk;
+		ap = AD_SOFTC(rdp->disks[drv])->disk;
 		(void) ap->d_dump(ap, NULL, 0, 0, 0);
 	    }
 	}
@@ -603,7 +606,7 @@ ardump(void *arg, void *virtual, vm_offset_t physical,
 	case AR_F_SPAN:
 	case AR_F_RAID0:
 	    if (rdp->disks[drv].flags & AR_DF_ONLINE) {
-		ap = &AD_SOFTC(rdp->disks[drv])->disk;
+		ap = AD_SOFTC(rdp->disks[drv])->disk;
 		error1 = ap->d_dump(ap, vdata, pdata,
 				    (off_t) lba * DEV_BSIZE,
 				    chunk * DEV_BSIZE);
@@ -618,7 +621,7 @@ ardump(void *arg, void *virtual, vm_offset_t physical,
 	    if ((rdp->disks[drv].flags & AR_DF_ONLINE) ||
 		((rdp->flags & AR_F_REBUILDING) && 
 		 (rdp->disks[drv].flags & AR_DF_SPARE))) {
-		ap = &AD_SOFTC(rdp->disks[drv])->disk;
+		ap = AD_SOFTC(rdp->disks[drv])->disk;
 		error1 = ap->d_dump(ap, vdata, pdata,
 				    (off_t) lba * DEV_BSIZE,
 				    chunk * DEV_BSIZE);
@@ -627,7 +630,7 @@ ardump(void *arg, void *virtual, vm_offset_t physical,
 	    if ((rdp->disks[drv + rdp->width].flags & AR_DF_ONLINE) ||
 		((rdp->flags & AR_F_REBUILDING) &&
 		 (rdp->disks[drv + rdp->width].flags & AR_DF_SPARE))) {
-		ap = &AD_SOFTC(rdp->disks[drv + rdp->width])->disk;
+		ap = AD_SOFTC(rdp->disks[drv + rdp->width])->disk;
 		error2 = ap->d_dump(ap, vdata, pdata,
 				    (off_t) lba * DEV_BSIZE,
 				    chunk * DEV_BSIZE);
@@ -739,7 +742,7 @@ arstrategy(struct bio *bp)
 		biodone(bp);
 		return;
 	    }
-	    buf1->bp.bio_disk = &AD_SOFTC(rdp->disks[buf1->drive])->disk;
+	    buf1->bp.bio_disk = AD_SOFTC(rdp->disks[buf1->drive])->disk;
 	    AR_STRATEGY((struct bio *)buf1);
 	    break;
 
@@ -827,7 +830,7 @@ arstrategy(struct bio *bp)
 			buf2->mirror = buf1;
 			buf2->drive = buf1->drive + rdp->width;
 			buf2->bp.bio_disk =
-			    &AD_SOFTC(rdp->disks[buf2->drive])->disk;
+			    AD_SOFTC(rdp->disks[buf2->drive])->disk;
 			AR_STRATEGY((struct bio *)buf2);
 			rdp->disks[buf2->drive].last_lba =
 			    buf2->bp.bio_pblkno + chunk;
@@ -836,7 +839,7 @@ arstrategy(struct bio *bp)
 			buf1->drive = buf1->drive + rdp->width;
 		}
 	    }
-	    buf1->bp.bio_disk = &AD_SOFTC(rdp->disks[buf1->drive])->disk;
+	    buf1->bp.bio_disk = AD_SOFTC(rdp->disks[buf1->drive])->disk;
 	    AR_STRATEGY((struct bio *)buf1);
 	    rdp->disks[buf1->drive].last_lba = buf1->bp.bio_pblkno + chunk;
 	    break;
@@ -881,7 +884,7 @@ ar_done(struct bio *bp)
 			buf->drive = buf->drive + rdp->width;
 		    else
 			buf->drive = buf->drive - rdp->width;
-		    buf->bp.bio_disk = &AD_SOFTC(rdp->disks[buf->drive])->disk;
+		    buf->bp.bio_disk = AD_SOFTC(rdp->disks[buf->drive])->disk;
 		    buf->bp.bio_flags = buf->org->bio_flags;
 		    buf->bp.bio_error = 0;
 		    AR_STRATEGY((struct bio *)buf);
@@ -1629,7 +1632,7 @@ ar_rw(struct ad_softc *adp, u_int32_t lba, int count, caddr_t data, int flags)
 
     if (!(bp = (struct bio *)malloc(sizeof(struct bio), M_AR, M_NOWAIT|M_ZERO)))
 	return 1;
-    bp->bio_disk = &adp->disk;
+    bp->bio_disk = adp->disk;
     bp->bio_data = data;
     bp->bio_pblkno = lba;
     bp->bio_bcount = count;
diff --git a/sys/dev/ata/ata-raid.h b/sys/dev/ata/ata-raid.h
index 9af598eacf15..9c71fa3cb5e4 100644
--- a/sys/dev/ata/ata-raid.h
+++ b/sys/dev/ata/ata-raid.h
@@ -79,7 +79,7 @@ struct ar_softc {
     int			offset;		/* offset from start of disk */
     u_int64_t		lock_start;	/* start of locked area for rebuild */
     u_int64_t		lock_end;	/* end of locked area for rebuild */
-    struct disk		disk;		/* disklabel/slice stuff */
+    struct disk		*disk;		/* disklabel/slice stuff */
     struct proc		*pid;		/* rebuilder process id */
 };
 
diff --git a/sys/dev/ata/atapi-fd.c b/sys/dev/ata/atapi-fd.c
index be31d10f1cb9..0cba39acb1d7 100644
--- a/sys/dev/ata/atapi-fd.c
+++ b/sys/dev/ata/atapi-fd.c
@@ -96,19 +96,21 @@ afd_attach(struct ata_device *atadev)
     atadev->flags |= ATA_D_MEDIA_CHANGED;
 
     /* lets create the disk device */
-    fdp->disk.d_open = afd_open;
-    fdp->disk.d_close = afd_close;
+    fdp->disk = disk_alloc();
+    fdp->disk->d_open = afd_open;
+    fdp->disk->d_close = afd_close;
 #ifdef notyet
-    fdp->disk.d_ioctl = afd_ioctl;
+    fdp->disk->d_ioctl = afd_ioctl;
 #endif
-    fdp->disk.d_strategy = afdstrategy;
-    fdp->disk.d_name = "afd";
-    fdp->disk.d_drv1 = fdp;
+    fdp->disk->d_strategy = afdstrategy;
+    fdp->disk->d_name = "afd";
+    fdp->disk->d_drv1 = fdp;
     if (atadev->channel->dma)
-	fdp->disk.d_maxsize = atadev->channel->dma->max_iosize;
+	fdp->disk->d_maxsize = atadev->channel->dma->max_iosize;
     else
-	fdp->disk.d_maxsize = DFLTPHYS;
-    disk_create(fdp->lun, &fdp->disk, DISKFLAG_NOGIANT, NULL, NULL);
+	fdp->disk->d_maxsize = DFLTPHYS;
+    fdp->disk->d_unit = fdp->lun;
+    disk_create(fdp->disk, DISK_VERSION);
 
     /* announce we are here */
     afd_describe(fdp);
@@ -122,7 +124,7 @@ afd_detach(struct ata_device *atadev)
     mtx_lock(&fdp->queue_mtx);
     bioq_flush(&fdp->queue, NULL, ENXIO);
     mtx_unlock(&fdp->queue_mtx);
-    disk_destroy(&fdp->disk);
+    disk_destroy(fdp->disk);
     ata_prtdev(atadev, "WARNING - removed from configuration\n");
     ata_free_name(atadev);
     ata_free_lun(&afd_lun_map, fdp->lun);
@@ -233,11 +235,11 @@ afd_open(struct disk *dp)
 
     fdp->device->flags &= ~ATA_D_MEDIA_CHANGED;
 
-    fdp->disk.d_sectorsize = fdp->cap.sector_size;
-    fdp->disk.d_mediasize = (off_t)fdp->cap.sector_size * fdp->cap.sectors *
+    fdp->disk->d_sectorsize = fdp->cap.sector_size;
+    fdp->disk->d_mediasize = (off_t)fdp->cap.sector_size * fdp->cap.sectors *
 	fdp->cap.heads * fdp->cap.cylinders;
-    fdp->disk.d_fwsectors = fdp->cap.sectors;
-    fdp->disk.d_fwheads = fdp->cap.heads;
+    fdp->disk->d_fwsectors = fdp->cap.sectors;
+    fdp->disk->d_fwheads = fdp->cap.heads;
   
     return 0;
 }
diff --git a/sys/dev/ata/atapi-fd.h b/sys/dev/ata/atapi-fd.h
index 90223f495c9b..e51d1c3ae705 100644
--- a/sys/dev/ata/atapi-fd.h
+++ b/sys/dev/ata/atapi-fd.h
@@ -74,6 +74,6 @@ struct afd_softc {
     struct mtx			queue_mtx;	/* queue lock */
     struct bio_queue_head	queue;		/* queue of i/o requests */
     struct afd_cappage		cap;		/* capabilities page info */
-    struct disk			disk;		/* virtual drives */
+    struct disk			*disk;		/* virtual drives */
 };
 
diff --git a/sys/dev/ida/ida_disk.c b/sys/dev/ida/ida_disk.c
index f554bac16a94..31769e70357f 100644
--- a/sys/dev/ida/ida_disk.c
+++ b/sys/dev/ida/ida_disk.c
@@ -203,16 +203,19 @@ idad_attach(device_t dev)
 	    drv->secperunit / ((1024 * 1024) / drv->secsize),
 	    drv->secperunit, drv->secsize);
 
-	drv->disk.d_strategy = idad_strategy;
-	drv->disk.d_name = "idad";
-	drv->disk.d_dump = idad_dump;
-	drv->disk.d_sectorsize = drv->secsize;
-	drv->disk.d_mediasize = (off_t)drv->secperunit * drv->secsize;
-	drv->disk.d_fwsectors = drv->sectors;
-	drv->disk.d_fwheads = drv->heads;
-	drv->disk.d_drv1 = drv;
-	drv->disk.d_maxsize = DFLTPHYS;		/* XXX guess? */
-	disk_create(drv->unit, &drv->disk, 0, NULL, NULL);
+	drv->disk = disk_alloc();
+	drv->disk->d_strategy = idad_strategy;
+	drv->disk->d_name = "idad";
+	drv->disk->d_dump = idad_dump;
+	drv->disk->d_sectorsize = drv->secsize;
+	drv->disk->d_mediasize = (off_t)drv->secperunit * drv->secsize;
+	drv->disk->d_fwsectors = drv->sectors;
+	drv->disk->d_fwheads = drv->heads;
+	drv->disk->d_drv1 = drv;
+	drv->disk->d_maxsize = DFLTPHYS;		/* XXX guess? */
+	drv->disk->d_unit = drv->unit;
+	drv->disk->d_flags = DISKFLAG_NEEDSGIANT;
+	disk_create(drv->disk, DISK_VERSION);
 
 	return (0);
 }
@@ -223,6 +226,6 @@ idad_detach(device_t dev)
 	struct idad_softc *drv;
 
 	drv = (struct idad_softc *)device_get_softc(dev);
-	disk_destroy(&drv->disk);
+	disk_destroy(drv->disk);
 	return (0);
 }
diff --git a/sys/dev/ida/idavar.h b/sys/dev/ida/idavar.h
index 9898b23d5f9d..78993cb3ea48 100644
--- a/sys/dev/ida/idavar.h
+++ b/sys/dev/ida/idavar.h
@@ -170,7 +170,7 @@ struct ida_softc {
 struct idad_softc {
 	device_t	dev;
 	struct 		ida_softc *controller;
-	struct		disk disk;
+	struct		disk *disk;
 	int		drive;			/* per controller */
 	int		unit;			/* global */
 	int		cylinders;
diff --git a/sys/dev/ips/ips_disk.c b/sys/dev/ips/ips_disk.c
index cde0545f4f67..f20a8f8f40c8 100644
--- a/sys/dev/ips/ips_disk.c
+++ b/sys/dev/ips/ips_disk.c
@@ -122,25 +122,28 @@ static int ipsd_attach(device_t dev)
 	dsc->sc = device_get_softc(adapter);
 	dsc->unit = device_get_unit(dev);
 	dsc->disk_number = (uintptr_t) device_get_ivars(dev);
-	dsc->ipsd_disk.d_drv1 = dsc;
-	dsc->ipsd_disk.d_name = "ipsd";
-	dsc->ipsd_disk.d_maxsize = IPS_MAX_IO_SIZE;
-	dsc->ipsd_disk.d_open = ipsd_open;
-	dsc->ipsd_disk.d_close = ipsd_close;
-	dsc->ipsd_disk.d_strategy = ipsd_strategy;
+	dsc->ipsd_disk = disk_alloc();
+	dsc->ipsd_disk->d_drv1 = dsc;
+	dsc->ipsd_disk->d_name = "ipsd";
+	dsc->ipsd_disk->d_maxsize = IPS_MAX_IO_SIZE;
+	dsc->ipsd_disk->d_open = ipsd_open;
+	dsc->ipsd_disk->d_close = ipsd_close;
+	dsc->ipsd_disk->d_strategy = ipsd_strategy;
 
 	totalsectors = dsc->sc->drives[dsc->disk_number].sector_count;
    	if ((totalsectors > 0x400000) &&
        			((dsc->sc->adapter_info.miscflags & 0x8) == 0)) {
-      		dsc->ipsd_disk.d_fwheads = IPS_NORM_HEADS;
-      		dsc->ipsd_disk.d_fwsectors = IPS_NORM_SECTORS;
+      		dsc->ipsd_disk->d_fwheads = IPS_NORM_HEADS;
+      		dsc->ipsd_disk->d_fwsectors = IPS_NORM_SECTORS;
    	} else {
-      		dsc->ipsd_disk.d_fwheads = IPS_COMP_HEADS;
-      		dsc->ipsd_disk.d_fwsectors = IPS_COMP_SECTORS;
+      		dsc->ipsd_disk->d_fwheads = IPS_COMP_HEADS;
+      		dsc->ipsd_disk->d_fwsectors = IPS_COMP_SECTORS;
    	}
-	dsc->ipsd_disk.d_sectorsize = IPS_BLKSIZE;
-	dsc->ipsd_disk.d_mediasize = (off_t)totalsectors * IPS_BLKSIZE;
-	disk_create(dsc->unit, &dsc->ipsd_disk, 0, NULL, NULL);
+	dsc->ipsd_disk->d_sectorsize = IPS_BLKSIZE;
+	dsc->ipsd_disk->d_mediasize = (off_t)totalsectors * IPS_BLKSIZE;
+	dsc->ipsd_disk->d_unit = dsc->unit;
+	dsc->ipsd_disk->d_flags = DISKFLAG_NEEDSGIANT;
+	disk_create(dsc->ipsd_disk, DISK_VERSION);
 
 	device_printf(dev, "Logical Drive  (%dMB)\n",
 		      dsc->sc->drives[dsc->disk_number].sector_count >> 11);
@@ -155,7 +158,7 @@ static int ipsd_detach(device_t dev)
 	dsc = (ipsdisk_softc_t *)device_get_softc(dev);
 	if(dsc->state & IPS_DEV_OPEN)
 		return (EBUSY);
-	disk_destroy(&dsc->ipsd_disk);
+	disk_destroy(dsc->ipsd_disk);
 	return 0;
 }
 
diff --git a/sys/dev/ips/ips_disk.h b/sys/dev/ips/ips_disk.h
index 9bc67260b661..0b0fe65d4030 100644
--- a/sys/dev/ips/ips_disk.h
+++ b/sys/dev/ips/ips_disk.h
@@ -61,6 +61,6 @@ typedef struct ipsdisk_softc {
 	int		unit;
 	int		disk_number;
 	u_int32_t 	state;
-	struct disk 	ipsd_disk;
+	struct disk 	*ipsd_disk;
 	ips_softc_t	*sc;
 }ipsdisk_softc_t;
diff --git a/sys/dev/mlx/mlx_disk.c b/sys/dev/mlx/mlx_disk.c
index bd864664842f..2ad0bc6ba533 100644
--- a/sys/dev/mlx/mlx_disk.c
+++ b/sys/dev/mlx/mlx_disk.c
@@ -219,30 +219,33 @@ mlxd_attach(device_t dev)
 		  sc->mlxd_drive->ms_size / ((1024 * 1024) / MLX_BLKSIZE),
 		  sc->mlxd_drive->ms_size, sc->mlxd_drive->ms_raidlevel, state);
 
-    sc->mlxd_disk.d_open = mlxd_open;
-    sc->mlxd_disk.d_close = mlxd_close;
-    sc->mlxd_disk.d_ioctl = mlxd_ioctl;
-    sc->mlxd_disk.d_strategy = mlxd_strategy;
-    sc->mlxd_disk.d_name = "mlxd";
-    sc->mlxd_disk.d_drv1 = sc;
-    sc->mlxd_disk.d_sectorsize = MLX_BLKSIZE;
-    sc->mlxd_disk.d_mediasize = MLX_BLKSIZE * (off_t)sc->mlxd_drive->ms_size;
-    sc->mlxd_disk.d_fwsectors = sc->mlxd_drive->ms_sectors;
-    sc->mlxd_disk.d_fwheads = sc->mlxd_drive->ms_heads;
+    sc->mlxd_disk = disk_alloc();
+    sc->mlxd_disk->d_open = mlxd_open;
+    sc->mlxd_disk->d_close = mlxd_close;
+    sc->mlxd_disk->d_ioctl = mlxd_ioctl;
+    sc->mlxd_disk->d_strategy = mlxd_strategy;
+    sc->mlxd_disk->d_name = "mlxd";
+    sc->mlxd_disk->d_unit = sc->mlxd_unit;
+    sc->mlxd_disk->d_drv1 = sc;
+    sc->mlxd_disk->d_sectorsize = MLX_BLKSIZE;
+    sc->mlxd_disk->d_mediasize = MLX_BLKSIZE * (off_t)sc->mlxd_drive->ms_size;
+    sc->mlxd_disk->d_fwsectors = sc->mlxd_drive->ms_sectors;
+    sc->mlxd_disk->d_fwheads = sc->mlxd_drive->ms_heads;
+    sc->mlxd_disk->d_flags = DISKFLAG_NEEDSGIANT;
 
     /* 
      * Set maximum I/O size to the lesser of the recommended maximum and the practical
      * maximum except on v2 cards where the maximum is set to 8 pages.
      */
     if (sc->mlxd_controller->mlx_iftype == MLX_IFTYPE_2)
-	sc->mlxd_disk.d_maxsize = 8 * PAGE_SIZE;
+	sc->mlxd_disk->d_maxsize = 8 * PAGE_SIZE;
     else {
 	s1 = sc->mlxd_controller->mlx_enq2->me_maxblk * MLX_BLKSIZE;
 	s2 = (sc->mlxd_controller->mlx_enq2->me_max_sg - 1) * PAGE_SIZE;
-	sc->mlxd_disk.d_maxsize = imin(s1, s2);
+	sc->mlxd_disk->d_maxsize = imin(s1, s2);
     }
 
-    disk_create(sc->mlxd_unit, &sc->mlxd_disk, 0, NULL, NULL);
+    disk_create(sc->mlxd_disk, DISK_VERSION);
 
     return (0);
 }
@@ -254,7 +257,7 @@ mlxd_detach(device_t dev)
 
     debug_called(1);
 
-    disk_destroy(&sc->mlxd_disk);
+    disk_destroy(sc->mlxd_disk);
 
     return(0);
 }
diff --git a/sys/dev/mlx/mlxvar.h b/sys/dev/mlx/mlxvar.h
index 43cbcb1ac59e..e499569d279f 100644
--- a/sys/dev/mlx/mlxvar.h
+++ b/sys/dev/mlx/mlxvar.h
@@ -228,7 +228,7 @@ struct mlxd_softc
     device_t		mlxd_dev;
     struct mlx_softc	*mlxd_controller;
     struct mlx_sysdrive	*mlxd_drive;
-    struct disk		mlxd_disk;
+    struct disk		*mlxd_disk;
     int			mlxd_unit;
     int			mlxd_flags;
 #define MLXD_OPEN	(1<<0)		/* drive is open (can't shut down) */
diff --git a/sys/dev/ofw/ofw_disk.c b/sys/dev/ofw/ofw_disk.c
index 8d4ae8238157..f3e143a731cb 100644
--- a/sys/dev/ofw/ofw_disk.c
+++ b/sys/dev/ofw/ofw_disk.c
@@ -48,7 +48,7 @@ __FBSDID("$FreeBSD$");
 struct ofwd_softc
 {
 	device_t	ofwd_dev;
-	struct		disk ofwd_disk;
+	struct		disk *ofwd_disk;
 	phandle_t	ofwd_package;
 	ihandle_t	ofwd_instance;
 };
@@ -203,15 +203,18 @@ ofwd_attach(device_t dev)
 		return (ENXIO);
 	}
 
-	sc->ofwd_disk.d_strategy = ofwd_strategy;
-	sc->ofwd_disk.d_name = "ofwd";
-	sc->ofwd_disk.d_sectorsize = OFWD_BLOCKSIZE;
-	sc->ofwd_disk.d_mediasize = (off_t)33554432 * OFWD_BLOCKSIZE;
-	sc->ofwd_disk.d_fwsectors = 0;
-	sc->ofwd_disk.d_fwheads = 0;
-	sc->ofwd_disk.d_drv1 = sc;
-	sc->ofwd_disk.d_maxsize = PAGE_SIZE;
-	disk_create(device_get_unit(dev), &sc->ofwd_disk, 0, NULL, NULL);
+	sc->ofwd_disk = disk_alloc();
+	sc->ofwd_disk->d_strategy = ofwd_strategy;
+	sc->ofwd_disk->d_name = "ofwd";
+	sc->ofwd_disk->d_sectorsize = OFWD_BLOCKSIZE;
+	sc->ofwd_disk->d_mediasize = (off_t)33554432 * OFWD_BLOCKSIZE;
+	sc->ofwd_disk->d_fwsectors = 0;
+	sc->ofwd_disk->d_fwheads = 0;
+	sc->ofwd_disk->d_drv1 = sc;
+	sc->ofwd_disk->d_maxsize = PAGE_SIZE;
+	sc->ofwd_disk->d_unit = device_get_unit(dev);
+	sc->ofwd_disk->d_flags = DISKFLAG_NEEDSGIANT;
+	disk_create(sc->ofwd_disk, DISK_VERSION);
 
 	return (0);
 }
diff --git a/sys/dev/pst/pst-raid.c b/sys/dev/pst/pst-raid.c
index e545a5fb34c5..83a52803b526 100644
--- a/sys/dev/pst/pst-raid.c
+++ b/sys/dev/pst/pst-raid.c
@@ -56,7 +56,7 @@ struct pst_softc {
     struct iop_softc		*iop;
     struct i2o_lct_entry	*lct;
     struct i2o_bsa_device	*info;
-    struct disk			disk;
+    struct disk			*disk;
     struct bio_queue_head	queue;
 };
 
@@ -149,16 +149,19 @@ pst_attach(device_t dev)
 
     bioq_init(&psc->queue);
 
-    psc->disk.d_name = "pst";
-    psc->disk.d_strategy = pststrategy;
-    psc->disk.d_maxsize = 64 * 1024; /*I2O_SGL_MAX_SEGS * PAGE_SIZE;*/
-    psc->disk.d_drv1 = psc;
-    disk_create(lun, &psc->disk, DISKFLAG_NOGIANT, NULL, NULL);
+    psc->disk = disk_alloc();
+    psc->disk->d_name = "pst";
+    psc->disk->d_strategy = pststrategy;
+    psc->disk->d_maxsize = 64 * 1024; /*I2O_SGL_MAX_SEGS * PAGE_SIZE;*/
+    psc->disk->d_drv1 = psc;
+    psc->disk->d_unit = lun;
 
-    psc->disk.d_sectorsize = psc->info->block_size;
-    psc->disk.d_mediasize = psc->info->capacity;
-    psc->disk.d_fwsectors = 63;
-    psc->disk.d_fwheads = 255;
+    psc->disk->d_sectorsize = psc->info->block_size;
+    psc->disk->d_mediasize = psc->info->capacity;
+    psc->disk->d_fwsectors = 63;
+    psc->disk->d_fwheads = 255;
+
+    disk_create(psc->disk, DISK_VERSION);
 
     printf("pst%d: %lluMB <%.40s> [%lld/%d/%d] on %.16s\n", lun,
 	   (unsigned long long)psc->info->capacity / (1024 * 1024),
diff --git a/sys/dev/raidframe/rf_freebsdkintf.c b/sys/dev/raidframe/rf_freebsdkintf.c
index caaf86801362..78490f8266f3 100644
--- a/sys/dev/raidframe/rf_freebsdkintf.c
+++ b/sys/dev/raidframe/rf_freebsdkintf.c
@@ -252,7 +252,7 @@ struct raid_softc {
 	int	sc_busycount;	/* How many times are we opened? */
 	size_t  sc_size;	/* size of the raid device */
 	dev_t	sc_parent;	/* Parent device */
-	struct disk		sc_disk;	/* generic disk device info */
+	struct disk		*sc_disk;	/* generic disk device info */
  	uma_zone_t		sc_cbufpool;	/* component buffer pool */
 	RF_Raid_t		*raidPtr;	/* Raid information struct */
 	struct bio_queue_head	bio_queue;	/* used for the device queue */
@@ -599,7 +599,7 @@ out:
 		retcode = rf_Shutdown(sc->raidPtr);
 		RF_THREADGROUP_WAIT_STOP(&sc->raidPtr->engine_tg);
 
-		disk_destroy(&sc->sc_disk);
+		disk_destroy(sc->sc_disk);
 		raidunlock(sc);
 
 		/* XXX Need to be able to destroy the zone */
@@ -631,7 +631,7 @@ raidopen(struct disk *dp)
 
 	if ((error = raidlock(sc)) != 0)
 		return (error);
-	dp = &sc->sc_disk;
+	dp = sc->sc_disk;
 
 	rf_printf(1, "Opening raid device %s%d\n", dp->d_name, dp->d_unit);
 
@@ -1276,14 +1276,17 @@ raidinit(raidPtr)
 	sc->sc_size = raidPtr->totalSectors;
 
 	/* Create the disk device */
-	sc->sc_disk.d_open = raidopen;
-	sc->sc_disk.d_close = raidclose;
-	sc->sc_disk.d_ioctl = raidioctl;
-	sc->sc_disk.d_strategy = raidstrategy;
-	sc->sc_disk.d_drv1 = sc;
-	sc->sc_disk.d_maxsize = DFLTPHYS;
-	sc->sc_disk.d_name = "raid";
-	disk_create(raidPtr->raidid, &sc->sc_disk, 0, NULL, NULL);
+	sc->sc_disk = disk_alloc();
+	sc->sc_disk->d_open = raidopen;
+	sc->sc_disk->d_close = raidclose;
+	sc->sc_disk->d_ioctl = raidioctl;
+	sc->sc_disk->d_strategy = raidstrategy;
+	sc->sc_disk->d_drv1 = sc;
+	sc->sc_disk->d_maxsize = DFLTPHYS;
+	sc->sc_disk->d_name = "raid";
+	sc->sc_disk->d_unit = raidPtr->raidid;
+	sc->sc_disk->d_flags = DISKFLAG_NEEDSGIANT;
+	disk_create(sc->sc_disk, DISK_VERSION);
 	raidPtr->sc = sc;
 
 	return (sc);
@@ -1467,7 +1470,7 @@ rf_DispatchKernelIO(queue, req)
 
 	sc = queue->raidPtr->sc;
 
-	rf_printf(3, "DispatchKernelIO %s\n", sc->sc_disk.d_name);
+	rf_printf(3, "DispatchKernelIO %s\n", sc->sc_disk->d_name);
 
 	bp = req->bp;
 #if 1
@@ -1533,8 +1536,8 @@ rf_DispatchKernelIO(queue, req)
 		queue->curPriority = req->priority;
 
 		rf_printf(3, "Going for %c to %s%d row %d col %d\n",
-			req->type, sc->sc_disk.d_name, 
-			sc->sc_disk.d_unit, queue->row, queue->col);
+			req->type, sc->sc_disk->d_name, 
+			sc->sc_disk->d_unit, queue->row, queue->col);
 		rf_printf(3, "sector %d count %d (%d bytes) %d\n",
 			(int) req->sectorOffset, (int) req->numSector,
 			(int) (req->numSector <<
@@ -1609,7 +1612,7 @@ KernelWakeupFunc(vbp)
 		if (queue->raidPtr->Disks[queue->row][queue->col].status ==
 		    rf_ds_optimal) {
 			rf_printf(0, "%s%d: IO Error.  Marking %s as "
-			    "failed.\n", sc->sc_disk.d_name, sc->sc_disk.d_unit,
+			    "failed.\n", sc->sc_disk->d_name, sc->sc_disk->d_unit,
 			    queue->raidPtr->Disks[queue->row][queue->col].devname);
 			queue->raidPtr->Disks[queue->row][queue->col].status =
 			    rf_ds_failed;
diff --git a/sys/dev/twe/twe_freebsd.c b/sys/dev/twe/twe_freebsd.c
index 34e4954b2843..6f3f02bbe9ec 100644
--- a/sys/dev/twe/twe_freebsd.c
+++ b/sys/dev/twe/twe_freebsd.c
@@ -640,7 +640,7 @@ struct twed_softc
     device_t		twed_dev;
     struct twe_softc	*twed_controller;	/* parent device softc */
     struct twe_drive	*twed_drive;		/* drive data in parent softc */
-    struct disk		twed_disk;		/* generic disk handle */
+    struct disk		*twed_disk;		/* generic disk handle */
 };
 
 /*
@@ -805,19 +805,24 @@ twed_attach(device_t dev)
     
     /* attach a generic disk device to ourselves */
 
-    sc->twed_disk.d_open = twed_open;
-    sc->twed_disk.d_strategy = twed_strategy;
-    sc->twed_disk.d_dump = (dumper_t *)twed_dump;
-    sc->twed_disk.d_name = "twed";
-    sc->twed_disk.d_drv1 = sc;
-    sc->twed_disk.d_maxsize = (TWE_MAX_SGL_LENGTH - 1) * PAGE_SIZE;
-    sc->twed_disk.d_sectorsize = TWE_BLOCK_SIZE;
-    sc->twed_disk.d_mediasize = TWE_BLOCK_SIZE * (off_t)sc->twed_drive->td_size;
-    sc->twed_disk.d_fwsectors = sc->twed_drive->td_sectors;
-    sc->twed_disk.d_fwheads = sc->twed_drive->td_heads;
     sc->twed_drive->td_sys_unit = device_get_unit(dev);
 
-    disk_create(sc->twed_drive->td_sys_unit, &sc->twed_disk, 0, NULL, NULL);
+    sc->twed_disk = disk_alloc();
+    sc->twed_disk->d_open = twed_open;
+    sc->twed_disk->d_strategy = twed_strategy;
+    sc->twed_disk->d_dump = (dumper_t *)twed_dump;
+    sc->twed_disk->d_name = "twed";
+    sc->twed_disk->d_drv1 = sc;
+    sc->twed_disk->d_maxsize = (TWE_MAX_SGL_LENGTH - 1) * PAGE_SIZE;
+    sc->twed_disk->d_sectorsize = TWE_BLOCK_SIZE;
+    sc->twed_disk->d_mediasize = TWE_BLOCK_SIZE * (off_t)sc->twed_drive->td_size;
+    sc->twed_disk->d_fwsectors = sc->twed_drive->td_sectors;
+    sc->twed_disk->d_fwheads = sc->twed_drive->td_heads;
+    sc->twed_disk->d_unit = sc->twed_drive->td_sys_unit;
+    sc->twed_disk->d_flags = DISKFLAG_NEEDSGIANT;
+
+    disk_create(sc->twed_disk, DISK_VERSION);
+
 #ifdef FREEBSD_4
     disks_registered++;
 #endif
@@ -837,10 +842,10 @@ twed_detach(device_t dev)
 
     debug_called(4);
 
-    if (sc->twed_disk.d_flags & DISKFLAG_OPEN)
+    if (sc->twed_disk->d_flags & DISKFLAG_OPEN)
 	return(EBUSY);
 
-    disk_destroy(&sc->twed_disk);
+    disk_destroy(sc->twed_disk);
 
 #ifdef FREEBSD_4
     if (--disks_registered == 0)