Change the disk(9) API in order to make device removal more robust.

Previously the "struct disk" were owned by the device driver and this
gave us problems when the device disappared and the users of that device
were not immediately disappearing.

Now the struct disk is allocate with a new call, disk_alloc() and owned
by geom_disk and just abandonned by the device driver when disk_create()
is called.

Unfortunately, this results in a ton of "s/\./->/" changes to device
drivers.

Since I'm doing the sweep anyway, a couple of other API improvements
have been carried out at the same time:

The Giant awareness flag has been flipped from DISKFLAG_NOGIANT to
DISKFLAG_NEEDSGIANT

A version number have been added to disk_create() so that we can detect,
report and ignore binary drivers with old ABI in the future.

Manual page update to follow shortly.

28 files changed, 335 insertions, 273 deletions

diff --git a/sys/cam/scsi/scsi_cd.c b/sys/cam/scsi/scsi_cd.c
index 3be7b54..ac65e36 100644
--- a/sys/cam/scsi/scsi_cd.c
+++ b/sys/cam/scsi/scsi_cd.c
@@ -159,7 +159,7 @@ struct cd_softc {
 	struct sysctl_oid	*sysctl_tree;
 	STAILQ_HEAD(, cd_mode_params)	mode_queue;
 	struct cd_tocdata	toc;
-	struct disk		disk;
+	struct disk		*disk;
 };
 
 struct cd_page_sizes {
@@ -498,7 +498,7 @@ cdcleanup(struct cam_periph *periph)
 		free(softc->changer, M_DEVBUF);
 		num_changers--;
 	}
-	disk_destroy(&softc->disk);
+	disk_destroy(softc->disk);
 	free(softc, M_DEVBUF);
 	splx(s);
 }
@@ -736,18 +736,21 @@ cdregister(struct cam_periph *periph, void *arg)
 	 * WORM peripheral driver.  WORM drives will also have the WORM
 	 * driver attached to them.
 	 */
-	softc->disk.d_devstat = devstat_new_entry("cd", 
+	softc->disk = disk_alloc();
+	softc->disk->d_devstat = devstat_new_entry("cd", 
 			  periph->unit_number, 0,
 	  		  DEVSTAT_BS_UNAVAILABLE,
 			  DEVSTAT_TYPE_CDROM | DEVSTAT_TYPE_IF_SCSI,
 			  DEVSTAT_PRIORITY_CD);
-	softc->disk.d_open = cdopen;
-	softc->disk.d_close = cdclose;
-	softc->disk.d_strategy = cdstrategy;
-	softc->disk.d_ioctl = cdioctl;
-	softc->disk.d_name = "cd";
-	disk_create(periph->unit_number, &softc->disk, 0, NULL, NULL);
-	softc->disk.d_drv1 = periph;
+	softc->disk->d_open = cdopen;
+	softc->disk->d_close = cdclose;
+	softc->disk->d_strategy = cdstrategy;
+	softc->disk->d_ioctl = cdioctl;
+	softc->disk->d_name = "cd";
+	softc->disk->d_unit = periph->unit_number;
+	softc->disk->d_drv1 = periph;
+	softc->disk->d_flags = DISKFLAG_NEEDSGIANT;
+	disk_create(softc->disk, DISK_VERSION);
 
 	/*
 	 * Add an async callback so that we get
@@ -1059,7 +1062,7 @@ cdclose(struct disk *dp)
 	 * Since we're closing this CD, mark the blocksize as unavailable.
 	 * It will be marked as available when the CD is opened again.
 	 */
-	softc->disk.d_devstat->flags |= DEVSTAT_BS_UNAVAILABLE;
+	softc->disk->d_devstat->flags |= DEVSTAT_BS_UNAVAILABLE;
 
 	/*
 	 * We'll check the media and toc again at the next open().
@@ -1353,7 +1356,7 @@ cdrunccb(union ccb *ccb, int (*error_routine)(union ccb *ccb,
 	softc = (struct cd_softc *)periph->softc;
 
 	error = cam_periph_runccb(ccb, error_routine, cam_flags, sense_flags,
-				  softc->disk.d_devstat);
+				  softc->disk->d_devstat);
 
 	if (softc->flags & CD_FLAG_CHANGER)
 		cdchangerschedule(softc);
@@ -1509,7 +1512,7 @@ cdstart(struct cam_periph *periph, union ccb *start_ccb)
 		} else {
 			bioq_remove(&softc->bio_queue, bp);
 
-			devstat_start_transaction_bio(softc->disk.d_devstat, bp);
+			devstat_start_transaction_bio(softc->disk->d_devstat, bp);
 
 			scsi_read_write(&start_ccb->csio,
 					/*retries*/4,
@@ -1665,7 +1668,7 @@ cddone(struct cam_periph *periph, union ccb *done_ccb)
 		if (softc->flags & CD_FLAG_CHANGER)
 			cdchangerschedule(softc);
 
-		biofinish(bp, softc->disk.d_devstat, 0);
+		biofinish(bp, softc->disk->d_devstat, 0);
 		break;
 	}
 	case CD_CCB_PROBE:
