MFC r287499: Move setting of media parameters inside open routines.

This is preparation for possibility to open/close media several times
per LUN life cycle.  While there, rename variables to reduce confusion.
As additional bonus this allows to open read-only media, such as ZFS
snapshots.

1 files changed, 83 insertions, 106 deletions

diff --git a/sys/cam/ctl/ctl_backend_ramdisk.c b/sys/cam/ctl/ctl_backend_ramdisk.c
index 211738b..368c8dc 100644
--- a/sys/cam/ctl/ctl_backend_ramdisk.c
+++ b/sys/cam/ctl/ctl_backend_ramdisk.c
@@ -79,7 +79,7 @@ struct ctl_be_ramdisk_lun {
 	struct ctl_be_ramdisk_softc *softc;
 	ctl_be_ramdisk_lun_flags flags;
 	STAILQ_ENTRY(ctl_be_ramdisk_lun) links;
-	struct ctl_be_lun ctl_be_lun;
+	struct ctl_be_lun cbe_lun;
 	struct taskqueue *io_taskqueue;
 	struct task io_task;
 	STAILQ_HEAD(, ctl_io_hdr) cont_queue;
@@ -111,7 +111,7 @@ static int ctl_backend_ramdisk_ioctl(struct cdev *dev, u_long cmd,
 static int ctl_backend_ramdisk_rm(struct ctl_be_ramdisk_softc *softc,
 				  struct ctl_lun_req *req);
 static int ctl_backend_ramdisk_create(struct ctl_be_ramdisk_softc *softc,
-				      struct ctl_lun_req *req, int do_wait);
+				      struct ctl_lun_req *req);
 static int ctl_backend_ramdisk_modify(struct ctl_be_ramdisk_softc *softc,
 				  struct ctl_lun_req *req);
 static void ctl_backend_ramdisk_worker(void *context, int pending);
@@ -194,8 +194,8 @@ ctl_backend_ramdisk_shutdown(void)
 		 * lock of the same mutex, which would cause a hang.
 		 */
 		mtx_unlock(&softc->lock);
-		ctl_disable_lun(&lun->ctl_be_lun);
-		ctl_invalidate_lun(&lun->ctl_be_lun);
+		ctl_disable_lun(&lun->cbe_lun);
+		ctl_invalidate_lun(&lun->cbe_lun);
 		mtx_lock(&softc->lock);
 	}
 	mtx_unlock(&softc->lock);
