summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--sys/cam/scsi/scsi_cd.c49
-rw-r--r--sys/cam/scsi/scsi_da.c45
-rw-r--r--sys/contrib/dev/fla/fla.c27
-rw-r--r--sys/dev/aac/aac.c2
-rw-r--r--sys/dev/aac/aac_disk.c28
-rw-r--r--sys/dev/aac/aacvar.h2
-rw-r--r--sys/dev/amr/amr_disk.c29
-rw-r--r--sys/dev/amr/amrvar.h2
-rw-r--r--sys/dev/ata/ata-disk.c30
-rw-r--r--sys/dev/ata/ata-disk.h2
-rw-r--r--sys/dev/ata/ata-raid.c43
-rw-r--r--sys/dev/ata/ata-raid.h2
-rw-r--r--sys/dev/ata/atapi-fd.c30
-rw-r--r--sys/dev/ata/atapi-fd.h2
-rw-r--r--sys/dev/ida/ida_disk.c25
-rw-r--r--sys/dev/ida/idavar.h2
-rw-r--r--sys/dev/ips/ips_disk.c31
-rw-r--r--sys/dev/ips/ips_disk.h2
-rw-r--r--sys/dev/mlx/mlx_disk.c31
-rw-r--r--sys/dev/mlx/mlxvar.h2
-rw-r--r--sys/dev/ofw/ofw_disk.c23
-rw-r--r--sys/dev/pst/pst-raid.c23
-rw-r--r--sys/dev/raidframe/rf_freebsdkintf.c33
-rw-r--r--sys/dev/twe/twe_freebsd.c33
-rw-r--r--sys/geom/geom_disk.c54
-rw-r--r--sys/geom/geom_disk.h8
-rw-r--r--sys/ia64/ia64/sscdisk.c23
-rw-r--r--sys/pc98/pc98/wd.c25
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");
OpenPOWER on IntegriCloud