@@ -2719,9 +2722,9 @@ cdcheckmedia(struct cam_periph *periph)
 	softc = (struct cd_softc *)periph->softc;
 
 	cdprevent(periph, PR_PREVENT);
-	softc->disk.d_maxsize = DFLTPHYS;
-	softc->disk.d_sectorsize = 0;
-	softc->disk.d_mediasize = 0;
+	softc->disk->d_maxsize = DFLTPHYS;
+	softc->disk->d_sectorsize = 0;
+	softc->disk->d_mediasize = 0;
 
 	/*
 	 * Get the disc size and block size.  If we can't get it, we don't
@@ -2821,9 +2824,9 @@ cdcheckmedia(struct cam_periph *periph)
 	}
 
 	softc->flags |= CD_FLAG_VALID_TOC;
-	softc->disk.d_maxsize = DFLTPHYS;
-	softc->disk.d_sectorsize = softc->params.blksize;
-	softc->disk.d_mediasize =
+	softc->disk->d_maxsize = DFLTPHYS;
+	softc->disk->d_sectorsize = softc->params.blksize;
+	softc->disk->d_mediasize =
 	    (off_t)softc->params.blksize * softc->params.disksize;
 
 bailout:
@@ -2835,9 +2838,9 @@ bailout:
 	 * XXX problems here if some slice or partition is still
 	 * open with the old size?
 	 */
-	if ((softc->disk.d_devstat->flags & DEVSTAT_BS_UNAVAILABLE) != 0)
-		softc->disk.d_devstat->flags &= ~DEVSTAT_BS_UNAVAILABLE;
-	softc->disk.d_devstat->block_size = softc->params.blksize;
+	if ((softc->disk->d_devstat->flags & DEVSTAT_BS_UNAVAILABLE) != 0)
+		softc->disk->d_devstat->flags &= ~DEVSTAT_BS_UNAVAILABLE;
+	softc->disk->d_devstat->block_size = softc->params.blksize;
 
 	return (error);
 }
diff --git a/sys/cam/scsi/scsi_da.c b/sys/cam/scsi/scsi_da.c
index bc9acaf..7127eb0 100644
--- a/sys/cam/scsi/scsi_da.c
+++ b/sys/cam/scsi/scsi_da.c
@@ -133,7 +133,7 @@ struct da_softc {
 	int	 ordered_tag_count;
 	int	 outstanding_cmds;
 	struct	 disk_params params;
-	struct	 disk disk;
+	struct	 disk *disk;
 	union	 ccb saved_ccb;
 	struct task		sysctl_task;
 	struct sysctl_ctx_list	sysctl_ctx;
@@ -493,13 +493,13 @@ daopen(struct disk *dp)
 
 	if (error == 0) {
 
-		softc->disk.d_sectorsize = softc->params.secsize;
-		softc->disk.d_mediasize = softc->params.secsize * (off_t)softc->params.sectors;
+		softc->disk->d_sectorsize = softc->params.secsize;
+		softc->disk->d_mediasize = softc->params.secsize * (off_t)softc->params.sectors;
 		/* XXX: these are not actually "firmware" values, so they may be wrong */
-		softc->disk.d_fwsectors = softc->params.secs_per_track;
-		softc->disk.d_fwheads = softc->params.heads;
-		softc->disk.d_devstat->block_size = softc->params.secsize;
-		softc->disk.d_devstat->flags &= ~DEVSTAT_BS_UNAVAILABLE;
+		softc->disk->d_fwsectors = softc->params.secs_per_track;
+		softc->disk->d_fwheads = softc->params.heads;
+		softc->disk->d_devstat->block_size = softc->params.secsize;
+		softc->disk->d_devstat->flags &= ~DEVSTAT_BS_UNAVAILABLE;
 	}
 	
 	if (error == 0) {
@@ -547,7 +547,7 @@ daclose(struct disk *dp)
 
 		cam_periph_runccb(ccb, /*error_routine*/NULL, /*cam_flags*/0,
 				  /*sense_flags*/SF_RETRY_UA,
-				  softc->disk.d_devstat);
+				  softc->disk->d_devstat);
 
 		if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
 			if ((ccb->ccb_h.status & CAM_STATUS_MASK) ==
@@ -589,7 +589,7 @@ daclose(struct disk *dp)
 		 * unavailable, since it could change when new media is
 		 * inserted.
 		 */
-		softc->disk.d_devstat->flags |= DEVSTAT_BS_UNAVAILABLE;
+		softc->disk->d_devstat->flags |= DEVSTAT_BS_UNAVAILABLE;
 	}
 
 	softc->flags &= ~DA_FLAG_OPEN;
@@ -851,7 +851,7 @@ dacleanup(struct cam_periph *periph)
 		xpt_print_path(periph->path);
 		printf("can't remove sysctl context\n");
 	}
