2 * Copyright (c) 2014 Alexander Motin <mav@FreeBSD.org>
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer,
10 * without modification, immediately at the beginning of the file.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
30 #include <sys/param.h>
31 #include <sys/systm.h>
32 #include <sys/kernel.h>
33 #include <sys/types.h>
35 #include <sys/module.h>
36 #include <sys/mutex.h>
37 #include <sys/condvar.h>
38 #include <sys/malloc.h>
40 #include <sys/queue.h>
41 #include <sys/sysctl.h>
42 #include <machine/atomic.h>
45 #include <cam/scsi/scsi_all.h>
46 #include <cam/scsi/scsi_da.h>
47 #include <cam/ctl/ctl_io.h>
48 #include <cam/ctl/ctl.h>
49 #include <cam/ctl/ctl_frontend.h>
50 #include <cam/ctl/ctl_frontend_internal.h>
51 #include <cam/ctl/ctl_util.h>
52 #include <cam/ctl/ctl_backend.h>
53 #include <cam/ctl/ctl_ioctl.h>
54 #include <cam/ctl/ctl_ha.h>
55 #include <cam/ctl/ctl_private.h>
56 #include <cam/ctl/ctl_debug.h>
57 #include <cam/ctl/ctl_scsi_all.h>
58 #include <cam/ctl/ctl_tpc.h>
59 #include <cam/ctl/ctl_error.h>
61 #define TPC_MAX_CSCDS 64
62 #define TPC_MAX_SEGS 64
64 #define TPC_MAX_LIST 8192
65 #define TPC_MAX_INLINE 0
66 #define TPC_MAX_LISTS 255
67 #define TPC_MAX_IO_SIZE (1024 * 1024)
68 #define TPC_MAX_IOCHUNK_SIZE (TPC_MAX_IO_SIZE * 16)
69 #define TPC_MIN_TOKEN_TIMEOUT 1
70 #define TPC_DFL_TOKEN_TIMEOUT 60
71 #define TPC_MAX_TOKEN_TIMEOUT 600
73 MALLOC_DEFINE(M_CTL_TPC, "ctltpc", "CTL TPC");
76 TPC_ERR_RETRY = 0x000,
79 TPC_ERR_NO_DECREMENT = 0x100
83 TAILQ_HEAD(runl, tpc_io);
87 struct tpc_list *list;
89 TAILQ_ENTRY(tpc_io) rlinks;
90 TAILQ_ENTRY(tpc_io) links;
98 struct scsi_range_desc *range;
103 TAILQ_ENTRY(tpc_token) links;
107 uint8_t service_action;
113 struct scsi_ec_cscd *cscd;
114 struct scsi_ec_segment *seg[TPC_MAX_SEGS];
119 struct tpc_token *token;
120 struct scsi_range_desc *range;
122 off_t offset_into_rod;
137 TAILQ_HEAD(, tpc_io) allio;
138 struct scsi_sense_data sense_data;
141 struct ctl_scsiio *ctsio;
144 uint8_t res_token[512];
145 TAILQ_ENTRY(tpc_list) links;
148 extern struct ctl_softc *control_softc;
151 tpc_timeout(void *arg)
153 struct ctl_softc *softc = arg;
155 struct tpc_token *token, *ttoken;
156 struct tpc_list *list, *tlist;
158 /* Free completed lists with expired timeout. */
159 STAILQ_FOREACH(lun, &softc->lun_list, links) {
160 mtx_lock(&lun->lun_lock);
161 TAILQ_FOREACH_SAFE(list, &lun->tpc_lists, links, tlist) {
162 if (!list->completed || time_uptime < list->last_active +
163 TPC_DFL_TOKEN_TIMEOUT)
165 TAILQ_REMOVE(&lun->tpc_lists, list, links);
168 mtx_unlock(&lun->lun_lock);
171 /* Free inactive ROD tokens with expired timeout. */
172 TAILQ_FOREACH_SAFE(token, &softc->tpc_tokens, links, ttoken) {
174 time_uptime < token->last_active + token->timeout + 1)
176 TAILQ_REMOVE(&softc->tpc_tokens, token, links);
177 free(token->params, M_CTL);
180 callout_schedule(&softc->tpc_timeout, hz);
184 ctl_tpc_init(struct ctl_softc *softc)
187 TAILQ_INIT(&softc->tpc_tokens);
188 callout_init_mtx(&softc->tpc_timeout, &softc->ctl_lock, 0);
189 callout_reset(&softc->tpc_timeout, hz, tpc_timeout, softc);
193 ctl_tpc_shutdown(struct ctl_softc *softc)
195 struct tpc_token *token;
197 callout_drain(&softc->tpc_timeout);
199 /* Free ROD tokens. */
200 mtx_lock(&softc->ctl_lock);
201 while ((token = TAILQ_FIRST(&softc->tpc_tokens)) != NULL) {
202 TAILQ_REMOVE(&softc->tpc_tokens, token, links);
203 free(token->params, M_CTL);
206 mtx_unlock(&softc->ctl_lock);
210 ctl_tpc_lun_init(struct ctl_lun *lun)
213 TAILQ_INIT(&lun->tpc_lists);
217 ctl_tpc_lun_shutdown(struct ctl_lun *lun)
219 struct tpc_list *list;
220 struct tpc_token *token, *ttoken;
222 /* Free lists for this LUN. */
223 while ((list = TAILQ_FIRST(&lun->tpc_lists)) != NULL) {
224 TAILQ_REMOVE(&lun->tpc_lists, list, links);
225 KASSERT(list->completed,
226 ("Not completed TPC (%p) on shutdown", list));
230 /* Free ROD tokens for this LUN. */
231 mtx_assert(&control_softc->ctl_lock, MA_OWNED);
232 TAILQ_FOREACH_SAFE(token, &control_softc->tpc_tokens, links, ttoken) {
233 if (token->lun != lun->lun || token->active)
235 TAILQ_REMOVE(&control_softc->tpc_tokens, token, links);
236 free(token->params, M_CTL);
242 ctl_inquiry_evpd_tpc(struct ctl_scsiio *ctsio, int alloc_len)
244 struct scsi_vpd_tpc *tpc_ptr;
245 struct scsi_vpd_tpc_descriptor *d_ptr;
246 struct scsi_vpd_tpc_descriptor_bdrl *bdrl_ptr;
247 struct scsi_vpd_tpc_descriptor_sc *sc_ptr;
248 struct scsi_vpd_tpc_descriptor_sc_descr *scd_ptr;
249 struct scsi_vpd_tpc_descriptor_pd *pd_ptr;
250 struct scsi_vpd_tpc_descriptor_sd *sd_ptr;
251 struct scsi_vpd_tpc_descriptor_sdid *sdid_ptr;
252 struct scsi_vpd_tpc_descriptor_rtf *rtf_ptr;
253 struct scsi_vpd_tpc_descriptor_rtf_block *rtfb_ptr;
254 struct scsi_vpd_tpc_descriptor_srt *srt_ptr;
255 struct scsi_vpd_tpc_descriptor_srtd *srtd_ptr;
256 struct scsi_vpd_tpc_descriptor_gco *gco_ptr;
260 lun = (struct ctl_lun *)ctsio->io_hdr.ctl_private[CTL_PRIV_LUN].ptr;
262 data_len = sizeof(struct scsi_vpd_tpc) +
263 sizeof(struct scsi_vpd_tpc_descriptor_bdrl) +
264 roundup2(sizeof(struct scsi_vpd_tpc_descriptor_sc) +
265 2 * sizeof(struct scsi_vpd_tpc_descriptor_sc_descr) + 11, 4) +
266 sizeof(struct scsi_vpd_tpc_descriptor_pd) +
267 roundup2(sizeof(struct scsi_vpd_tpc_descriptor_sd) + 4, 4) +
268 roundup2(sizeof(struct scsi_vpd_tpc_descriptor_sdid) + 2, 4) +
269 sizeof(struct scsi_vpd_tpc_descriptor_rtf) +
270 sizeof(struct scsi_vpd_tpc_descriptor_rtf_block) +
271 sizeof(struct scsi_vpd_tpc_descriptor_srt) +
272 2*sizeof(struct scsi_vpd_tpc_descriptor_srtd) +
273 sizeof(struct scsi_vpd_tpc_descriptor_gco);
275 ctsio->kern_data_ptr = malloc(data_len, M_CTL, M_WAITOK | M_ZERO);
276 tpc_ptr = (struct scsi_vpd_tpc *)ctsio->kern_data_ptr;
277 ctsio->kern_sg_entries = 0;
279 if (data_len < alloc_len) {
280 ctsio->residual = alloc_len - data_len;
281 ctsio->kern_data_len = data_len;
282 ctsio->kern_total_len = data_len;
285 ctsio->kern_data_len = alloc_len;
286 ctsio->kern_total_len = alloc_len;
288 ctsio->kern_data_resid = 0;
289 ctsio->kern_rel_offset = 0;
290 ctsio->kern_sg_entries = 0;
293 * The control device is always connected. The disk device, on the
294 * other hand, may not be online all the time.
297 tpc_ptr->device = (SID_QUAL_LU_CONNECTED << 5) |
298 lun->be_lun->lun_type;
300 tpc_ptr->device = (SID_QUAL_LU_OFFLINE << 5) | T_DIRECT;
301 tpc_ptr->page_code = SVPD_SCSI_TPC;
302 scsi_ulto2b(data_len - 4, tpc_ptr->page_length);
304 /* Block Device ROD Limits */
305 d_ptr = (struct scsi_vpd_tpc_descriptor *)&tpc_ptr->descr[0];
306 bdrl_ptr = (struct scsi_vpd_tpc_descriptor_bdrl *)d_ptr;
307 scsi_ulto2b(SVPD_TPC_BDRL, bdrl_ptr->desc_type);
308 scsi_ulto2b(sizeof(*bdrl_ptr) - 4, bdrl_ptr->desc_length);
309 scsi_ulto2b(TPC_MAX_SEGS, bdrl_ptr->maximum_ranges);
310 scsi_ulto4b(TPC_MAX_TOKEN_TIMEOUT,
311 bdrl_ptr->maximum_inactivity_timeout);
312 scsi_ulto4b(TPC_DFL_TOKEN_TIMEOUT,
313 bdrl_ptr->default_inactivity_timeout);
314 scsi_u64to8b(0, bdrl_ptr->maximum_token_transfer_size);
315 scsi_u64to8b(0, bdrl_ptr->optimal_transfer_count);
317 /* Supported commands */
318 d_ptr = (struct scsi_vpd_tpc_descriptor *)
319 (&d_ptr->parameters[0] + scsi_2btoul(d_ptr->desc_length));
320 sc_ptr = (struct scsi_vpd_tpc_descriptor_sc *)d_ptr;
321 scsi_ulto2b(SVPD_TPC_SC, sc_ptr->desc_type);
322 sc_ptr->list_length = 2 * sizeof(*scd_ptr) + 11;
323 scsi_ulto2b(roundup2(1 + sc_ptr->list_length, 4), sc_ptr->desc_length);
324 scd_ptr = &sc_ptr->descr[0];
325 scd_ptr->opcode = EXTENDED_COPY;
326 scd_ptr->sa_length = 5;
327 scd_ptr->supported_service_actions[0] = EC_EC_LID1;
328 scd_ptr->supported_service_actions[1] = EC_EC_LID4;
329 scd_ptr->supported_service_actions[2] = EC_PT;
330 scd_ptr->supported_service_actions[3] = EC_WUT;
331 scd_ptr->supported_service_actions[4] = EC_COA;
332 scd_ptr = (struct scsi_vpd_tpc_descriptor_sc_descr *)
333 &scd_ptr->supported_service_actions[scd_ptr->sa_length];
334 scd_ptr->opcode = RECEIVE_COPY_STATUS;
335 scd_ptr->sa_length = 6;
336 scd_ptr->supported_service_actions[0] = RCS_RCS_LID1;
337 scd_ptr->supported_service_actions[1] = RCS_RCFD;
338 scd_ptr->supported_service_actions[2] = RCS_RCS_LID4;
339 scd_ptr->supported_service_actions[3] = RCS_RCOP;
340 scd_ptr->supported_service_actions[4] = RCS_RRTI;
341 scd_ptr->supported_service_actions[5] = RCS_RART;
343 /* Parameter data. */
344 d_ptr = (struct scsi_vpd_tpc_descriptor *)
345 (&d_ptr->parameters[0] + scsi_2btoul(d_ptr->desc_length));
346 pd_ptr = (struct scsi_vpd_tpc_descriptor_pd *)d_ptr;
347 scsi_ulto2b(SVPD_TPC_PD, pd_ptr->desc_type);
348 scsi_ulto2b(sizeof(*pd_ptr) - 4, pd_ptr->desc_length);
349 scsi_ulto2b(TPC_MAX_CSCDS, pd_ptr->maximum_cscd_descriptor_count);
350 scsi_ulto2b(TPC_MAX_SEGS, pd_ptr->maximum_segment_descriptor_count);
351 scsi_ulto4b(TPC_MAX_LIST, pd_ptr->maximum_descriptor_list_length);
352 scsi_ulto4b(TPC_MAX_INLINE, pd_ptr->maximum_inline_data_length);
354 /* Supported Descriptors */
355 d_ptr = (struct scsi_vpd_tpc_descriptor *)
356 (&d_ptr->parameters[0] + scsi_2btoul(d_ptr->desc_length));
357 sd_ptr = (struct scsi_vpd_tpc_descriptor_sd *)d_ptr;
358 scsi_ulto2b(SVPD_TPC_SD, sd_ptr->desc_type);
359 scsi_ulto2b(roundup2(sizeof(*sd_ptr) - 4 + 4, 4), sd_ptr->desc_length);
360 sd_ptr->list_length = 4;
361 sd_ptr->supported_descriptor_codes[0] = EC_SEG_B2B;
362 sd_ptr->supported_descriptor_codes[1] = EC_SEG_VERIFY;
363 sd_ptr->supported_descriptor_codes[2] = EC_SEG_REGISTER_KEY;
364 sd_ptr->supported_descriptor_codes[3] = EC_CSCD_ID;
366 /* Supported CSCD Descriptor IDs */
367 d_ptr = (struct scsi_vpd_tpc_descriptor *)
368 (&d_ptr->parameters[0] + scsi_2btoul(d_ptr->desc_length));
369 sdid_ptr = (struct scsi_vpd_tpc_descriptor_sdid *)d_ptr;
370 scsi_ulto2b(SVPD_TPC_SDID, sdid_ptr->desc_type);
371 scsi_ulto2b(roundup2(sizeof(*sdid_ptr) - 4 + 2, 4), sdid_ptr->desc_length);
372 scsi_ulto2b(2, sdid_ptr->list_length);
373 scsi_ulto2b(0xffff, &sdid_ptr->supported_descriptor_ids[0]);
375 /* ROD Token Features */
376 d_ptr = (struct scsi_vpd_tpc_descriptor *)
377 (&d_ptr->parameters[0] + scsi_2btoul(d_ptr->desc_length));
378 rtf_ptr = (struct scsi_vpd_tpc_descriptor_rtf *)d_ptr;
379 scsi_ulto2b(SVPD_TPC_RTF, rtf_ptr->desc_type);
380 scsi_ulto2b(sizeof(*rtf_ptr) - 4 + sizeof(*rtfb_ptr), rtf_ptr->desc_length);
381 rtf_ptr->remote_tokens = 0;
382 scsi_ulto4b(TPC_MIN_TOKEN_TIMEOUT, rtf_ptr->minimum_token_lifetime);
383 scsi_ulto4b(UINT32_MAX, rtf_ptr->maximum_token_lifetime);
384 scsi_ulto4b(TPC_MAX_TOKEN_TIMEOUT,
385 rtf_ptr->maximum_token_inactivity_timeout);
386 scsi_ulto2b(sizeof(*rtfb_ptr), rtf_ptr->type_specific_features_length);
387 rtfb_ptr = (struct scsi_vpd_tpc_descriptor_rtf_block *)
388 &rtf_ptr->type_specific_features;
389 rtfb_ptr->type_format = SVPD_TPC_RTF_BLOCK;
390 scsi_ulto2b(sizeof(*rtfb_ptr) - 4, rtfb_ptr->desc_length);
391 scsi_ulto2b(0, rtfb_ptr->optimal_length_granularity);
392 scsi_u64to8b(0, rtfb_ptr->maximum_bytes);
393 scsi_u64to8b(0, rtfb_ptr->optimal_bytes);
394 scsi_u64to8b(TPC_MAX_IOCHUNK_SIZE,
395 rtfb_ptr->optimal_bytes_to_token_per_segment);
396 scsi_u64to8b(TPC_MAX_IOCHUNK_SIZE,
397 rtfb_ptr->optimal_bytes_from_token_per_segment);
399 /* Supported ROD Tokens */
400 d_ptr = (struct scsi_vpd_tpc_descriptor *)
401 (&d_ptr->parameters[0] + scsi_2btoul(d_ptr->desc_length));
402 srt_ptr = (struct scsi_vpd_tpc_descriptor_srt *)d_ptr;
403 scsi_ulto2b(SVPD_TPC_SRT, srt_ptr->desc_type);
404 scsi_ulto2b(sizeof(*srt_ptr) - 4 + 2*sizeof(*srtd_ptr), srt_ptr->desc_length);
405 scsi_ulto2b(2*sizeof(*srtd_ptr), srt_ptr->rod_type_descriptors_length);
406 srtd_ptr = (struct scsi_vpd_tpc_descriptor_srtd *)
407 &srt_ptr->rod_type_descriptors;
408 scsi_ulto4b(ROD_TYPE_AUR, srtd_ptr->rod_type);
409 srtd_ptr->flags = SVPD_TPC_SRTD_TIN | SVPD_TPC_SRTD_TOUT;
410 scsi_ulto2b(0, srtd_ptr->preference_indicator);
412 scsi_ulto4b(ROD_TYPE_BLOCK_ZERO, srtd_ptr->rod_type);
413 srtd_ptr->flags = SVPD_TPC_SRTD_TIN;
414 scsi_ulto2b(0, srtd_ptr->preference_indicator);
416 /* General Copy Operations */
417 d_ptr = (struct scsi_vpd_tpc_descriptor *)
418 (&d_ptr->parameters[0] + scsi_2btoul(d_ptr->desc_length));
419 gco_ptr = (struct scsi_vpd_tpc_descriptor_gco *)d_ptr;
420 scsi_ulto2b(SVPD_TPC_GCO, gco_ptr->desc_type);
421 scsi_ulto2b(sizeof(*gco_ptr) - 4, gco_ptr->desc_length);
422 scsi_ulto4b(TPC_MAX_LISTS, gco_ptr->total_concurrent_copies);
423 scsi_ulto4b(TPC_MAX_LISTS, gco_ptr->maximum_identified_concurrent_copies);
424 scsi_ulto4b(TPC_MAX_SEG, gco_ptr->maximum_segment_length);
425 gco_ptr->data_segment_granularity = 0;
426 gco_ptr->inline_data_granularity = 0;
428 ctsio->scsi_status = SCSI_STATUS_OK;
429 ctsio->io_hdr.flags |= CTL_FLAG_ALLOCATED;
430 ctsio->be_move_done = ctl_config_move_done;
431 ctl_datamove((union ctl_io *)ctsio);
433 return (CTL_RETVAL_COMPLETE);
437 ctl_receive_copy_operating_parameters(struct ctl_scsiio *ctsio)
439 struct scsi_receive_copy_operating_parameters *cdb;
440 struct scsi_receive_copy_operating_parameters_data *data;
442 int alloc_len, total_len;
444 CTL_DEBUG_PRINT(("ctl_report_supported_tmf\n"));
446 cdb = (struct scsi_receive_copy_operating_parameters *)ctsio->cdb;
448 retval = CTL_RETVAL_COMPLETE;
450 total_len = sizeof(*data) + 4;
451 alloc_len = scsi_4btoul(cdb->length);
453 ctsio->kern_data_ptr = malloc(total_len, M_CTL, M_WAITOK | M_ZERO);
455 ctsio->kern_sg_entries = 0;
457 if (total_len < alloc_len) {
458 ctsio->residual = alloc_len - total_len;
459 ctsio->kern_data_len = total_len;
460 ctsio->kern_total_len = total_len;
463 ctsio->kern_data_len = alloc_len;
464 ctsio->kern_total_len = alloc_len;
466 ctsio->kern_data_resid = 0;
467 ctsio->kern_rel_offset = 0;
469 data = (struct scsi_receive_copy_operating_parameters_data *)ctsio->kern_data_ptr;
470 scsi_ulto4b(sizeof(*data) - 4 + 4, data->length);
471 data->snlid = RCOP_SNLID;
472 scsi_ulto2b(TPC_MAX_CSCDS, data->maximum_cscd_descriptor_count);
473 scsi_ulto2b(TPC_MAX_SEGS, data->maximum_segment_descriptor_count);
474 scsi_ulto4b(TPC_MAX_LIST, data->maximum_descriptor_list_length);
475 scsi_ulto4b(TPC_MAX_SEG, data->maximum_segment_length);
476 scsi_ulto4b(TPC_MAX_INLINE, data->maximum_inline_data_length);
477 scsi_ulto4b(0, data->held_data_limit);
478 scsi_ulto4b(0, data->maximum_stream_device_transfer_size);
479 scsi_ulto2b(TPC_MAX_LISTS, data->total_concurrent_copies);
480 data->maximum_concurrent_copies = TPC_MAX_LISTS;
481 data->data_segment_granularity = 0;
482 data->inline_data_granularity = 0;
483 data->held_data_granularity = 0;
484 data->implemented_descriptor_list_length = 4;
485 data->list_of_implemented_descriptor_type_codes[0] = EC_SEG_B2B;
486 data->list_of_implemented_descriptor_type_codes[1] = EC_SEG_VERIFY;
487 data->list_of_implemented_descriptor_type_codes[2] = EC_SEG_REGISTER_KEY;
488 data->list_of_implemented_descriptor_type_codes[3] = EC_CSCD_ID;
490 ctsio->io_hdr.flags |= CTL_FLAG_ALLOCATED;
491 ctsio->be_move_done = ctl_config_move_done;
493 ctl_datamove((union ctl_io *)ctsio);
497 static struct tpc_list *
498 tpc_find_list(struct ctl_lun *lun, uint32_t list_id, uint32_t init_idx)
500 struct tpc_list *list;
502 mtx_assert(&lun->lun_lock, MA_OWNED);
503 TAILQ_FOREACH(list, &lun->tpc_lists, links) {
504 if ((list->flags & EC_LIST_ID_USAGE_MASK) !=
505 EC_LIST_ID_USAGE_NONE && list->list_id == list_id &&
506 list->init_idx == init_idx)
513 ctl_receive_copy_status_lid1(struct ctl_scsiio *ctsio)
516 struct scsi_receive_copy_status_lid1 *cdb;
517 struct scsi_receive_copy_status_lid1_data *data;
518 struct tpc_list *list;
519 struct tpc_list list_copy;
521 int alloc_len, total_len;
524 CTL_DEBUG_PRINT(("ctl_receive_copy_status_lid1\n"));
526 cdb = (struct scsi_receive_copy_status_lid1 *)ctsio->cdb;
527 lun = (struct ctl_lun *)ctsio->io_hdr.ctl_private[CTL_PRIV_LUN].ptr;
529 retval = CTL_RETVAL_COMPLETE;
531 list_id = cdb->list_identifier;
532 mtx_lock(&lun->lun_lock);
533 list = tpc_find_list(lun, list_id,
534 ctl_get_resindex(&ctsio->io_hdr.nexus));
536 mtx_unlock(&lun->lun_lock);
537 ctl_set_invalid_field(ctsio, /*sks_valid*/ 1,
538 /*command*/ 1, /*field*/ 2, /*bit_valid*/ 0,
540 ctl_done((union ctl_io *)ctsio);
544 if (list->completed) {
545 TAILQ_REMOVE(&lun->tpc_lists, list, links);
548 mtx_unlock(&lun->lun_lock);
550 total_len = sizeof(*data);
551 alloc_len = scsi_4btoul(cdb->length);
553 ctsio->kern_data_ptr = malloc(total_len, M_CTL, M_WAITOK | M_ZERO);
555 ctsio->kern_sg_entries = 0;
557 if (total_len < alloc_len) {
558 ctsio->residual = alloc_len - total_len;
559 ctsio->kern_data_len = total_len;
560 ctsio->kern_total_len = total_len;
563 ctsio->kern_data_len = alloc_len;
564 ctsio->kern_total_len = alloc_len;
566 ctsio->kern_data_resid = 0;
567 ctsio->kern_rel_offset = 0;
569 data = (struct scsi_receive_copy_status_lid1_data *)ctsio->kern_data_ptr;
570 scsi_ulto4b(sizeof(*data) - 4, data->available_data);
571 if (list_copy.completed) {
572 if (list_copy.error || list_copy.abort)
573 data->copy_command_status = RCS_CCS_ERROR;
575 data->copy_command_status = RCS_CCS_COMPLETED;
577 data->copy_command_status = RCS_CCS_INPROG;
578 scsi_ulto2b(list_copy.curseg, data->segments_processed);
579 if (list_copy.curbytes <= UINT32_MAX) {
580 data->transfer_count_units = RCS_TC_BYTES;
581 scsi_ulto4b(list_copy.curbytes, data->transfer_count);
583 data->transfer_count_units = RCS_TC_MBYTES;
584 scsi_ulto4b(list_copy.curbytes >> 20, data->transfer_count);
587 ctsio->io_hdr.flags |= CTL_FLAG_ALLOCATED;
588 ctsio->be_move_done = ctl_config_move_done;
590 ctl_datamove((union ctl_io *)ctsio);
595 ctl_receive_copy_failure_details(struct ctl_scsiio *ctsio)
598 struct scsi_receive_copy_failure_details *cdb;
599 struct scsi_receive_copy_failure_details_data *data;
600 struct tpc_list *list;
601 struct tpc_list list_copy;
603 int alloc_len, total_len;
606 CTL_DEBUG_PRINT(("ctl_receive_copy_failure_details\n"));
608 cdb = (struct scsi_receive_copy_failure_details *)ctsio->cdb;
609 lun = (struct ctl_lun *)ctsio->io_hdr.ctl_private[CTL_PRIV_LUN].ptr;
611 retval = CTL_RETVAL_COMPLETE;
613 list_id = cdb->list_identifier;
614 mtx_lock(&lun->lun_lock);
615 list = tpc_find_list(lun, list_id,
616 ctl_get_resindex(&ctsio->io_hdr.nexus));
617 if (list == NULL || !list->completed) {
618 mtx_unlock(&lun->lun_lock);
619 ctl_set_invalid_field(ctsio, /*sks_valid*/ 1,
620 /*command*/ 1, /*field*/ 2, /*bit_valid*/ 0,
622 ctl_done((union ctl_io *)ctsio);
626 TAILQ_REMOVE(&lun->tpc_lists, list, links);
628 mtx_unlock(&lun->lun_lock);
630 total_len = sizeof(*data) + list_copy.sense_len;
631 alloc_len = scsi_4btoul(cdb->length);
633 ctsio->kern_data_ptr = malloc(total_len, M_CTL, M_WAITOK | M_ZERO);
635 ctsio->kern_sg_entries = 0;
637 if (total_len < alloc_len) {
638 ctsio->residual = alloc_len - total_len;
639 ctsio->kern_data_len = total_len;
640 ctsio->kern_total_len = total_len;
643 ctsio->kern_data_len = alloc_len;
644 ctsio->kern_total_len = alloc_len;
646 ctsio->kern_data_resid = 0;
647 ctsio->kern_rel_offset = 0;
649 data = (struct scsi_receive_copy_failure_details_data *)ctsio->kern_data_ptr;
650 if (list_copy.completed && (list_copy.error || list_copy.abort)) {
651 scsi_ulto4b(sizeof(*data) - 4 + list_copy.sense_len,
652 data->available_data);
653 data->copy_command_status = RCS_CCS_ERROR;
655 scsi_ulto4b(0, data->available_data);
656 scsi_ulto2b(list_copy.sense_len, data->sense_data_length);
657 memcpy(data->sense_data, &list_copy.sense_data, list_copy.sense_len);
659 ctsio->io_hdr.flags |= CTL_FLAG_ALLOCATED;
660 ctsio->be_move_done = ctl_config_move_done;
662 ctl_datamove((union ctl_io *)ctsio);
667 ctl_receive_copy_status_lid4(struct ctl_scsiio *ctsio)
670 struct scsi_receive_copy_status_lid4 *cdb;
671 struct scsi_receive_copy_status_lid4_data *data;
672 struct tpc_list *list;
673 struct tpc_list list_copy;
675 int alloc_len, total_len;
678 CTL_DEBUG_PRINT(("ctl_receive_copy_status_lid4\n"));
680 cdb = (struct scsi_receive_copy_status_lid4 *)ctsio->cdb;
681 lun = (struct ctl_lun *)ctsio->io_hdr.ctl_private[CTL_PRIV_LUN].ptr;
683 retval = CTL_RETVAL_COMPLETE;
685 list_id = scsi_4btoul(cdb->list_identifier);
686 mtx_lock(&lun->lun_lock);
687 list = tpc_find_list(lun, list_id,
688 ctl_get_resindex(&ctsio->io_hdr.nexus));
690 mtx_unlock(&lun->lun_lock);
691 ctl_set_invalid_field(ctsio, /*sks_valid*/ 1,
692 /*command*/ 1, /*field*/ 2, /*bit_valid*/ 0,
694 ctl_done((union ctl_io *)ctsio);
698 if (list->completed) {
699 TAILQ_REMOVE(&lun->tpc_lists, list, links);
702 mtx_unlock(&lun->lun_lock);
704 total_len = sizeof(*data) + list_copy.sense_len;
705 alloc_len = scsi_4btoul(cdb->length);
707 ctsio->kern_data_ptr = malloc(total_len, M_CTL, M_WAITOK | M_ZERO);
709 ctsio->kern_sg_entries = 0;
711 if (total_len < alloc_len) {
712 ctsio->residual = alloc_len - total_len;
713 ctsio->kern_data_len = total_len;
714 ctsio->kern_total_len = total_len;
717 ctsio->kern_data_len = alloc_len;
718 ctsio->kern_total_len = alloc_len;
720 ctsio->kern_data_resid = 0;
721 ctsio->kern_rel_offset = 0;
723 data = (struct scsi_receive_copy_status_lid4_data *)ctsio->kern_data_ptr;
724 scsi_ulto4b(sizeof(*data) - 4 + list_copy.sense_len,
725 data->available_data);
726 data->response_to_service_action = list_copy.service_action;
727 if (list_copy.completed) {
729 data->copy_command_status = RCS_CCS_ERROR;
730 else if (list_copy.abort)
731 data->copy_command_status = RCS_CCS_ABORTED;
733 data->copy_command_status = RCS_CCS_COMPLETED;
735 data->copy_command_status = RCS_CCS_INPROG_FG;
736 scsi_ulto2b(list_copy.curops, data->operation_counter);
737 scsi_ulto4b(UINT32_MAX, data->estimated_status_update_delay);
738 data->transfer_count_units = RCS_TC_BYTES;
739 scsi_u64to8b(list_copy.curbytes, data->transfer_count);
740 scsi_ulto2b(list_copy.curseg, data->segments_processed);
741 data->length_of_the_sense_data_field = list_copy.sense_len;
742 data->sense_data_length = list_copy.sense_len;
743 memcpy(data->sense_data, &list_copy.sense_data, list_copy.sense_len);
745 ctsio->io_hdr.flags |= CTL_FLAG_ALLOCATED;
746 ctsio->be_move_done = ctl_config_move_done;
748 ctl_datamove((union ctl_io *)ctsio);
753 ctl_copy_operation_abort(struct ctl_scsiio *ctsio)
756 struct scsi_copy_operation_abort *cdb;
757 struct tpc_list *list;
761 CTL_DEBUG_PRINT(("ctl_copy_operation_abort\n"));
763 cdb = (struct scsi_copy_operation_abort *)ctsio->cdb;
764 lun = (struct ctl_lun *)ctsio->io_hdr.ctl_private[CTL_PRIV_LUN].ptr;
766 retval = CTL_RETVAL_COMPLETE;
768 list_id = scsi_4btoul(cdb->list_identifier);
769 mtx_lock(&lun->lun_lock);
770 list = tpc_find_list(lun, list_id,
771 ctl_get_resindex(&ctsio->io_hdr.nexus));
773 mtx_unlock(&lun->lun_lock);
774 ctl_set_invalid_field(ctsio, /*sks_valid*/ 1,
775 /*command*/ 1, /*field*/ 2, /*bit_valid*/ 0,
777 ctl_done((union ctl_io *)ctsio);
781 mtx_unlock(&lun->lun_lock);
783 ctl_set_success(ctsio);
784 ctl_done((union ctl_io *)ctsio);
789 tpc_resolve(struct tpc_list *list, uint16_t idx, uint32_t *ss)
793 if (ss && list->lun->be_lun)
794 *ss = list->lun->be_lun->blocksize;
795 return (list->lun->lun);
797 if (idx >= list->ncscd)
799 return (tpcl_resolve(list->init_port, &list->cscd[idx], ss));
803 tpc_process_b2b(struct tpc_list *list)
805 struct scsi_ec_segment_b2b *seg;
806 struct scsi_ec_cscd_dtsp *sdstp, *ddstp;
807 struct tpc_io *tior, *tiow;
808 struct runl run, *prun;
810 off_t srclba, dstlba, numbytes, donebytes, roundbytes;
812 uint32_t srcblock, dstblock;
814 if (list->stage == 1) {
816 while ((tior = TAILQ_FIRST(&list->allio)) != NULL) {
817 TAILQ_REMOVE(&list->allio, tior, links);
818 ctl_free_io(tior->io);
821 free(list->buf, M_CTL);
823 ctl_set_task_aborted(list->ctsio);
824 return (CTL_RETVAL_ERROR);
825 } else if (list->error) {
826 ctl_set_sense(list->ctsio, /*current_error*/ 1,
827 /*sense_key*/ SSD_KEY_COPY_ABORTED,
828 /*asc*/ 0x0d, /*ascq*/ 0x01, SSD_ELEM_NONE);
829 return (CTL_RETVAL_ERROR);
831 list->cursectors += list->segsectors;
832 list->curbytes += list->segbytes;
833 return (CTL_RETVAL_COMPLETE);
836 TAILQ_INIT(&list->allio);
837 seg = (struct scsi_ec_segment_b2b *)list->seg[list->curseg];
838 sl = tpc_resolve(list, scsi_2btoul(seg->src_cscd), &srcblock);
839 dl = tpc_resolve(list, scsi_2btoul(seg->dst_cscd), &dstblock);
840 if (sl >= CTL_MAX_LUNS || dl >= CTL_MAX_LUNS) {
841 ctl_set_sense(list->ctsio, /*current_error*/ 1,
842 /*sense_key*/ SSD_KEY_COPY_ABORTED,
843 /*asc*/ 0x08, /*ascq*/ 0x04, SSD_ELEM_NONE);
844 return (CTL_RETVAL_ERROR);
846 sdstp = &list->cscd[scsi_2btoul(seg->src_cscd)].dtsp;
847 if (scsi_3btoul(sdstp->block_length) != 0)
848 srcblock = scsi_3btoul(sdstp->block_length);
849 ddstp = &list->cscd[scsi_2btoul(seg->dst_cscd)].dtsp;
850 if (scsi_3btoul(ddstp->block_length) != 0)
851 dstblock = scsi_3btoul(ddstp->block_length);
852 numlba = scsi_2btoul(seg->number_of_blocks);
853 if (seg->flags & EC_SEG_DC)
854 numbytes = (off_t)numlba * dstblock;
856 numbytes = (off_t)numlba * srcblock;
857 srclba = scsi_8btou64(seg->src_lba);
858 dstlba = scsi_8btou64(seg->dst_lba);
860 // printf("Copy %ju bytes from %ju @ %ju to %ju @ %ju\n",
861 // (uintmax_t)numbytes, sl, scsi_8btou64(seg->src_lba),
862 // dl, scsi_8btou64(seg->dst_lba));
865 return (CTL_RETVAL_COMPLETE);
867 if (numbytes % srcblock != 0 || numbytes % dstblock != 0) {
868 ctl_set_sense(list->ctsio, /*current_error*/ 1,
869 /*sense_key*/ SSD_KEY_COPY_ABORTED,
870 /*asc*/ 0x26, /*ascq*/ 0x0A, SSD_ELEM_NONE);
871 return (CTL_RETVAL_ERROR);
874 list->buf = malloc(numbytes, M_CTL, M_WAITOK);
875 list->segbytes = numbytes;
876 list->segsectors = numbytes / dstblock;
881 while (donebytes < numbytes) {
882 roundbytes = MIN(numbytes - donebytes, TPC_MAX_IO_SIZE);
884 tior = malloc(sizeof(*tior), M_CTL, M_WAITOK | M_ZERO);
885 TAILQ_INIT(&tior->run);
887 TAILQ_INSERT_TAIL(&list->allio, tior, links);
888 tior->io = tpcl_alloc_io();
889 if (tior->io == NULL) {
893 ctl_scsi_read_write(tior->io,
894 /*data_ptr*/ &list->buf[donebytes],
895 /*data_len*/ roundbytes,
898 /*minimum_cdb_size*/ 0,
899 /*lba*/ srclba + donebytes / srcblock,
900 /*num_blocks*/ roundbytes / srcblock,
901 /*tag_type*/ CTL_TAG_SIMPLE,
903 tior->io->io_hdr.retries = 3;
905 tior->io->io_hdr.ctl_private[CTL_PRIV_FRONTEND].ptr = tior;
907 tiow = malloc(sizeof(*tior), M_CTL, M_WAITOK | M_ZERO);
908 TAILQ_INIT(&tiow->run);
910 TAILQ_INSERT_TAIL(&list->allio, tiow, links);
911 tiow->io = tpcl_alloc_io();
912 if (tiow->io == NULL) {
916 ctl_scsi_read_write(tiow->io,
917 /*data_ptr*/ &list->buf[donebytes],
918 /*data_len*/ roundbytes,
921 /*minimum_cdb_size*/ 0,
922 /*lba*/ dstlba + donebytes / dstblock,
923 /*num_blocks*/ roundbytes / dstblock,
924 /*tag_type*/ CTL_TAG_SIMPLE,
926 tiow->io->io_hdr.retries = 3;
928 tiow->io->io_hdr.ctl_private[CTL_PRIV_FRONTEND].ptr = tior;
930 TAILQ_INSERT_TAIL(&tior->run, tiow, rlinks);
931 TAILQ_INSERT_TAIL(prun, tior, rlinks);
933 donebytes += roundbytes;
936 while ((tior = TAILQ_FIRST(&run)) != NULL) {
937 TAILQ_REMOVE(&run, tior, rlinks);
938 if (tpcl_queue(tior->io, tior->lun) != CTL_RETVAL_COMPLETE)
939 panic("tpcl_queue() error");
943 return (CTL_RETVAL_QUEUED);
947 tpc_process_verify(struct tpc_list *list)
949 struct scsi_ec_segment_verify *seg;
953 if (list->stage == 1) {
955 while ((tio = TAILQ_FIRST(&list->allio)) != NULL) {
956 TAILQ_REMOVE(&list->allio, tio, links);
957 ctl_free_io(tio->io);
961 ctl_set_task_aborted(list->ctsio);
962 return (CTL_RETVAL_ERROR);
963 } else if (list->error) {
964 ctl_set_sense(list->ctsio, /*current_error*/ 1,
965 /*sense_key*/ SSD_KEY_COPY_ABORTED,
966 /*asc*/ 0x0d, /*ascq*/ 0x01, SSD_ELEM_NONE);
967 return (CTL_RETVAL_ERROR);
969 return (CTL_RETVAL_COMPLETE);
972 TAILQ_INIT(&list->allio);
973 seg = (struct scsi_ec_segment_verify *)list->seg[list->curseg];
974 sl = tpc_resolve(list, scsi_2btoul(seg->src_cscd), NULL);
975 if (sl >= CTL_MAX_LUNS) {
976 ctl_set_sense(list->ctsio, /*current_error*/ 1,
977 /*sense_key*/ SSD_KEY_COPY_ABORTED,
978 /*asc*/ 0x08, /*ascq*/ 0x04, SSD_ELEM_NONE);
979 return (CTL_RETVAL_ERROR);
982 // printf("Verify %ju\n", sl);
984 if ((seg->tur & 0x01) == 0)
985 return (CTL_RETVAL_COMPLETE);
988 tio = malloc(sizeof(*tio), M_CTL, M_WAITOK | M_ZERO);
989 TAILQ_INIT(&tio->run);
991 TAILQ_INSERT_TAIL(&list->allio, tio, links);
992 tio->io = tpcl_alloc_io();
993 if (tio->io == NULL) {
997 ctl_scsi_tur(tio->io, /*tag_type*/ CTL_TAG_SIMPLE, /*control*/ 0);
998 tio->io->io_hdr.retries = 3;
1000 tio->io->io_hdr.ctl_private[CTL_PRIV_FRONTEND].ptr = tio;
1002 if (tpcl_queue(tio->io, tio->lun) != CTL_RETVAL_COMPLETE)
1003 panic("tpcl_queue() error");
1004 return (CTL_RETVAL_QUEUED);
1008 tpc_process_register_key(struct tpc_list *list)
1010 struct scsi_ec_segment_register_key *seg;
1015 if (list->stage == 1) {
1017 while ((tio = TAILQ_FIRST(&list->allio)) != NULL) {
1018 TAILQ_REMOVE(&list->allio, tio, links);
1019 ctl_free_io(tio->io);
1022 free(list->buf, M_CTL);
1024 ctl_set_task_aborted(list->ctsio);
1025 return (CTL_RETVAL_ERROR);
1026 } else if (list->error) {
1027 ctl_set_sense(list->ctsio, /*current_error*/ 1,
1028 /*sense_key*/ SSD_KEY_COPY_ABORTED,
1029 /*asc*/ 0x0d, /*ascq*/ 0x01, SSD_ELEM_NONE);
1030 return (CTL_RETVAL_ERROR);
1032 return (CTL_RETVAL_COMPLETE);
1035 TAILQ_INIT(&list->allio);
1036 seg = (struct scsi_ec_segment_register_key *)list->seg[list->curseg];
1037 dl = tpc_resolve(list, scsi_2btoul(seg->dst_cscd), NULL);
1038 if (dl >= CTL_MAX_LUNS) {
1039 ctl_set_sense(list->ctsio, /*current_error*/ 1,
1040 /*sense_key*/ SSD_KEY_COPY_ABORTED,
1041 /*asc*/ 0x08, /*ascq*/ 0x04, SSD_ELEM_NONE);
1042 return (CTL_RETVAL_ERROR);
1045 // printf("Register Key %ju\n", dl);
1048 tio = malloc(sizeof(*tio), M_CTL, M_WAITOK | M_ZERO);
1049 TAILQ_INIT(&tio->run);
1051 TAILQ_INSERT_TAIL(&list->allio, tio, links);
1052 tio->io = tpcl_alloc_io();
1053 if (tio->io == NULL) {
1057 datalen = sizeof(struct scsi_per_res_out_parms);
1058 list->buf = malloc(datalen, M_CTL, M_WAITOK);
1059 ctl_scsi_persistent_res_out(tio->io,
1060 list->buf, datalen, SPRO_REGISTER, -1,
1061 scsi_8btou64(seg->res_key), scsi_8btou64(seg->sa_res_key),
1062 /*tag_type*/ CTL_TAG_SIMPLE, /*control*/ 0);
1063 tio->io->io_hdr.retries = 3;
1065 tio->io->io_hdr.ctl_private[CTL_PRIV_FRONTEND].ptr = tio;
1067 if (tpcl_queue(tio->io, tio->lun) != CTL_RETVAL_COMPLETE)
1068 panic("tpcl_queue() error");
1069 return (CTL_RETVAL_QUEUED);
1073 tpc_ranges_length(struct scsi_range_desc *range, int nrange)
1078 for (r = 0; r < nrange; r++)
1079 length += scsi_4btoul(range[r].length);
1084 tpc_skip_ranges(struct scsi_range_desc *range, int nrange, off_t skip,
1085 int *srange, off_t *soffset)
1092 while (r < nrange) {
1093 if (skip - off < scsi_4btoul(range[r].length)) {
1095 *soffset = skip - off;
1098 off += scsi_4btoul(range[r].length);
1105 tpc_process_wut(struct tpc_list *list)
1107 struct tpc_io *tio, *tior, *tiow;
1108 struct runl run, *prun;
1110 off_t doffset, soffset;
1111 off_t srclba, dstlba, numbytes, donebytes, roundbytes;
1112 uint32_t srcblock, dstblock;
1114 if (list->stage > 0) {
1116 /* Cleanup after previous rounds. */
1117 while ((tio = TAILQ_FIRST(&list->allio)) != NULL) {
1118 TAILQ_REMOVE(&list->allio, tio, links);
1119 ctl_free_io(tio->io);
1122 free(list->buf, M_CTL);
1124 ctl_set_task_aborted(list->ctsio);
1125 return (CTL_RETVAL_ERROR);
1126 } else if (list->error) {
1127 ctl_set_sense(list->ctsio, /*current_error*/ 1,
1128 /*sense_key*/ SSD_KEY_COPY_ABORTED,
1129 /*asc*/ 0x0d, /*ascq*/ 0x01, SSD_ELEM_NONE);
1130 return (CTL_RETVAL_ERROR);
1132 list->cursectors += list->segsectors;
1133 list->curbytes += list->segbytes;
1136 /* Check where we are on destination ranges list. */
1137 if (tpc_skip_ranges(list->range, list->nrange, list->cursectors,
1138 &drange, &doffset) != 0)
1139 return (CTL_RETVAL_COMPLETE);
1140 dstblock = list->lun->be_lun->blocksize;
1142 /* Check where we are on source ranges list. */
1143 srcblock = list->token->blocksize;
1144 if (tpc_skip_ranges(list->token->range, list->token->nrange,
1145 list->offset_into_rod + list->cursectors * dstblock / srcblock,
1146 &srange, &soffset) != 0) {
1147 ctl_set_sense(list->ctsio, /*current_error*/ 1,
1148 /*sense_key*/ SSD_KEY_COPY_ABORTED,
1149 /*asc*/ 0x0d, /*ascq*/ 0x04, SSD_ELEM_NONE);
1150 return (CTL_RETVAL_ERROR);
1153 srclba = scsi_8btou64(list->token->range[srange].lba) + soffset;
1154 numbytes = srcblock * omin(TPC_MAX_IOCHUNK_SIZE / srcblock,
1155 (scsi_4btoul(list->token->range[srange].length) - soffset));
1156 dstlba = scsi_8btou64(list->range[drange].lba) + doffset;
1157 numbytes = omin(numbytes,
1158 dstblock * omin(TPC_MAX_IOCHUNK_SIZE / dstblock,
1159 (scsi_4btoul(list->range[drange].length) - doffset)));
1161 if (numbytes % srcblock != 0 || numbytes % dstblock != 0) {
1162 ctl_set_sense(list->ctsio, /*current_error*/ 1,
1163 /*sense_key*/ SSD_KEY_COPY_ABORTED,
1164 /*asc*/ 0x26, /*ascq*/ 0x0A, SSD_ELEM_NONE);
1165 return (CTL_RETVAL_ERROR);
1168 list->buf = malloc(numbytes, M_CTL, M_WAITOK |
1169 (list->token == NULL ? M_ZERO : 0));
1170 list->segbytes = numbytes;
1171 list->segsectors = numbytes / dstblock;
1172 //printf("Copy chunk of %ju sectors from %ju to %ju\n", list->segsectors,
1178 TAILQ_INIT(&list->allio);
1179 while (donebytes < numbytes) {
1180 roundbytes = MIN(numbytes - donebytes, TPC_MAX_IO_SIZE);
1182 tior = malloc(sizeof(*tior), M_CTL, M_WAITOK | M_ZERO);
1183 TAILQ_INIT(&tior->run);
1185 TAILQ_INSERT_TAIL(&list->allio, tior, links);
1186 tior->io = tpcl_alloc_io();
1187 if (tior->io == NULL) {
1191 ctl_scsi_read_write(tior->io,
1192 /*data_ptr*/ &list->buf[donebytes],
1193 /*data_len*/ roundbytes,
1196 /*minimum_cdb_size*/ 0,
1197 /*lba*/ srclba + donebytes / srcblock,
1198 /*num_blocks*/ roundbytes / srcblock,
1199 /*tag_type*/ CTL_TAG_SIMPLE,
1201 tior->io->io_hdr.retries = 3;
1202 tior->lun = list->token->lun;
1203 tior->io->io_hdr.ctl_private[CTL_PRIV_FRONTEND].ptr = tior;
1205 tiow = malloc(sizeof(*tiow), M_CTL, M_WAITOK | M_ZERO);
1206 TAILQ_INIT(&tiow->run);
1208 TAILQ_INSERT_TAIL(&list->allio, tiow, links);
1209 tiow->io = tpcl_alloc_io();
1210 if (tiow->io == NULL) {
1214 ctl_scsi_read_write(tiow->io,
1215 /*data_ptr*/ &list->buf[donebytes],
1216 /*data_len*/ roundbytes,
1219 /*minimum_cdb_size*/ 0,
1220 /*lba*/ dstlba + donebytes / dstblock,
1221 /*num_blocks*/ roundbytes / dstblock,
1222 /*tag_type*/ CTL_TAG_SIMPLE,
1224 tiow->io->io_hdr.retries = 3;
1225 tiow->lun = list->lun->lun;
1226 tiow->io->io_hdr.ctl_private[CTL_PRIV_FRONTEND].ptr = tiow;
1228 TAILQ_INSERT_TAIL(&tior->run, tiow, rlinks);
1229 TAILQ_INSERT_TAIL(prun, tior, rlinks);
1231 donebytes += roundbytes;
1234 while ((tior = TAILQ_FIRST(&run)) != NULL) {
1235 TAILQ_REMOVE(&run, tior, rlinks);
1236 if (tpcl_queue(tior->io, tior->lun) != CTL_RETVAL_COMPLETE)
1237 panic("tpcl_queue() error");
1241 return (CTL_RETVAL_QUEUED);
1245 tpc_process_zero_wut(struct tpc_list *list)
1247 struct tpc_io *tio, *tiow;
1248 struct runl run, *prun;
1250 uint32_t dstblock, len;
1252 if (list->stage > 0) {
1254 /* Cleanup after previous rounds. */
1255 while ((tio = TAILQ_FIRST(&list->allio)) != NULL) {
1256 TAILQ_REMOVE(&list->allio, tio, links);
1257 ctl_free_io(tio->io);
1260 free(list->buf, M_CTL);
1262 ctl_set_task_aborted(list->ctsio);
1263 return (CTL_RETVAL_ERROR);
1264 } else if (list->error) {
1265 ctl_set_sense(list->ctsio, /*current_error*/ 1,
1266 /*sense_key*/ SSD_KEY_COPY_ABORTED,
1267 /*asc*/ 0x0d, /*ascq*/ 0x01, SSD_ELEM_NONE);
1268 return (CTL_RETVAL_ERROR);
1270 list->cursectors += list->segsectors;
1271 list->curbytes += list->segbytes;
1272 return (CTL_RETVAL_COMPLETE);
1275 dstblock = list->lun->be_lun->blocksize;
1276 list->buf = malloc(dstblock, M_CTL, M_WAITOK | M_ZERO);
1280 TAILQ_INIT(&list->allio);
1281 list->segsectors = 0;
1282 for (r = 0; r < list->nrange; r++) {
1283 len = scsi_4btoul(list->range[r].length);
1287 tiow = malloc(sizeof(*tiow), M_CTL, M_WAITOK | M_ZERO);
1288 TAILQ_INIT(&tiow->run);
1290 TAILQ_INSERT_TAIL(&list->allio, tiow, links);
1291 tiow->io = tpcl_alloc_io();
1292 if (tiow->io == NULL) {
1296 ctl_scsi_write_same(tiow->io,
1297 /*data_ptr*/ list->buf,
1298 /*data_len*/ dstblock,
1300 /*lba*/ scsi_8btou64(list->range[r].lba),
1302 /*tag_type*/ CTL_TAG_SIMPLE,
1304 tiow->io->io_hdr.retries = 3;
1305 tiow->lun = list->lun->lun;
1306 tiow->io->io_hdr.ctl_private[CTL_PRIV_FRONTEND].ptr = tiow;
1308 TAILQ_INSERT_TAIL(prun, tiow, rlinks);
1310 list->segsectors += len;
1312 list->segbytes = list->segsectors * dstblock;
1314 if (TAILQ_EMPTY(&run))
1317 while ((tiow = TAILQ_FIRST(&run)) != NULL) {
1318 TAILQ_REMOVE(&run, tiow, rlinks);
1319 if (tpcl_queue(tiow->io, tiow->lun) != CTL_RETVAL_COMPLETE)
1320 panic("tpcl_queue() error");
1324 return (CTL_RETVAL_QUEUED);
1328 tpc_process(struct tpc_list *list)
1330 struct ctl_lun *lun = list->lun;
1331 struct scsi_ec_segment *seg;
1332 struct ctl_scsiio *ctsio = list->ctsio;
1333 int retval = CTL_RETVAL_COMPLETE;
1335 if (list->service_action == EC_WUT) {
1336 if (list->token != NULL)
1337 retval = tpc_process_wut(list);
1339 retval = tpc_process_zero_wut(list);
1340 if (retval == CTL_RETVAL_QUEUED)
1342 if (retval == CTL_RETVAL_ERROR) {
1347 //printf("ZZZ %d cscd, %d segs\n", list->ncscd, list->nseg);
1348 while (list->curseg < list->nseg) {
1349 seg = list->seg[list->curseg];
1350 switch (seg->type_code) {
1352 retval = tpc_process_b2b(list);
1355 retval = tpc_process_verify(list);
1357 case EC_SEG_REGISTER_KEY:
1358 retval = tpc_process_register_key(list);
1361 ctl_set_sense(ctsio, /*current_error*/ 1,
1362 /*sense_key*/ SSD_KEY_COPY_ABORTED,
1363 /*asc*/ 0x26, /*ascq*/ 0x09, SSD_ELEM_NONE);
1366 if (retval == CTL_RETVAL_QUEUED)
1368 if (retval == CTL_RETVAL_ERROR) {
1377 ctl_set_success(ctsio);
1380 //printf("ZZZ done\n");
1381 free(list->params, M_CTL);
1382 list->params = NULL;
1384 mtx_lock(&control_softc->ctl_lock);
1385 if (--list->token->active == 0)
1386 list->token->last_active = time_uptime;
1387 mtx_unlock(&control_softc->ctl_lock);
1390 mtx_lock(&lun->lun_lock);
1391 if ((list->flags & EC_LIST_ID_USAGE_MASK) == EC_LIST_ID_USAGE_NONE) {
1392 TAILQ_REMOVE(&lun->tpc_lists, list, links);
1395 list->completed = 1;
1396 list->last_active = time_uptime;
1397 list->sense_data = ctsio->sense_data;
1398 list->sense_len = ctsio->sense_len;
1399 list->scsi_status = ctsio->scsi_status;
1401 mtx_unlock(&lun->lun_lock);
1403 ctl_done((union ctl_io *)ctsio);
1407 * For any sort of check condition, busy, etc., we just retry. We do not
1408 * decrement the retry count for unit attention type errors. These are
1409 * normal, and we want to save the retry count for "real" errors. Otherwise,
1410 * we could end up with situations where a command will succeed in some
1411 * situations and fail in others, depending on whether a unit attention is
1412 * pending. Also, some of our error recovery actions, most notably the
1413 * LUN reset action, will cause a unit attention.
1415 * We can add more detail here later if necessary.
1417 static tpc_error_action
1418 tpc_checkcond_parse(union ctl_io *io)
1420 tpc_error_action error_action;
1421 int error_code, sense_key, asc, ascq;
1424 * Default to retrying the command.
1426 error_action = TPC_ERR_RETRY;
1428 scsi_extract_sense_len(&io->scsiio.sense_data,
1429 io->scsiio.sense_len,
1436 switch (error_code) {
1437 case SSD_DEFERRED_ERROR:
1438 case SSD_DESC_DEFERRED_ERROR:
1439 error_action |= TPC_ERR_NO_DECREMENT;
1441 case SSD_CURRENT_ERROR:
1442 case SSD_DESC_CURRENT_ERROR:
1444 switch (sense_key) {
1445 case SSD_KEY_UNIT_ATTENTION:
1446 error_action |= TPC_ERR_NO_DECREMENT;
1448 case SSD_KEY_HARDWARE_ERROR:
1450 * This is our generic "something bad happened"
1451 * error code. It often isn't recoverable.
1453 if ((asc == 0x44) && (ascq == 0x00))
1454 error_action = TPC_ERR_FAIL;
1456 case SSD_KEY_NOT_READY:
1458 * If the LUN is powered down, there likely isn't
1459 * much point in retrying right now.
1461 if ((asc == 0x04) && (ascq == 0x02))
1462 error_action = TPC_ERR_FAIL;
1464 * If the LUN is offline, there probably isn't much
1465 * point in retrying, either.
1467 if ((asc == 0x04) && (ascq == 0x03))
1468 error_action = TPC_ERR_FAIL;
1472 return (error_action);
1475 static tpc_error_action
1476 tpc_error_parse(union ctl_io *io)
1478 tpc_error_action error_action = TPC_ERR_RETRY;
1480 switch (io->io_hdr.io_type) {
1482 switch (io->io_hdr.status & CTL_STATUS_MASK) {
1483 case CTL_SCSI_ERROR:
1484 switch (io->scsiio.scsi_status) {
1485 case SCSI_STATUS_CHECK_COND:
1486 error_action = tpc_checkcond_parse(io);
1499 panic("%s: invalid ctl_io type %d\n", __func__,
1500 io->io_hdr.io_type);
1503 return (error_action);
1507 tpc_done(union ctl_io *io)
1509 struct tpc_io *tio, *tior;
1512 * Very minimal retry logic. We basically retry if we got an error
1513 * back, and the retry count is greater than 0. If we ever want
1514 * more sophisticated initiator type behavior, the CAM error
1515 * recovery code in ../common might be helpful.
1517 // if ((io->io_hdr.status & CTL_STATUS_MASK) != CTL_SUCCESS)
1518 // ctl_io_error_print(io, NULL);
1519 tio = io->io_hdr.ctl_private[CTL_PRIV_FRONTEND].ptr;
1520 if (((io->io_hdr.status & CTL_STATUS_MASK) != CTL_SUCCESS)
1521 && (io->io_hdr.retries > 0)) {
1522 ctl_io_status old_status;
1523 tpc_error_action error_action;
1525 error_action = tpc_error_parse(io);
1526 switch (error_action & TPC_ERR_MASK) {
1531 if ((error_action & TPC_ERR_NO_DECREMENT) == 0)
1532 io->io_hdr.retries--;
1533 old_status = io->io_hdr.status;
1534 io->io_hdr.status = CTL_STATUS_NONE;
1535 io->io_hdr.flags &= ~CTL_FLAG_ABORT;
1536 io->io_hdr.flags &= ~CTL_FLAG_SENT_2OTHER_SC;
1537 if (tpcl_queue(io, tio->lun) != CTL_RETVAL_COMPLETE) {
1538 printf("%s: error returned from ctl_queue()!\n",
1540 io->io_hdr.status = old_status;
1546 if ((io->io_hdr.status & CTL_STATUS_MASK) != CTL_SUCCESS)
1547 tio->list->error = 1;
1549 atomic_add_int(&tio->list->curops, 1);
1550 if (!tio->list->error && !tio->list->abort) {
1551 while ((tior = TAILQ_FIRST(&tio->run)) != NULL) {
1552 TAILQ_REMOVE(&tio->run, tior, rlinks);
1553 atomic_add_int(&tio->list->tbdio, 1);
1554 if (tpcl_queue(tior->io, tior->lun) != CTL_RETVAL_COMPLETE)
1555 panic("tpcl_queue() error");
1558 if (atomic_fetchadd_int(&tio->list->tbdio, -1) == 1)
1559 tpc_process(tio->list);
1563 ctl_extended_copy_lid1(struct ctl_scsiio *ctsio)
1565 struct scsi_extended_copy *cdb;
1566 struct scsi_extended_copy_lid1_data *data;
1567 struct ctl_lun *lun;
1568 struct tpc_list *list, *tlist;
1571 int len, off, lencscd, lenseg, leninl, nseg;
1573 CTL_DEBUG_PRINT(("ctl_extended_copy_lid1\n"));
1575 lun = (struct ctl_lun *)ctsio->io_hdr.ctl_private[CTL_PRIV_LUN].ptr;
1576 cdb = (struct scsi_extended_copy *)ctsio->cdb;
1577 len = scsi_4btoul(cdb->length);
1579 if (len < sizeof(struct scsi_extended_copy_lid1_data) ||
1580 len > sizeof(struct scsi_extended_copy_lid1_data) +
1581 TPC_MAX_LIST + TPC_MAX_INLINE) {
1582 ctl_set_invalid_field(ctsio, /*sks_valid*/ 1, /*command*/ 1,
1583 /*field*/ 9, /*bit_valid*/ 0, /*bit*/ 0);
1588 * If we've got a kernel request that hasn't been malloced yet,
1589 * malloc it and tell the caller the data buffer is here.
1591 if ((ctsio->io_hdr.flags & CTL_FLAG_ALLOCATED) == 0) {
1592 ctsio->kern_data_ptr = malloc(len, M_CTL, M_WAITOK);
1593 ctsio->kern_data_len = len;
1594 ctsio->kern_total_len = len;
1595 ctsio->kern_data_resid = 0;
1596 ctsio->kern_rel_offset = 0;
1597 ctsio->kern_sg_entries = 0;
1598 ctsio->io_hdr.flags |= CTL_FLAG_ALLOCATED;
1599 ctsio->be_move_done = ctl_config_move_done;
1600 ctl_datamove((union ctl_io *)ctsio);
1602 return (CTL_RETVAL_COMPLETE);
1605 data = (struct scsi_extended_copy_lid1_data *)ctsio->kern_data_ptr;
1606 lencscd = scsi_2btoul(data->cscd_list_length);
1607 lenseg = scsi_4btoul(data->segment_list_length);
1608 leninl = scsi_4btoul(data->inline_data_length);
1609 if (len < sizeof(struct scsi_extended_copy_lid1_data) +
1610 lencscd + lenseg + leninl ||
1611 leninl > TPC_MAX_INLINE) {
1612 ctl_set_invalid_field(ctsio, /*sks_valid*/ 1, /*command*/ 0,
1613 /*field*/ 2, /*bit_valid*/ 0, /*bit*/ 0);
1616 if (lencscd > TPC_MAX_CSCDS * sizeof(struct scsi_ec_cscd)) {
1617 ctl_set_sense(ctsio, /*current_error*/ 1,
1618 /*sense_key*/ SSD_KEY_ILLEGAL_REQUEST,
1619 /*asc*/ 0x26, /*ascq*/ 0x06, SSD_ELEM_NONE);
1622 if (lencscd + lenseg > TPC_MAX_LIST) {
1623 ctl_set_param_len_error(ctsio);
1627 list = malloc(sizeof(struct tpc_list), M_CTL, M_WAITOK | M_ZERO);
1628 list->service_action = cdb->service_action;
1629 value = ctl_get_opt(&lun->be_lun->options, "insecure_tpc");
1630 if (value != NULL && strcmp(value, "on") == 0)
1631 list->init_port = -1;
1633 list->init_port = ctsio->io_hdr.nexus.targ_port;
1634 list->init_idx = ctl_get_resindex(&ctsio->io_hdr.nexus);
1635 list->list_id = data->list_identifier;
1636 list->flags = data->flags;
1637 list->params = ctsio->kern_data_ptr;
1638 list->cscd = (struct scsi_ec_cscd *)&data->data[0];
1639 ptr = &data->data[lencscd];
1640 for (nseg = 0, off = 0; off < lenseg; nseg++) {
1641 if (nseg >= TPC_MAX_SEGS) {
1643 ctl_set_sense(ctsio, /*current_error*/ 1,
1644 /*sense_key*/ SSD_KEY_ILLEGAL_REQUEST,
1645 /*asc*/ 0x26, /*ascq*/ 0x08, SSD_ELEM_NONE);
1648 list->seg[nseg] = (struct scsi_ec_segment *)(ptr + off);
1649 off += sizeof(struct scsi_ec_segment) +
1650 scsi_2btoul(list->seg[nseg]->descr_length);
1652 list->inl = &data->data[lencscd + lenseg];
1653 list->ncscd = lencscd / sizeof(struct scsi_ec_cscd);
1655 list->leninl = leninl;
1656 list->ctsio = ctsio;
1658 mtx_lock(&lun->lun_lock);
1659 if ((list->flags & EC_LIST_ID_USAGE_MASK) != EC_LIST_ID_USAGE_NONE) {
1660 tlist = tpc_find_list(lun, list->list_id, list->init_idx);
1661 if (tlist != NULL && !tlist->completed) {
1662 mtx_unlock(&lun->lun_lock);
1664 ctl_set_invalid_field(ctsio, /*sks_valid*/ 1,
1665 /*command*/ 0, /*field*/ 0, /*bit_valid*/ 0,
1669 if (tlist != NULL) {
1670 TAILQ_REMOVE(&lun->tpc_lists, tlist, links);
1674 TAILQ_INSERT_TAIL(&lun->tpc_lists, list, links);
1675 mtx_unlock(&lun->lun_lock);
1678 return (CTL_RETVAL_COMPLETE);
1681 ctl_done((union ctl_io *)ctsio);
1682 return (CTL_RETVAL_COMPLETE);
1686 ctl_extended_copy_lid4(struct ctl_scsiio *ctsio)
1688 struct scsi_extended_copy *cdb;
1689 struct scsi_extended_copy_lid4_data *data;
1690 struct ctl_lun *lun;
1691 struct tpc_list *list, *tlist;
1694 int len, off, lencscd, lenseg, leninl, nseg;
1696 CTL_DEBUG_PRINT(("ctl_extended_copy_lid4\n"));
1698 lun = (struct ctl_lun *)ctsio->io_hdr.ctl_private[CTL_PRIV_LUN].ptr;
1699 cdb = (struct scsi_extended_copy *)ctsio->cdb;
1700 len = scsi_4btoul(cdb->length);
1702 if (len < sizeof(struct scsi_extended_copy_lid4_data) ||
1703 len > sizeof(struct scsi_extended_copy_lid4_data) +
1704 TPC_MAX_LIST + TPC_MAX_INLINE) {
1705 ctl_set_invalid_field(ctsio, /*sks_valid*/ 1, /*command*/ 1,
1706 /*field*/ 9, /*bit_valid*/ 0, /*bit*/ 0);
1711 * If we've got a kernel request that hasn't been malloced yet,
1712 * malloc it and tell the caller the data buffer is here.
1714 if ((ctsio->io_hdr.flags & CTL_FLAG_ALLOCATED) == 0) {
1715 ctsio->kern_data_ptr = malloc(len, M_CTL, M_WAITOK);
1716 ctsio->kern_data_len = len;
1717 ctsio->kern_total_len = len;
1718 ctsio->kern_data_resid = 0;
1719 ctsio->kern_rel_offset = 0;
1720 ctsio->kern_sg_entries = 0;
1721 ctsio->io_hdr.flags |= CTL_FLAG_ALLOCATED;
1722 ctsio->be_move_done = ctl_config_move_done;
1723 ctl_datamove((union ctl_io *)ctsio);
1725 return (CTL_RETVAL_COMPLETE);
1728 data = (struct scsi_extended_copy_lid4_data *)ctsio->kern_data_ptr;
1729 lencscd = scsi_2btoul(data->cscd_list_length);
1730 lenseg = scsi_2btoul(data->segment_list_length);
1731 leninl = scsi_2btoul(data->inline_data_length);
1732 if (len < sizeof(struct scsi_extended_copy_lid4_data) +
1733 lencscd + lenseg + leninl ||
1734 leninl > TPC_MAX_INLINE) {
1735 ctl_set_invalid_field(ctsio, /*sks_valid*/ 1, /*command*/ 0,
1736 /*field*/ 2, /*bit_valid*/ 0, /*bit*/ 0);
1739 if (lencscd > TPC_MAX_CSCDS * sizeof(struct scsi_ec_cscd)) {
1740 ctl_set_sense(ctsio, /*current_error*/ 1,
1741 /*sense_key*/ SSD_KEY_ILLEGAL_REQUEST,
1742 /*asc*/ 0x26, /*ascq*/ 0x06, SSD_ELEM_NONE);
1745 if (lencscd + lenseg > TPC_MAX_LIST) {
1746 ctl_set_param_len_error(ctsio);
1750 list = malloc(sizeof(struct tpc_list), M_CTL, M_WAITOK | M_ZERO);
1751 list->service_action = cdb->service_action;
1752 value = ctl_get_opt(&lun->be_lun->options, "insecure_tpc");
1753 if (value != NULL && strcmp(value, "on") == 0)
1754 list->init_port = -1;
1756 list->init_port = ctsio->io_hdr.nexus.targ_port;
1757 list->init_idx = ctl_get_resindex(&ctsio->io_hdr.nexus);
1758 list->list_id = scsi_4btoul(data->list_identifier);
1759 list->flags = data->flags;
1760 list->params = ctsio->kern_data_ptr;
1761 list->cscd = (struct scsi_ec_cscd *)&data->data[0];
1762 ptr = &data->data[lencscd];
1763 for (nseg = 0, off = 0; off < lenseg; nseg++) {
1764 if (nseg >= TPC_MAX_SEGS) {
1766 ctl_set_sense(ctsio, /*current_error*/ 1,
1767 /*sense_key*/ SSD_KEY_ILLEGAL_REQUEST,
1768 /*asc*/ 0x26, /*ascq*/ 0x08, SSD_ELEM_NONE);
1771 list->seg[nseg] = (struct scsi_ec_segment *)(ptr + off);
1772 off += sizeof(struct scsi_ec_segment) +
1773 scsi_2btoul(list->seg[nseg]->descr_length);
1775 list->inl = &data->data[lencscd + lenseg];
1776 list->ncscd = lencscd / sizeof(struct scsi_ec_cscd);
1778 list->leninl = leninl;
1779 list->ctsio = ctsio;
1781 mtx_lock(&lun->lun_lock);
1782 if ((list->flags & EC_LIST_ID_USAGE_MASK) != EC_LIST_ID_USAGE_NONE) {
1783 tlist = tpc_find_list(lun, list->list_id, list->init_idx);
1784 if (tlist != NULL && !tlist->completed) {
1785 mtx_unlock(&lun->lun_lock);
1787 ctl_set_invalid_field(ctsio, /*sks_valid*/ 1,
1788 /*command*/ 0, /*field*/ 0, /*bit_valid*/ 0,
1792 if (tlist != NULL) {
1793 TAILQ_REMOVE(&lun->tpc_lists, tlist, links);
1797 TAILQ_INSERT_TAIL(&lun->tpc_lists, list, links);
1798 mtx_unlock(&lun->lun_lock);
1801 return (CTL_RETVAL_COMPLETE);
1804 ctl_done((union ctl_io *)ctsio);
1805 return (CTL_RETVAL_COMPLETE);
1809 tpc_create_token(struct ctl_lun *lun, struct ctl_port *port, off_t len,
1810 struct scsi_token *token)
1813 struct scsi_vpd_id_descriptor *idd = NULL;
1814 struct scsi_ec_cscd_id *cscd;
1817 scsi_ulto4b(ROD_TYPE_AUR, token->type);
1818 scsi_ulto2b(0x01f8, token->length);
1819 scsi_u64to8b(atomic_fetchadd_int(&id, 1), &token->body[0]);
1821 idd = scsi_get_devid_desc((struct scsi_vpd_id_descriptor *)
1822 lun->lun_devid->data, lun->lun_devid->len,
1823 scsi_devid_is_lun_naa);
1824 if (idd == NULL && lun->lun_devid)
1825 idd = scsi_get_devid_desc((struct scsi_vpd_id_descriptor *)
1826 lun->lun_devid->data, lun->lun_devid->len,
1827 scsi_devid_is_lun_eui64);
1829 cscd = (struct scsi_ec_cscd_id *)&token->body[8];
1830 cscd->type_code = EC_CSCD_ID;
1831 cscd->luidt_pdt = T_DIRECT;
1832 memcpy(&cscd->codeset, idd, 4 + idd->length);
1834 scsi_u64to8b(0, &token->body[40]);
1835 scsi_u64to8b(len, &token->body[48]);
1836 if (port->target_devid) {
1837 targid_len = port->target_devid->len;
1838 memcpy(&token->body[120], port->target_devid->data, targid_len);
1841 arc4rand(&token->body[120 + targid_len], 384 - targid_len, 0);
1845 ctl_populate_token(struct ctl_scsiio *ctsio)
1847 struct scsi_populate_token *cdb;
1848 struct scsi_populate_token_data *data;
1849 struct ctl_lun *lun;
1850 struct ctl_port *port;
1851 struct tpc_list *list, *tlist;
1852 struct tpc_token *token;
1855 CTL_DEBUG_PRINT(("ctl_populate_token\n"));
1857 lun = (struct ctl_lun *)ctsio->io_hdr.ctl_private[CTL_PRIV_LUN].ptr;
1858 port = control_softc->ctl_ports[ctl_port_idx(ctsio->io_hdr.nexus.targ_port)];
1859 cdb = (struct scsi_populate_token *)ctsio->cdb;
1860 len = scsi_4btoul(cdb->length);
1862 if (len < sizeof(struct scsi_populate_token_data) ||
1863 len > sizeof(struct scsi_populate_token_data) +
1864 TPC_MAX_SEGS * sizeof(struct scsi_range_desc)) {
1865 ctl_set_invalid_field(ctsio, /*sks_valid*/ 1, /*command*/ 1,
1866 /*field*/ 9, /*bit_valid*/ 0, /*bit*/ 0);
1871 * If we've got a kernel request that hasn't been malloced yet,
1872 * malloc it and tell the caller the data buffer is here.
1874 if ((ctsio->io_hdr.flags & CTL_FLAG_ALLOCATED) == 0) {
1875 ctsio->kern_data_ptr = malloc(len, M_CTL, M_WAITOK);
1876 ctsio->kern_data_len = len;
1877 ctsio->kern_total_len = len;
1878 ctsio->kern_data_resid = 0;
1879 ctsio->kern_rel_offset = 0;
1880 ctsio->kern_sg_entries = 0;
1881 ctsio->io_hdr.flags |= CTL_FLAG_ALLOCATED;
1882 ctsio->be_move_done = ctl_config_move_done;
1883 ctl_datamove((union ctl_io *)ctsio);
1885 return (CTL_RETVAL_COMPLETE);
1888 data = (struct scsi_populate_token_data *)ctsio->kern_data_ptr;
1889 lendesc = scsi_2btoul(data->range_descriptor_length);
1890 if (len < sizeof(struct scsi_populate_token_data) + lendesc) {
1891 ctl_set_invalid_field(ctsio, /*sks_valid*/ 1, /*command*/ 0,
1892 /*field*/ 2, /*bit_valid*/ 0, /*bit*/ 0);
1896 printf("PT(list=%u) flags=%x to=%d rt=%x len=%x\n",
1897 scsi_4btoul(cdb->list_identifier),
1898 data->flags, scsi_4btoul(data->inactivity_timeout),
1899 scsi_4btoul(data->rod_type),
1900 scsi_2btoul(data->range_descriptor_length));
1902 if ((data->flags & EC_PT_RTV) &&
1903 scsi_4btoul(data->rod_type) != ROD_TYPE_AUR) {
1904 ctl_set_invalid_field(ctsio, /*sks_valid*/ 1, /*command*/ 0,
1905 /*field*/ 8, /*bit_valid*/ 0, /*bit*/ 0);
1909 list = malloc(sizeof(struct tpc_list), M_CTL, M_WAITOK | M_ZERO);
1910 list->service_action = cdb->service_action;
1911 list->init_port = ctsio->io_hdr.nexus.targ_port;
1912 list->init_idx = ctl_get_resindex(&ctsio->io_hdr.nexus);
1913 list->list_id = scsi_4btoul(cdb->list_identifier);
1914 list->flags = data->flags;
1915 list->ctsio = ctsio;
1917 mtx_lock(&lun->lun_lock);
1918 tlist = tpc_find_list(lun, list->list_id, list->init_idx);
1919 if (tlist != NULL && !tlist->completed) {
1920 mtx_unlock(&lun->lun_lock);
1922 ctl_set_invalid_field(ctsio, /*sks_valid*/ 1,
1923 /*command*/ 0, /*field*/ 0, /*bit_valid*/ 0,
1927 if (tlist != NULL) {
1928 TAILQ_REMOVE(&lun->tpc_lists, tlist, links);
1931 TAILQ_INSERT_TAIL(&lun->tpc_lists, list, links);
1932 mtx_unlock(&lun->lun_lock);
1934 token = malloc(sizeof(*token), M_CTL, M_WAITOK | M_ZERO);
1935 token->lun = lun->lun;
1936 token->blocksize = lun->be_lun->blocksize;
1937 token->params = ctsio->kern_data_ptr;
1938 token->range = &data->desc[0];
1939 token->nrange = scsi_2btoul(data->range_descriptor_length) /
1940 sizeof(struct scsi_range_desc);
1941 tpc_create_token(lun, port, list->curbytes,
1942 (struct scsi_token *)token->token);
1944 token->last_active = time_uptime;
1945 token->timeout = scsi_4btoul(data->inactivity_timeout);
1946 if (token->timeout == 0)
1947 token->timeout = TPC_DFL_TOKEN_TIMEOUT;
1948 else if (token->timeout < TPC_MIN_TOKEN_TIMEOUT)
1949 token->timeout = TPC_MIN_TOKEN_TIMEOUT;
1950 else if (token->timeout > TPC_MAX_TOKEN_TIMEOUT) {
1951 ctl_set_invalid_field(ctsio, /*sks_valid*/ 1,
1952 /*command*/ 0, /*field*/ 4, /*bit_valid*/ 0,
1955 memcpy(list->res_token, token->token, sizeof(list->res_token));
1956 list->res_token_valid = 1;
1957 list->cursectors = tpc_ranges_length(token->range, token->nrange);
1958 list->curbytes = (off_t)list->cursectors * lun->be_lun->blocksize;
1960 list->completed = 1;
1961 list->last_active = time_uptime;
1962 mtx_lock(&control_softc->ctl_lock);
1963 TAILQ_INSERT_TAIL(&control_softc->tpc_tokens, token, links);
1964 mtx_unlock(&control_softc->ctl_lock);
1965 ctl_set_success(ctsio);
1966 ctl_done((union ctl_io *)ctsio);
1967 return (CTL_RETVAL_COMPLETE);
1970 if (ctsio->io_hdr.flags & CTL_FLAG_ALLOCATED)
1971 free(ctsio->kern_data_ptr, M_CTL);
1972 ctl_done((union ctl_io *)ctsio);
1973 return (CTL_RETVAL_COMPLETE);
1977 ctl_write_using_token(struct ctl_scsiio *ctsio)
1979 struct scsi_write_using_token *cdb;
1980 struct scsi_write_using_token_data *data;
1981 struct ctl_lun *lun;
1982 struct tpc_list *list, *tlist;
1983 struct tpc_token *token;
1986 CTL_DEBUG_PRINT(("ctl_write_using_token\n"));
1988 lun = (struct ctl_lun *)ctsio->io_hdr.ctl_private[CTL_PRIV_LUN].ptr;
1989 cdb = (struct scsi_write_using_token *)ctsio->cdb;
1990 len = scsi_4btoul(cdb->length);
1992 if (len < sizeof(struct scsi_populate_token_data) ||
1993 len > sizeof(struct scsi_populate_token_data) +
1994 TPC_MAX_SEGS * sizeof(struct scsi_range_desc)) {
1995 ctl_set_invalid_field(ctsio, /*sks_valid*/ 1, /*command*/ 1,
1996 /*field*/ 9, /*bit_valid*/ 0, /*bit*/ 0);
2001 * If we've got a kernel request that hasn't been malloced yet,
2002 * malloc it and tell the caller the data buffer is here.
2004 if ((ctsio->io_hdr.flags & CTL_FLAG_ALLOCATED) == 0) {
2005 ctsio->kern_data_ptr = malloc(len, M_CTL, M_WAITOK);
2006 ctsio->kern_data_len = len;
2007 ctsio->kern_total_len = len;
2008 ctsio->kern_data_resid = 0;
2009 ctsio->kern_rel_offset = 0;
2010 ctsio->kern_sg_entries = 0;
2011 ctsio->io_hdr.flags |= CTL_FLAG_ALLOCATED;
2012 ctsio->be_move_done = ctl_config_move_done;
2013 ctl_datamove((union ctl_io *)ctsio);
2015 return (CTL_RETVAL_COMPLETE);
2018 data = (struct scsi_write_using_token_data *)ctsio->kern_data_ptr;
2019 lendesc = scsi_2btoul(data->range_descriptor_length);
2020 if (len < sizeof(struct scsi_populate_token_data) + lendesc) {
2021 ctl_set_invalid_field(ctsio, /*sks_valid*/ 1, /*command*/ 0,
2022 /*field*/ 2, /*bit_valid*/ 0, /*bit*/ 0);
2026 printf("WUT(list=%u) flags=%x off=%ju len=%x\n",
2027 scsi_4btoul(cdb->list_identifier),
2028 data->flags, scsi_8btou64(data->offset_into_rod),
2029 scsi_2btoul(data->range_descriptor_length));
2031 list = malloc(sizeof(struct tpc_list), M_CTL, M_WAITOK | M_ZERO);
2032 list->service_action = cdb->service_action;
2033 list->init_port = ctsio->io_hdr.nexus.targ_port;
2034 list->init_idx = ctl_get_resindex(&ctsio->io_hdr.nexus);
2035 list->list_id = scsi_4btoul(cdb->list_identifier);
2036 list->flags = data->flags;
2037 list->params = ctsio->kern_data_ptr;
2038 list->range = &data->desc[0];
2039 list->nrange = scsi_2btoul(data->range_descriptor_length) /
2040 sizeof(struct scsi_range_desc);
2041 list->offset_into_rod = scsi_8btou64(data->offset_into_rod);
2042 list->ctsio = ctsio;
2044 mtx_lock(&lun->lun_lock);
2045 tlist = tpc_find_list(lun, list->list_id, list->init_idx);
2046 if (tlist != NULL && !tlist->completed) {
2047 mtx_unlock(&lun->lun_lock);
2049 ctl_set_invalid_field(ctsio, /*sks_valid*/ 1,
2050 /*command*/ 0, /*field*/ 0, /*bit_valid*/ 0,
2054 if (tlist != NULL) {
2055 TAILQ_REMOVE(&lun->tpc_lists, tlist, links);
2058 TAILQ_INSERT_TAIL(&lun->tpc_lists, list, links);
2059 mtx_unlock(&lun->lun_lock);
2061 /* Block device zero ROD token -> no token. */
2062 if (scsi_4btoul(data->rod_token) == ROD_TYPE_BLOCK_ZERO) {
2064 return (CTL_RETVAL_COMPLETE);
2067 mtx_lock(&control_softc->ctl_lock);
2068 TAILQ_FOREACH(token, &control_softc->tpc_tokens, links) {
2069 if (memcmp(token->token, data->rod_token,
2070 sizeof(data->rod_token)) == 0)
2073 if (token != NULL) {
2075 list->token = token;
2076 if (data->flags & EC_WUT_DEL_TKN)
2079 mtx_unlock(&control_softc->ctl_lock);
2080 if (token == NULL) {
2081 mtx_lock(&lun->lun_lock);
2082 TAILQ_REMOVE(&lun->tpc_lists, list, links);
2083 mtx_unlock(&lun->lun_lock);
2085 ctl_set_sense(ctsio, /*current_error*/ 1,
2086 /*sense_key*/ SSD_KEY_ILLEGAL_REQUEST,
2087 /*asc*/ 0x23, /*ascq*/ 0x04, SSD_ELEM_NONE);
2092 return (CTL_RETVAL_COMPLETE);
2095 if (ctsio->io_hdr.flags & CTL_FLAG_ALLOCATED)
2096 free(ctsio->kern_data_ptr, M_CTL);
2097 ctl_done((union ctl_io *)ctsio);
2098 return (CTL_RETVAL_COMPLETE);
2102 ctl_receive_rod_token_information(struct ctl_scsiio *ctsio)
2104 struct ctl_lun *lun;
2105 struct scsi_receive_rod_token_information *cdb;
2106 struct scsi_receive_copy_status_lid4_data *data;
2107 struct tpc_list *list;
2108 struct tpc_list list_copy;
2111 int alloc_len, total_len, token_len;
2114 CTL_DEBUG_PRINT(("ctl_receive_rod_token_information\n"));
2116 cdb = (struct scsi_receive_rod_token_information *)ctsio->cdb;
2117 lun = (struct ctl_lun *)ctsio->io_hdr.ctl_private[CTL_PRIV_LUN].ptr;
2119 retval = CTL_RETVAL_COMPLETE;
2121 list_id = scsi_4btoul(cdb->list_identifier);
2122 mtx_lock(&lun->lun_lock);
2123 list = tpc_find_list(lun, list_id,
2124 ctl_get_resindex(&ctsio->io_hdr.nexus));
2126 mtx_unlock(&lun->lun_lock);
2127 ctl_set_invalid_field(ctsio, /*sks_valid*/ 1,
2128 /*command*/ 1, /*field*/ 2, /*bit_valid*/ 0,
2130 ctl_done((union ctl_io *)ctsio);
2134 if (list->completed) {
2135 TAILQ_REMOVE(&lun->tpc_lists, list, links);
2138 mtx_unlock(&lun->lun_lock);
2140 token_len = list_copy.res_token_valid ? 2 + sizeof(list_copy.res_token) : 0;
2141 total_len = sizeof(*data) + list_copy.sense_len + 4 + token_len;
2142 alloc_len = scsi_4btoul(cdb->length);
2144 ctsio->kern_data_ptr = malloc(total_len, M_CTL, M_WAITOK | M_ZERO);
2146 ctsio->kern_sg_entries = 0;
2148 if (total_len < alloc_len) {
2149 ctsio->residual = alloc_len - total_len;
2150 ctsio->kern_data_len = total_len;
2151 ctsio->kern_total_len = total_len;
2153 ctsio->residual = 0;
2154 ctsio->kern_data_len = alloc_len;
2155 ctsio->kern_total_len = alloc_len;
2157 ctsio->kern_data_resid = 0;
2158 ctsio->kern_rel_offset = 0;
2160 data = (struct scsi_receive_copy_status_lid4_data *)ctsio->kern_data_ptr;
2161 scsi_ulto4b(sizeof(*data) - 4 + list_copy.sense_len +
2162 4 + token_len, data->available_data);
2163 data->response_to_service_action = list_copy.service_action;
2164 if (list_copy.completed) {
2165 if (list_copy.error)
2166 data->copy_command_status = RCS_CCS_ERROR;
2167 else if (list_copy.abort)
2168 data->copy_command_status = RCS_CCS_ABORTED;
2170 data->copy_command_status = RCS_CCS_COMPLETED;
2172 data->copy_command_status = RCS_CCS_INPROG_FG;
2173 scsi_ulto2b(list_copy.curops, data->operation_counter);
2174 scsi_ulto4b(UINT32_MAX, data->estimated_status_update_delay);
2175 data->transfer_count_units = RCS_TC_LBAS;
2176 scsi_u64to8b(list_copy.cursectors, data->transfer_count);
2177 scsi_ulto2b(list_copy.curseg, data->segments_processed);
2178 data->length_of_the_sense_data_field = list_copy.sense_len;
2179 data->sense_data_length = list_copy.sense_len;
2180 memcpy(data->sense_data, &list_copy.sense_data, list_copy.sense_len);
2182 ptr = &data->sense_data[data->length_of_the_sense_data_field];
2183 scsi_ulto4b(token_len, &ptr[0]);
2184 if (list_copy.res_token_valid) {
2185 scsi_ulto2b(0, &ptr[4]);
2186 memcpy(&ptr[6], list_copy.res_token, sizeof(list_copy.res_token));
2189 printf("RRTI(list=%u) valid=%d\n",
2190 scsi_4btoul(cdb->list_identifier), list_copy.res_token_valid);
2192 ctsio->io_hdr.flags |= CTL_FLAG_ALLOCATED;
2193 ctsio->be_move_done = ctl_config_move_done;
2195 ctl_datamove((union ctl_io *)ctsio);
2200 ctl_report_all_rod_tokens(struct ctl_scsiio *ctsio)
2202 struct ctl_lun *lun;
2203 struct scsi_report_all_rod_tokens *cdb;
2204 struct scsi_report_all_rod_tokens_data *data;
2205 struct tpc_token *token;
2207 int alloc_len, total_len, tokens, i;
2209 CTL_DEBUG_PRINT(("ctl_receive_rod_token_information\n"));
2211 cdb = (struct scsi_report_all_rod_tokens *)ctsio->cdb;
2212 lun = (struct ctl_lun *)ctsio->io_hdr.ctl_private[CTL_PRIV_LUN].ptr;
2214 retval = CTL_RETVAL_COMPLETE;
2217 mtx_lock(&control_softc->ctl_lock);
2218 TAILQ_FOREACH(token, &control_softc->tpc_tokens, links)
2220 mtx_unlock(&control_softc->ctl_lock);
2224 total_len = sizeof(*data) + tokens * 96;
2225 alloc_len = scsi_4btoul(cdb->length);
2227 ctsio->kern_data_ptr = malloc(total_len, M_CTL, M_WAITOK | M_ZERO);
2229 ctsio->kern_sg_entries = 0;
2231 if (total_len < alloc_len) {
2232 ctsio->residual = alloc_len - total_len;
2233 ctsio->kern_data_len = total_len;
2234 ctsio->kern_total_len = total_len;
2236 ctsio->residual = 0;
2237 ctsio->kern_data_len = alloc_len;
2238 ctsio->kern_total_len = alloc_len;
2240 ctsio->kern_data_resid = 0;
2241 ctsio->kern_rel_offset = 0;
2243 data = (struct scsi_report_all_rod_tokens_data *)ctsio->kern_data_ptr;
2245 mtx_lock(&control_softc->ctl_lock);
2246 TAILQ_FOREACH(token, &control_softc->tpc_tokens, links) {
2249 memcpy(&data->rod_management_token_list[i * 96],
2253 mtx_unlock(&control_softc->ctl_lock);
2254 scsi_ulto4b(sizeof(*data) - 4 + i * 96, data->available_data);
2256 printf("RART tokens=%d\n", i);
2258 ctsio->io_hdr.flags |= CTL_FLAG_ALLOCATED;
2259 ctsio->be_move_done = ctl_config_move_done;
2261 ctl_datamove((union ctl_io *)ctsio);