@@ -218,16 +218,16 @@ ctl_backend_ramdisk_shutdown(void)
 static int
 ctl_backend_ramdisk_move_done(union ctl_io *io)
 {
-	struct ctl_be_lun *ctl_be_lun;
+	struct ctl_be_lun *cbe_lun;
 	struct ctl_be_ramdisk_lun *be_lun;
 #ifdef CTL_TIME_IO
 	struct bintime cur_bt;
 #endif
 
 	CTL_DEBUG_PRINT(("ctl_backend_ramdisk_move_done\n"));
-	ctl_be_lun = (struct ctl_be_lun *)io->io_hdr.ctl_private[
+	cbe_lun = (struct ctl_be_lun *)io->io_hdr.ctl_private[
 		CTL_PRIV_BACKEND_LUN].ptr;
-	be_lun = (struct ctl_be_ramdisk_lun *)ctl_be_lun->be_lun;
+	be_lun = (struct ctl_be_ramdisk_lun *)cbe_lun->be_lun;
 #ifdef CTL_TIME_IO
 	getbintime(&cur_bt);
 	bintime_sub(&cur_bt, &io->io_hdr.dma_start_bt);
@@ -274,10 +274,10 @@ ctl_backend_ramdisk_move_done(union ctl_io *io)
 static int
 ctl_backend_ramdisk_submit(union ctl_io *io)
 {
-	struct ctl_be_lun *ctl_be_lun;
+	struct ctl_be_lun *cbe_lun;
 	struct ctl_lba_len_flags *lbalen;
 
-	ctl_be_lun = (struct ctl_be_lun *)io->io_hdr.ctl_private[
+	cbe_lun = (struct ctl_be_lun *)io->io_hdr.ctl_private[
 		CTL_PRIV_BACKEND_LUN].ptr;
 	lbalen = (struct ctl_lba_len_flags *)&io->io_hdr.ctl_private[CTL_PRIV_LBA_LEN];
 	if (lbalen->flags & CTL_LLF_VERIFY) {
@@ -286,7 +286,7 @@ ctl_backend_ramdisk_submit(union ctl_io *io)
 		return (CTL_RETVAL_COMPLETE);
 	}
 	io->io_hdr.ctl_private[CTL_PRIV_BACKEND].integer =
-	    lbalen->len * ctl_be_lun->blocksize;
+	    lbalen->len * cbe_lun->blocksize;
 	ctl_backend_ramdisk_continue(io);
 	return (CTL_RETVAL_COMPLETE);
 }
@@ -391,8 +391,7 @@ ctl_backend_ramdisk_ioctl(struct cdev *dev, u_long cmd, caddr_t addr,
 
 		switch (lun_req->reqtype) {
 		case CTL_LUNREQ_CREATE:
-			retval = ctl_backend_ramdisk_create(softc, lun_req,
-							    /*do_wait*/ 1);
+			retval = ctl_backend_ramdisk_create(softc, lun_req);
 			break;
 		case CTL_LUNREQ_RM:
 			retval = ctl_backend_ramdisk_rm(softc, lun_req);
@@ -434,7 +433,7 @@ ctl_backend_ramdisk_rm(struct ctl_be_ramdisk_softc *softc,
 	mtx_lock(&softc->lock);
 
 	STAILQ_FOREACH(be_lun, &softc->lun_list, links) {
-		if (be_lun->ctl_be_lun.lun_id == params->lun_id)
+		if (be_lun->cbe_lun.lun_id == params->lun_id)
 			break;
 	}
 	mtx_unlock(&softc->lock);
@@ -446,7 +445,7 @@ ctl_backend_ramdisk_rm(struct ctl_be_ramdisk_softc *softc,
 		goto bailout_error;
 	}
 
-	retval = ctl_disable_lun(&be_lun->ctl_be_lun);
+	retval = ctl_disable_lun(&be_lun->cbe_lun);
 
 	if (retval != 0) {
 		snprintf(req->error_str, sizeof(req->error_str),
@@ -467,7 +466,7 @@ ctl_backend_ramdisk_rm(struct ctl_be_ramdisk_softc *softc,
 	be_lun->flags |= CTL_BE_RAMDISK_LUN_WAITING;
 	mtx_unlock(&softc->lock);
 
-	retval = ctl_invalidate_lun(&be_lun->ctl_be_lun);
+	retval = ctl_invalidate_lun(&be_lun->cbe_lun);
 	if (retval != 0) {
 		snprintf(req->error_str, sizeof(req->error_str),
 			 "%s: error %d returned from ctl_invalidate_lun() for "
@@ -504,7 +503,7 @@ ctl_backend_ramdisk_rm(struct ctl_be_ramdisk_softc *softc,
 	if (retval == 0) {
 		taskqueue_drain(be_lun->io_taskqueue, &be_lun->io_task);
 		taskqueue_free(be_lun->io_taskqueue);
-		ctl_free_opts(&be_lun->ctl_be_lun.options);
+		ctl_free_opts(&be_lun->cbe_lun.options);
 		mtx_destroy(&be_lun->queue_lock);
 		free(be_lun, M_RAMDISK);
 	}
@@ -521,122 +520,103 @@ bailout_error:
 
 static int
 ctl_backend_ramdisk_create(struct ctl_be_ramdisk_softc *softc,
-			   struct ctl_lun_req *req, int do_wait)
+			   struct ctl_lun_req *req)
 {
 	struct ctl_be_ramdisk_lun *be_lun;
+	struct ctl_be_lun *cbe_lun;
 	struct ctl_lun_create_params *params;
-	uint32_t blocksize;
 	char *value;
 	char tmpstr[32];
-	int retval, unmap;
+	int retval;
 
 	retval = 0;
 	params = &req->reqdata.create;
-	if (params->blocksize_bytes != 0)
-		blocksize = params->blocksize_bytes;
-	else
-		blocksize = 512;
-
-	be_lun = malloc(sizeof(*be_lun), M_RAMDISK, M_ZERO | (do_wait ?
-			M_WAITOK : M_NOWAIT));
 
-	if (be_lun == NULL) {
-		snprintf(req->error_str, sizeof(req->error_str),
-			 "%s: error allocating %zd bytes", __func__,
-			 sizeof(*be_lun));
-		goto bailout_error;
-	}
+	be_lun = malloc(sizeof(*be_lun), M_RAMDISK, M_ZERO | M_WAITOK);
+	cbe_lun = &be_lun->cbe_lun;
+	cbe_lun->be_lun = be_lun;
+	be_lun->softc = softc;
 	sprintf(be_lun->lunname, "cram%d", softc->num_luns);
-	ctl_init_opts(&be_lun->ctl_be_lun.options,
-	    req->num_be_args, req->kern_be_args);
+	ctl_init_opts(&cbe_lun->options, req->num_be_args, req->kern_be_args);
 
 	if (params->flags & CTL_LUN_FLAG_DEV_TYPE)
-		be_lun->ctl_be_lun.lun_type = params->device_type;
+		cbe_lun->lun_type = params->device_type;
 	else
-		be_lun->ctl_be_lun.lun_type = T_DIRECT;
-
-	if (be_lun->ctl_be_lun.lun_type == T_DIRECT) {
-
-		if (params->lun_size_bytes < blocksize) {
+		cbe_lun->lun_type = T_DIRECT;
+	be_lun->flags = CTL_BE_RAMDISK_LUN_UNCONFIGURED;
+	cbe_lun->flags = CTL_LUN_FLAG_PRIMARY;
+
+	if (cbe_lun->lun_type == T_DIRECT) {
+		if (params->blocksize_bytes != 0)
+			cbe_lun->blocksize = params->blocksize_bytes;
+		else
+			cbe_lun->blocksize = 512;
+		if (params->lun_size_bytes < cbe_lun->blocksize) {
 			snprintf(req->error_str, sizeof(req->error_str),
 				 "%s: LUN size %ju < blocksize %u", __func__,
-				 params->lun_size_bytes, blocksize);
+				 params->lun_size_bytes, cbe_lun->blocksize);
 			goto bailout_error;
 		}
-
-		be_lun->size_blocks = params->lun_size_bytes / blocksize;
-		be_lun->size_bytes = be_lun->size_blocks * blocksize;
-
-		be_lun->ctl_be_lun.maxlba = be_lun->size_blocks - 1;
-		be_lun->ctl_be_lun.atomicblock = UINT32_MAX;
-		be_lun->ctl_be_lun.opttxferlen = softc->rd_size / blocksize;
-	} else {
-		be_lun->ctl_be_lun.maxlba = 0;
-		blocksize = 0;
-		be_lun->size_bytes = 0;
-		be_lun->size_blocks = 0;
+		be_lun->size_blocks = params->lun_size_bytes / cbe_lun->blocksize;
+		be_lun->size_bytes = be_lun->size_blocks * cbe_lun->blocksize;
+		cbe_lun->maxlba = be_lun->size_blocks - 1;
+		cbe_lun->atomicblock = UINT32_MAX;
+		cbe_lun->opttxferlen = softc->rd_size / cbe_lun->blocksize;
 	}
 
-	be_lun->ctl_be_lun.blocksize = blocksize;
-
 	/* Tell the user the blocksize we ended up using */
-	params->blocksize_bytes = blocksize;
-
-	/* Tell the user the exact size we ended up using */
+	params->blocksize_bytes = cbe_lun->blocksize;
 	params->lun_size_bytes = be_lun->size_bytes;
 
-	be_lun->softc = softc;
-
-	unmap = 1;
-	value = ctl_get_opt(&be_lun->ctl_be_lun.options, "unmap");
+	value = ctl_get_opt(&cbe_lun->options, "unmap");
 	if (value != NULL && strcmp(value, "on") == 0)
-		unmap = (strcmp(value, "on") == 0);
-
-	be_lun->flags = CTL_BE_RAMDISK_LUN_UNCONFIGURED;
-	be_lun->ctl_be_lun.flags = CTL_LUN_FLAG_PRIMARY;
-	if (unmap)
-		be_lun->ctl_be_lun.flags |= CTL_LUN_FLAG_UNMAP;
-	be_lun->ctl_be_lun.be_lun = be_lun;
+		cbe_lun->flags |= CTL_LUN_FLAG_UNMAP;
+	value = ctl_get_opt(&cbe_lun->options, "readonly");
+	if (value != NULL && strcmp(value, "on") == 0)
+		cbe_lun->flags |= CTL_LUN_FLAG_READONLY;
+	cbe_lun->serseq = CTL_LUN_SERSEQ_OFF;
+	value = ctl_get_opt(&cbe_lun->options, "serseq");
+	if (value != NULL && strcmp(value, "on") == 0)
+		cbe_lun->serseq = CTL_LUN_SERSEQ_ON;
+	else if (value != NULL && strcmp(value, "read") == 0)
+		cbe_lun->serseq = CTL_LUN_SERSEQ_READ;
+	else if (value != NULL && strcmp(value, "off") == 0)
+		cbe_lun->serseq = CTL_LUN_SERSEQ_OFF;
 
 	if (params->flags & CTL_LUN_FLAG_ID_REQ) {
-		be_lun->ctl_be_lun.req_lun_id = params->req_lun_id;
-		be_lun->ctl_be_lun.flags |= CTL_LUN_FLAG_ID_REQ;
+		cbe_lun->req_lun_id = params->req_lun_id;
+		cbe_lun->flags |= CTL_LUN_FLAG_ID_REQ;
 	} else
-		be_lun->ctl_be_lun.req_lun_id = 0;
+		cbe_lun->req_lun_id = 0;
 
-	be_lun->ctl_be_lun.lun_shutdown = ctl_backend_ramdisk_lun_shutdown;
-	be_lun->ctl_be_lun.lun_config_status =
-		ctl_backend_ramdisk_lun_config_status;
-	be_lun->ctl_be_lun.be = &ctl_be_ramdisk_driver;
+	cbe_lun->lun_shutdown = ctl_backend_ramdisk_lun_shutdown;
+	cbe_lun->lun_config_status = ctl_backend_ramdisk_lun_config_status;
+	cbe_lun->be = &ctl_be_ramdisk_driver;
 	if ((params->flags & CTL_LUN_FLAG_SERIAL_NUM) == 0) {
 		snprintf(tmpstr, sizeof(tmpstr), "MYSERIAL%4d",
 			 softc->num_luns);
-		strncpy((char *)be_lun->ctl_be_lun.serial_num, tmpstr,
-			MIN(sizeof(be_lun->ctl_be_lun.serial_num),
-			    sizeof(tmpstr)));
+		strncpy((char *)cbe_lun->serial_num, tmpstr,
+			MIN(sizeof(cbe_lun->serial_num), sizeof(tmpstr)));
 
 		/* Tell the user what we used for a serial number */
 		strncpy((char *)params->serial_num, tmpstr,
 			MIN(sizeof(params->serial_num), sizeof(tmpstr)));
 	} else { 
-		strncpy((char *)be_lun->ctl_be_lun.serial_num,
-			params->serial_num,
-			MIN(sizeof(be_lun->ctl_be_lun.serial_num),
+		strncpy((char *)cbe_lun->serial_num, params->serial_num,
+			MIN(sizeof(cbe_lun->serial_num),
 			    sizeof(params->serial_num)));
 	}
 	if ((params->flags & CTL_LUN_FLAG_DEVID) == 0) {
 		snprintf(tmpstr, sizeof(tmpstr), "MYDEVID%4d", softc->num_luns);
-		strncpy((char *)be_lun->ctl_be_lun.device_id, tmpstr,
-			MIN(sizeof(be_lun->ctl_be_lun.device_id),
-			    sizeof(tmpstr)));
+		strncpy((char *)cbe_lun->device_id, tmpstr,
+			MIN(sizeof(cbe_lun->device_id), sizeof(tmpstr)));
 
 		/* Tell the user what we used for a device ID */
 		strncpy((char *)params->device_id, tmpstr,
 			MIN(sizeof(params->device_id), sizeof(tmpstr)));
 	} else {
-		strncpy((char *)be_lun->ctl_be_lun.device_id,
-			params->device_id,
-			MIN(sizeof(be_lun->ctl_be_lun.device_id),
+		strncpy((char *)cbe_lun->device_id, params->device_id,
+			MIN(sizeof(cbe_lun->device_id),
 			    sizeof(params->device_id)));
 	}
 
@@ -667,7 +647,7 @@ ctl_backend_ramdisk_create(struct ctl_be_ramdisk_softc *softc,
 
 	mtx_unlock(&softc->lock);
 
-	retval = ctl_add_lun(&be_lun->ctl_be_lun);
+	retval = ctl_add_lun(&be_lun->cbe_lun);
 	if (retval != 0) {
 		mtx_lock(&softc->lock);
 		STAILQ_REMOVE(&softc->lun_list, be_lun, ctl_be_ramdisk_lun,
@@ -681,9 +661,6 @@ ctl_backend_ramdisk_create(struct ctl_be_ramdisk_softc *softc,
 		goto bailout_error;
 	}
 
-	if (do_wait == 0)
-		return (retval);
-
 	mtx_lock(&softc->lock);
 
 	/*
@@ -709,7 +686,7 @@ ctl_backend_ramdisk_create(struct ctl_be_ramdisk_softc *softc,
 		mtx_unlock(&softc->lock);
 		goto bailout_error;
 	} else {
-		params->req_lun_id = be_lun->ctl_be_lun.lun_id;
+		params->req_lun_id = cbe_lun->lun_id;
 	}
 	mtx_unlock(&softc->lock);
 
@@ -723,7 +700,7 @@ bailout_error:
 		if (be_lun->io_taskqueue != NULL) {
 			taskqueue_free(be_lun->io_taskqueue);
 		}
-		ctl_free_opts(&be_lun->ctl_be_lun.options);
+		ctl_free_opts(&cbe_lun->options);
 		mtx_destroy(&be_lun->queue_lock);
 		free(be_lun, M_RAMDISK);
 	}
@@ -745,7 +722,7 @@ ctl_backend_ramdisk_modify(struct ctl_be_ramdisk_softc *softc,
 
 	mtx_lock(&softc->lock);
 	STAILQ_FOREACH(be_lun, &softc->lun_list, links) {
-		if (be_lun->ctl_be_lun.lun_id == params->lun_id)
+		if (be_lun->cbe_lun.lun_id == params->lun_id)
 			break;
 	}
 	mtx_unlock(&softc->lock);
@@ -764,7 +741,7 @@ ctl_backend_ramdisk_modify(struct ctl_be_ramdisk_softc *softc,
 		goto bailout_error;
 	}
 
-	blocksize = be_lun->ctl_be_lun.blocksize;
+	blocksize = be_lun->cbe_lun.blocksize;
 
 	if (params->lun_size_bytes < blocksize) {
 		snprintf(req->error_str, sizeof(req->error_str),
@@ -782,8 +759,8 @@ ctl_backend_ramdisk_modify(struct ctl_be_ramdisk_softc *softc,
 	 * XXX: Note that this field is being updated without locking,
 	 * 	which might cause problems on 32-bit architectures.
 	 */
-	be_lun->ctl_be_lun.maxlba = be_lun->size_blocks - 1;
-	ctl_lun_capacity_changed(&be_lun->ctl_be_lun);
+	be_lun->cbe_lun.maxlba = be_lun->size_blocks - 1;
+	ctl_lun_capacity_changed(&be_lun->cbe_lun);
 
 	/* Tell the user the exact size we ended up using */
 	params->lun_size_bytes = be_lun->size_bytes;
@@ -848,9 +825,9 @@ ctl_backend_ramdisk_lun_config_status(void *be_lun,
 		/*
 		 * We successfully added the LUN, attempt to enable it.
 		 */
-		if (ctl_enable_lun(&lun->ctl_be_lun) != 0) {
+		if (ctl_enable_lun(&lun->cbe_lun) != 0) {
 			printf("%s: ctl_enable_lun() failed!\n", __func__);
-			if (ctl_invalidate_lun(&lun->ctl_be_lun) != 0) {
+			if (ctl_invalidate_lun(&lun->cbe_lun) != 0) {
 				printf("%s: ctl_invalidate_lun() failed!\n",
 				       __func__);
 			}
@@ -911,23 +888,23 @@ ctl_backend_ramdisk_config_write(union ctl_io *io)
 		break;
 	case START_STOP_UNIT: {
 		struct scsi_start_stop_unit *cdb;
-		struct ctl_be_lun *ctl_be_lun;
+		struct ctl_be_lun *cbe_lun;
 		struct ctl_be_ramdisk_lun *be_lun;
 
 		cdb = (struct scsi_start_stop_unit *)io->scsiio.cdb;
 
-		ctl_be_lun = (struct ctl_be_lun *)io->io_hdr.ctl_private[
+		cbe_lun = (struct ctl_be_lun *)io->io_hdr.ctl_private[
 			CTL_PRIV_BACKEND_LUN].ptr;
-		be_lun = (struct ctl_be_ramdisk_lun *)ctl_be_lun->be_lun;
+		be_lun = (struct ctl_be_ramdisk_lun *)cbe_lun->be_lun;
 
 		if (cdb->how & SSS_START)
-			retval = ctl_start_lun(ctl_be_lun);
+			retval = ctl_start_lun(cbe_lun);
 		else {
-			retval = ctl_stop_lun(ctl_be_lun);
+			retval = ctl_stop_lun(cbe_lun);
 #ifdef NEEDTOPORT
 			if ((retval == 0)
 			 && (cdb->byte2 & SSS_ONOFFLINE))
-				retval = ctl_lun_offline(ctl_be_lun);
+				retval = ctl_lun_offline(cbe_lun);
 #endif
 		}