-	disk_destroy(&softc->disk);
+	disk_destroy(softc->disk);
 	free(softc, M_DEVBUF);
 }
 
@@ -1091,14 +1091,17 @@ daregister(struct cam_periph *periph, void *arg)
 	 * Register this media as a disk
 	 */
 
-	softc->disk.d_open = daopen;
-	softc->disk.d_close = daclose;
-	softc->disk.d_strategy = dastrategy;
-	softc->disk.d_dump = dadump;
-	softc->disk.d_name = "da";
-	softc->disk.d_drv1 = periph;
-	softc->disk.d_maxsize = DFLTPHYS; /* XXX: probably not arbitrary */
-	disk_create(periph->unit_number, &softc->disk, 0, NULL, NULL);
+	softc->disk = disk_alloc();
+	softc->disk->d_open = daopen;
+	softc->disk->d_close = daclose;
+	softc->disk->d_strategy = dastrategy;
+	softc->disk->d_dump = dadump;
+	softc->disk->d_name = "da";
+	softc->disk->d_drv1 = periph;
+	softc->disk->d_maxsize = DFLTPHYS; /* XXX: probably not arbitrary */
+	softc->disk->d_unit = periph->unit_number;
+	softc->disk->d_flags = DISKFLAG_NEEDSGIANT;
+	disk_create(softc->disk, DISK_VERSION);
 
 	/*
 	 * Add async callbacks for bus reset and
@@ -1666,7 +1669,7 @@ daprevent(struct cam_periph *periph, int action)
 		     5000);
 
 	error = cam_periph_runccb(ccb, /*error_routine*/NULL, CAM_RETRY_SELTO,
-				  SF_RETRY_UA, softc->disk.d_devstat);
+				  SF_RETRY_UA, softc->disk->d_devstat);
 
 	if (error == 0) {
 		if (action == PR_ALLOW)
@@ -1712,7 +1715,7 @@ dagetcapacity(struct cam_periph *periph)
 	error = cam_periph_runccb(ccb, daerror,
 				  /*cam_flags*/CAM_RETRY_SELTO,
 				  /*sense_flags*/SF_RETRY_UA,
-				  softc->disk.d_devstat);
+				  softc->disk->d_devstat);
 
 	if ((ccb->ccb_h.status & CAM_DEV_QFRZN) != 0)
 		cam_release_devq(ccb->ccb_h.path,
@@ -1747,7 +1750,7 @@ dagetcapacity(struct cam_periph *periph)
 	error = cam_periph_runccb(ccb, daerror,
 				  /*cam_flags*/CAM_RETRY_SELTO,
 				  /*sense_flags*/SF_RETRY_UA,
-				  softc->disk.d_devstat);
+				  softc->disk->d_devstat);
 
 	if ((ccb->ccb_h.status & CAM_DEV_QFRZN) != 0)
 		cam_release_devq(ccb->ccb_h.path,
diff --git a/sys/contrib/dev/fla/fla.c b/sys/contrib/dev/fla/fla.c
index 789db78..845befc 100644
--- a/sys/contrib/dev/fla/fla.c
+++ b/sys/contrib/dev/fla/fla.c
@@ -78,7 +78,7 @@ static struct fla_s {
 	unsigned nsect;
 	struct doc2k_stat ds;
 	struct bio_queue_head bio_queue;
-	struct disk disk;
+	struct disk *disk;
 	dev_t dev;
 } softc[8];
 
@@ -99,10 +99,10 @@ flaopen(struct disk *dp)
 	}
 
 	error = doc2k_size(sc->unit, &spu, &ncyl, &nt, &ns);
