int
astattach(struct ata_device *atadev)
{
struct ast_softc *stp;
struct ast_readposition position;
dev_t dev;
stp = malloc(sizeof(struct ast_softc), M_AST, M_NOWAIT | M_ZERO);
if (!stp) {
ata_prtdev(atadev, "out of memory\n");
return 0;
}
stp->device = atadev;
stp->lun = ata_get_lun(&ast_lun_map);
ata_set_name(atadev, "ast", stp->lun);
bufq_init(&stp->queue);
if (ast_sense(stp)) {
free(stp, M_AST);
return 0;
}
if (!strcmp(atadev->param->model, "OnStream DI-30")) {
struct ast_transferpage transfer;
struct ast_identifypage identify;
stp->flags |= F_ONSTREAM;
bzero(&transfer, sizeof(struct ast_transferpage));
ast_mode_sense(stp, ATAPI_TAPE_TRANSFER_PAGE,
&transfer, sizeof(transfer));
bzero(&identify, sizeof(struct ast_identifypage));
ast_mode_sense(stp, ATAPI_TAPE_IDENTIFY_PAGE,
&identify, sizeof(identify));
strncpy(identify.ident, "FBSD", 4);
ast_mode_select(stp, &identify, sizeof(identify));
ast_read_position(stp, 0, &position);
}
devstat_add_entry(&stp->stats, "ast", stp->lun, DEV_BSIZE,
DEVSTAT_NO_ORDERED_TAGS,
DEVSTAT_TYPE_SEQUENTIAL | DEVSTAT_TYPE_IF_IDE,
DEVSTAT_PRIORITY_TAPE);
dev = make_dev(&ast_cdevsw, dkmakeminor(stp->lun, 0, 0),
UID_ROOT, GID_OPERATOR, 0640, "ast%d", stp->lun);
dev->si_drv1 = stp;
dev->si_iosize_max = 256 * DEV_BSIZE;
stp->dev1 = dev;
dev = make_dev(&ast_cdevsw, dkmakeminor(stp->lun, 0, 1),
UID_ROOT, GID_OPERATOR, 0640, "nast%d", stp->lun);
dev->si_drv1 = stp;
dev->si_iosize_max = 256 * DEV_BSIZE;
stp->dev2 = dev;
stp->device->flags |= ATA_D_MEDIA_CHANGED;
ast_describe(stp);
atadev->driver = stp;
return 1;
}
struct acd *
acd_init_lun(struct atapi *ata, int unit, struct atapi_params *ap, int lun,
struct devstat *device_stats)
{
struct acd *ptr;
dev_t pdev;
if (!(ptr = malloc(sizeof(struct acd), M_TEMP, M_NOWAIT | M_ZERO)))
return NULL;
bioq_init(&ptr->bio_queue);
ptr->ata = ata;
ptr->unit = unit;
ptr->lun = lun;
ptr->param = ap;
ptr->flags = F_MEDIA_CHANGED;
ptr->flags &= ~(F_WRITTEN|F_TRACK_PREP|F_TRACK_PREPED);
ptr->block_size = 2048;
ptr->refcnt = 0;
ptr->slot = -1;
ptr->changer_info = NULL;
if (device_stats == NULL) {
if (!(ptr->device_stats = malloc(sizeof(struct devstat),
M_TEMP, M_NOWAIT | M_ZERO)))
return NULL;
}
else
ptr->device_stats = device_stats;
pdev = make_dev(&acd_cdevsw, dkmakeminor(lun, 0, 0),
UID_ROOT, GID_OPERATOR, 0640, "wcd%da", lun);
make_dev_alias(pdev, "rwcd%da", lun);
pdev->si_drv1 = ptr;
pdev = make_dev(&acd_cdevsw, dkmakeminor(lun, 0, RAW_PART),
UID_ROOT, GID_OPERATOR, 0640, "wcd%dc", lun);
make_dev_alias(pdev, "rwcd%dc", lun);
pdev->si_drv1 = ptr;
return ptr;
}
static int
disk_probe_slice(struct disk *dp, cdev_t dev, int slice, int reprobe)
{
struct disk_info *info = &dp->d_info;
struct diskslice *sp = &dp->d_slice->dss_slices[slice];
disklabel_ops_t ops;
struct partinfo part;
const char *msg;
char uuid_buf[128];
cdev_t ndev;
int sno;
u_int i;
disk_debug(2, "disk_probe_slice (begin): %s (%s)\n",
dev->si_name, dp->d_cdev->si_name);
sno = slice ? slice - 1 : 0;
ops = &disklabel32_ops;
msg = ops->op_readdisklabel(dev, sp, &sp->ds_label, info);
if (msg && !strcmp(msg, "no disk label")) {
ops = &disklabel64_ops;
msg = ops->op_readdisklabel(dev, sp, &sp->ds_label, info);
}
if (msg == NULL) {
if (slice != WHOLE_DISK_SLICE)
ops->op_adjust_label_reserved(dp->d_slice, slice, sp);
else
sp->ds_reserved = 0;
sp->ds_ops = ops;
for (i = 0; i < ops->op_getnumparts(sp->ds_label); i++) {
ops->op_loadpartinfo(sp->ds_label, i, &part);
if (part.fstype) {
if (reprobe &&
(ndev = devfs_find_device_by_name("%s%c",
dev->si_name, 'a' + i))
) {
/*
* Device already exists and
* is still valid.
*/
ndev->si_flags |= SI_REPROBE_TEST;
/*
* Destroy old UUID alias
*/
destroy_dev_alias(ndev, "part-by-uuid/*");
/* Create UUID alias */
if (!kuuid_is_nil(&part.storage_uuid)) {
snprintf_uuid(uuid_buf,
sizeof(uuid_buf),
&part.storage_uuid);
make_dev_alias(ndev,
"part-by-uuid/%s",
uuid_buf);
udev_dict_set_cstr(ndev, "uuid", uuid_buf);
}
} else {
ndev = make_dev_covering(&disk_ops, dp->d_rawdev->si_ops,
dkmakeminor(dkunit(dp->d_cdev),
slice, i),
UID_ROOT, GID_OPERATOR, 0640,
"%s%c", dev->si_name, 'a'+ i);
ndev->si_parent = dev;
ndev->si_iosize_max = dev->si_iosize_max;
ndev->si_disk = dp;
udev_dict_set_cstr(ndev, "subsystem", "disk");
/* Inherit parent's disk type */
if (dp->d_disktype) {
udev_dict_set_cstr(ndev, "disk-type",
__DECONST(char *, dp->d_disktype));
}
/* Create serno alias */
if (dp->d_info.d_serialno) {
make_dev_alias(ndev,
"serno/%s.s%d%c",
dp->d_info.d_serialno,
sno, 'a' + i);
}
/* Create UUID alias */
if (!kuuid_is_nil(&part.storage_uuid)) {
snprintf_uuid(uuid_buf,
sizeof(uuid_buf),
&part.storage_uuid);
make_dev_alias(ndev,
"part-by-uuid/%s",
uuid_buf);
udev_dict_set_cstr(ndev, "uuid", uuid_buf);
}
ndev->si_flags |= SI_REPROBE_TEST;
}
}
}
} else if (info->d_dsflags & DSO_COMPATLABEL) {