-	sc->disk.d_sectorsize = DEV_BSIZE;
-	sc->disk.d_mediasize = (off_t)spu * DEV_BSIZE;
-	sc->disk.d_fwsectors = ns;
-	sc->disk.d_fwheads = nt;
+	sc->disk->d_sectorsize = DEV_BSIZE;
+	sc->disk->d_mediasize = (off_t)spu * DEV_BSIZE;
+	sc->disk->d_fwsectors = ns;
+	sc->disk->d_fwheads = nt;
 
 	return (0);
 }
@@ -255,14 +255,17 @@ flaattach (device_t dev)
 
 	bioq_init(&sc->bio_queue);
 
-	sc->disk.d_open = flaopen;
-	sc->disk.d_close = flaclose;
-	sc->disk.d_strategy = flastrategy;
-	sc->disk.d_drv1 = sc;
-	sc->disk.d_name = "fla";
-	sc->disk.d_maxsize = MAXPHYS;
+	sc->disk = disk_alloc();
+	sc->disk->d_open = flaopen;
+	sc->disk->d_close = flaclose;
+	sc->disk->d_strategy = flastrategy;
+	sc->disk->d_drv1 = sc;
+	sc->disk->d_name = "fla";
+	sc->disk->d_maxsize = MAXPHYS;
 	sc->unit = unit;
-	disk_create(unit, &sc->disk, DISKFLAG_CANDELETE, NULL, NULL);
+	sc->disk->d_unit = unit;
+	sc->disk->d_flags = DISKFLAG_CANDELETE | DISKFLAG_NEEDSGIANT;
+	disk_create(sc->disk, DISK_VERSION);
 
 	return (0);
 }
diff --git a/sys/dev/aac/aac.c b/sys/dev/aac/aac.c
index 2fec4cf..57017bb 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 382b644..2231a0e 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 f2ee0f3..a4b30c3 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 42d09a2..a93e1ed 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 1191954..2378c97 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 25b9ef9..504049f 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 1373fd2..778169c 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 ba720af..be57886d 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 9af598e..9c71fa3 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 be31d10..0cba39a 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 90223f4..e51d1c3 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 f554bac..31769e7 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 9898b23..78993cb 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 cde0545..f20a8f8 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 9bc6726..0b0fe65 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 bd86466..2ad0bc6 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 43cbcb1..e499569 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 8d4ae82..f3e143a 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 e545a5f..83a5280 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 caaf868..78490f8 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 34e4954..6f3f02b 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)
diff --git a/sys/geom/geom_disk.c b/sys/geom/geom_disk.c
index b539940..aee02eb 100644
--- a/sys/geom/geom_disk.c
+++ b/sys/geom/geom_disk.c
@@ -87,17 +87,15 @@ DECLARE_GEOM_CLASS(g_disk_class, g_disk);
 static void __inline
 g_disk_lock_giant(struct disk *dp)
 {
-	if (dp->d_flags & DISKFLAG_NOGIANT)
-		return;
-	mtx_lock(&Giant);
+	if (dp->d_flags & DISKFLAG_NEEDSGIANT)
+		mtx_lock(&Giant);
 }
 
 static void __inline
 g_disk_unlock_giant(struct disk *dp)
 {
-	if (dp->d_flags & DISKFLAG_NOGIANT)
-		return;
-	mtx_unlock(&Giant);
+	if (dp->d_flags & DISKFLAG_NEEDSGIANT)
+		mtx_unlock(&Giant);
 }
 
 static int
@@ -110,15 +108,14 @@ g_disk_access(struct g_provider *pp, int r, int w, int e)
 	    pp->name, r, w, e);
 	g_topology_assert();
 	dp = pp->geom->softc;
-	if (dp == NULL) {
+	if (dp == NULL || dp->d_destroyed) {
 		/*
 		 * Allow decreasing access count even if disk is not
 		 * avaliable anymore.
 		 */
 		if (r <= 0 && w <= 0 && e <= 0)
 			return (0);
-		else
-			return (ENXIO);
+		return (ENXIO);
 	}
 	r += pp->acr;
 	w += pp->acw;
@@ -233,7 +230,7 @@ g_disk_start(struct bio *bp)
 	off_t off;
 
 	dp = bp->bio_to->geom->softc;
-	if (dp == NULL)
+	if (dp == NULL || dp->d_destroyed)
 		g_io_deliver(bp, ENXIO);
 	error = EJUSTRETURN;
 	switch(bp->bio_cmd) {
@@ -358,20 +355,37 @@ g_disk_create(void *arg, int flag)
 static void
 g_disk_destroy(void *ptr, int flag)
 {
+	struct disk *dp;
 	struct g_geom *gp;
 
 	g_topology_assert();
-	gp = ptr;
+	dp = ptr;
+	gp = dp->d_geom;
 	gp->softc = NULL;
 	g_wither_geom(gp, ENXIO);
+	g_free(dp);
 }
 
-void
-disk_create(int unit, struct disk *dp, int flags, void *unused __unused, void * unused2 __unused)
+struct disk *
+disk_alloc()
 {
+	struct disk *dp;
+
+	dp = g_malloc(sizeof *dp, M_WAITOK | M_ZERO);
+	return (dp);
+}
 
-	dp->d_unit = unit;
-	dp->d_flags = flags;
+void
+disk_create(struct disk *dp, int version)
+{
+	if (version != DISK_VERSION_00) {
+		printf("WARNING: Attempt to add disk %s%d %s",
+		    dp->d_name, dp->d_unit,
+		    " using incompatible ABI version of disk(9)\n");
+		printf("WARNING: Ignoring disk %s%d\n",
+		    dp->d_name, dp->d_unit);
+		return;
+	}
 	KASSERT(dp->d_strategy != NULL, ("disk_create need d_strategy"));
 	KASSERT(dp->d_name != NULL, ("disk_create need d_name"));
 	KASSERT(*dp->d_name != 0, ("disk_create need d_name"));
@@ -387,16 +401,10 @@ disk_create(int unit, struct disk *dp, int flags, void *unused __unused, void *
 void
 disk_destroy(struct disk *dp)
 {
-	struct g_geom *gp;
 
 	g_cancel_event(dp);
-	gp = dp->d_geom;
-	if (gp == NULL)
-		return;
-	gp->softc = NULL;
-	devstat_remove_entry(dp->d_devstat);
-	g_waitfor_event(g_disk_destroy, gp, M_WAITOK, NULL, NULL);
-	dp->d_geom = NULL;
+	dp->d_destroyed = 1;
+	g_post_event(g_disk_destroy, dp, M_WAITOK, NULL, NULL);
 }
 
 static void
diff --git a/sys/geom/geom_disk.h b/sys/geom/geom_disk.h
index 712e871..a94df89 100644
--- a/sys/geom/geom_disk.h
+++ b/sys/geom/geom_disk.h
@@ -57,6 +57,7 @@ struct disk {
 	/* Fields which are private to geom_disk */
 	struct g_geom		*d_geom;
 	struct devstat		*d_devstat;
+	int			d_destroyed;
 
 	/* Shared fields */
 	u_int			d_flags;
@@ -85,13 +86,16 @@ struct disk {
 	void			*d_drv1;
 };
 
-#define DISKFLAG_NOGIANT	0x1
+#define DISKFLAG_NEEDSGIANT	0x1
 #define DISKFLAG_OPEN		0x2
 #define DISKFLAG_CANDELETE	0x4
 
-void disk_create(int unit, struct disk *disk, int flags, void *unused, void *unused2);
+struct disk *disk_alloc(void);
+void disk_create(struct disk *disk, int version);
 void disk_destroy(struct disk *disk);
 
+#define DISK_VERSION_00		0x58561059
+#define DISK_VERSION		DISK_VERSION_00
 
 #endif /* _KERNEL */
 #endif /* _GEOM_GEOM_DISK_H_ */
diff --git a/sys/ia64/ia64/sscdisk.c b/sys/ia64/ia64/sscdisk.c
index c92cc55..d831ab9 100644
--- a/sys/ia64/ia64/sscdisk.c
+++ b/sys/ia64/ia64/sscdisk.c
@@ -84,7 +84,7 @@ struct ssc_s {
 	int unit;
 	LIST_ENTRY(ssc_s) list;
 	struct bio_queue_head bio_queue;
-	struct disk disk;
+	struct disk *disk;
 	dev_t dev;
 	int busy;
 	int fd;
@@ -174,15 +174,18 @@ ssccreate(int unit)
 	sc->unit = unit;
 	bioq_init(&sc->bio_queue);
 
-	sc->disk.d_drv1 = sc;
-	sc->disk.d_fwheads = 0;
-	sc->disk.d_fwsectors = 0;
-	sc->disk.d_maxsize = DFLTPHYS;
-	sc->disk.d_mediasize = (off_t)SSC_NSECT * DEV_BSIZE;
-	sc->disk.d_name = "sscdisk";
-	sc->disk.d_sectorsize = DEV_BSIZE;
-	sc->disk.d_strategy = sscstrategy;
-	disk_create(sc->unit, &sc->disk, 0, NULL, NULL);
+	sc->disk = disk_alloc();
+	sc->disk->d_drv1 = sc;
+	sc->disk->d_fwheads = 0;
+	sc->disk->d_fwsectors = 0;
+	sc->disk->d_maxsize = DFLTPHYS;
+	sc->disk->d_mediasize = (off_t)SSC_NSECT * DEV_BSIZE;
+	sc->disk->d_name = "sscdisk";
+	sc->disk->d_sectorsize = DEV_BSIZE;
+	sc->disk->d_strategy = sscstrategy;
+	sc->disk->d_unit = sc->unit;
+	sc->disk->d_flags = DISKFLAG_NEEDSGIANT;
+	disk_create(sc->disk, DISK_VERSION);
 	sc->fd = fd;
 	if (sc->unit == 0) 
 		sscrootready = 1;
diff --git a/sys/pc98/pc98/wd.c b/sys/pc98/pc98/wd.c
index 93b39f2..988ade8 100644
--- a/sys/pc98/pc98/wd.c
+++ b/sys/pc98/pc98/wd.c
@@ -184,7 +184,7 @@ struct softc {
 	struct diskgeom dk_dd;	/* device configuration data */
 	struct diskslices *dk_slices;	/* virtual drives */
 	void	*dk_dmacookie;	/* handle for DMA services */
-	struct disk disk;
+	struct disk *disk;
 };
 
 #define WD_COUNT_RETRIES
@@ -562,12 +562,15 @@ wdattach(struct isa_device *dvp)
 			/*
 			 * Register this media as a disk
 			 */
-			du->disk.d_open = wdopen;
-			du->disk.d_strategy = wdstrategy;
-			du->disk.d_drv1 = du;
-			du->disk.d_maxsize = 248 * 512;
-			du->disk.d_name = "wd";
-			disk_create(lunit, &du->disk, 0, NULL, NULL);
+			du->disk = disk_alloc();
+			du->disk->d_open = wdopen;
+			du->disk->d_strategy = wdstrategy;
+			du->disk->d_drv1 = du;
+			du->disk->d_maxsize = 248 * 512;
+			du->disk->d_name = "wd";
+			du->disk->d_unit = lunit;
+			du->disk->d_flags = DISKFLAG_NEEDSGIANT;
+			disk_create(du->disk, DISK_VERSION);
 			
 		} else {
 			free(du, M_TEMP);
@@ -1218,10 +1221,10 @@ wdopen(struct disk *dp)
 	du->dk_flags |= DKFL_LABELLING;
 	du->dk_state = WANTOPEN;
 
-	du->disk.d_sectorsize = du->dk_dd.d_secsize;
-	du->disk.d_mediasize = du->dk_dd.d_secperunit * du->dk_dd.d_secsize;
-	du->disk.d_fwsectors = du->dk_dd.d_nsectors;
-	du->disk.d_fwheads = du->dk_dd.d_ntracks;
+	du->disk->d_sectorsize = du->dk_dd.d_secsize;
+	du->disk->d_mediasize = du->dk_dd.d_secperunit * du->dk_dd.d_secsize;
+	du->disk->d_fwsectors = du->dk_dd.d_nsectors;
+	du->disk->d_fwheads = du->dk_dd.d_ntracks;
 
 	du->dk_flags &= ~DKFL_LABELLING;
 	wdsleep(du->dk_ctrlr, "wdopn2");