xref: /freebsd/sbin/camcontrol/zone.c (revision a0b9e2e854027e6ff61fb075a1309dbc71c42b54)
1 /*-
2  * Copyright (c) 2015, 2016 Spectra Logic Corporation
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions, and the following disclaimer,
10  *    without modification.
11  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
12  *    substantially similar to the "NO WARRANTY" disclaimer below
13  *    ("Disclaimer") and any redistribution must be conditioned upon
14  *    including a substantially similar Disclaimer requirement for further
15  *    binary redistribution.
16  *
17  * NO WARRANTY
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
26  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
27  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
28  * POSSIBILITY OF SUCH DAMAGES.
29  *
30  * Authors: Ken Merry           (Spectra Logic Corporation)
31  */
32 /*
33  * SCSI and ATA Shingled Media Recording (SMR) support for camcontrol(8).
34  * This is an implementation of the SCSI ZBC and ATA ZAC specs.
35  */
36 
37 #include <sys/cdefs.h>
38 __FBSDID("$FreeBSD$");
39 
40 #include <sys/ioctl.h>
41 #include <sys/stdint.h>
42 #include <sys/types.h>
43 #include <sys/endian.h>
44 #include <sys/sbuf.h>
45 #include <sys/queue.h>
46 #include <sys/chio.h>
47 
48 #include <stdio.h>
49 #include <stdlib.h>
50 #include <inttypes.h>
51 #include <unistd.h>
52 #include <string.h>
53 #include <strings.h>
54 #include <fcntl.h>
55 #include <ctype.h>
56 #include <limits.h>
57 #include <err.h>
58 #include <locale.h>
59 
60 #include <cam/cam.h>
61 #include <cam/cam_debug.h>
62 #include <cam/cam_ccb.h>
63 #include <cam/scsi/scsi_all.h>
64 #include <cam/scsi/scsi_da.h>
65 #include <cam/scsi/scsi_pass.h>
66 #include <cam/scsi/scsi_ch.h>
67 #include <cam/scsi/scsi_message.h>
68 #include <camlib.h>
69 #include "camcontrol.h"
70 
71 static struct scsi_nv zone_cmd_map[] = {
72 	{ "rz", ZBC_IN_SA_REPORT_ZONES },
73 	{ "reportzones", ZBC_IN_SA_REPORT_ZONES },
74 	{ "close", ZBC_OUT_SA_CLOSE },
75 	{ "finish", ZBC_OUT_SA_FINISH },
76 	{ "open", ZBC_OUT_SA_OPEN },
77 	{ "rwp", ZBC_OUT_SA_RWP }
78 };
79 
80 static struct scsi_nv zone_rep_opts[] = {
81 	{ "all", ZBC_IN_REP_ALL_ZONES },
82 	{ "empty", ZBC_IN_REP_EMPTY },
83 	{ "imp_open", ZBC_IN_REP_IMP_OPEN },
84 	{ "exp_open", ZBC_IN_REP_EXP_OPEN },
85 	{ "closed", ZBC_IN_REP_CLOSED },
86 	{ "full", ZBC_IN_REP_FULL },
87 	{ "readonly", ZBC_IN_REP_READONLY },
88 	{ "ro", ZBC_IN_REP_READONLY },
89 	{ "offline", ZBC_IN_REP_OFFLINE },
90 	{ "rwp", ZBC_IN_REP_RESET },
91 	{ "reset", ZBC_IN_REP_RESET },
92 	{ "nonseq", ZBC_IN_REP_NON_SEQ },
93 	{ "nonwp", ZBC_IN_REP_NON_WP }
94 };
95 
96 typedef enum {
97 	ZONE_OF_NORMAL	= 0x00,
98 	ZONE_OF_SUMMARY	= 0x01,
99 	ZONE_OF_SCRIPT	= 0x02
100 } zone_output_flags;
101 
102 static struct scsi_nv zone_print_opts[] = {
103 	{ "normal", ZONE_OF_NORMAL },
104 	{ "summary", ZONE_OF_SUMMARY },
105 	{ "script", ZONE_OF_SCRIPT }
106 };
107 
108 #define	ZAC_ATA_SECTOR_COUNT(bcount)	(((bcount) / 512) & 0xffff)
109 
110 typedef enum {
111 	ZONE_PRINT_OK,
112 	ZONE_PRINT_MORE_DATA,
113 	ZONE_PRINT_ERROR
114 } zone_print_status;
115 
116 typedef enum {
117 	ZONE_FW_START,
118 	ZONE_FW_LEN,
119 	ZONE_FW_WP,
120 	ZONE_FW_TYPE,
121 	ZONE_FW_COND,
122 	ZONE_FW_SEQ,
123 	ZONE_FW_RESET,
124 	ZONE_NUM_FIELDS
125 } zone_field_widths;
126 
127 zone_print_status zone_rz_print(uint8_t *data_ptr, uint32_t valid_len,
128 				int ata_format, zone_output_flags out_flags,
129 				int first_pass, uint64_t *next_start_lba);
130 
131 
132 zone_print_status
133 zone_rz_print(uint8_t *data_ptr, uint32_t valid_len, int ata_format,
134 	      zone_output_flags out_flags, int first_pass,
135 	      uint64_t *next_start_lba)
136 {
137 	struct scsi_report_zones_hdr *hdr = NULL;
138 	struct scsi_report_zones_desc *desc = NULL;
139 	uint32_t hdr_len, len;
140 	uint64_t max_lba, next_lba = 0;
141 	int more_data = 0;
142 	zone_print_status status = ZONE_PRINT_OK;
143 	char tmpstr[80];
144 	int field_widths[ZONE_NUM_FIELDS];
145 	char word_sep;
146 
147 	if (valid_len < sizeof(*hdr)) {
148 		status = ZONE_PRINT_ERROR;
149 		goto bailout;
150 	}
151 
152 	hdr = (struct scsi_report_zones_hdr *)data_ptr;
153 
154 	field_widths[ZONE_FW_START] = 11;
155 	field_widths[ZONE_FW_LEN] = 6;
156 	field_widths[ZONE_FW_WP] = 11;
157 	field_widths[ZONE_FW_TYPE] = 13;
158 	field_widths[ZONE_FW_COND] = 13;
159 	field_widths[ZONE_FW_SEQ] = 14;
160 	field_widths[ZONE_FW_RESET] = 16;
161 
162 	if (ata_format == 0) {
163 		hdr_len = scsi_4btoul(hdr->length);
164 		max_lba = scsi_8btou64(hdr->maximum_lba);
165 	} else {
166 		hdr_len = le32dec(hdr->length);
167 		max_lba = le64dec(hdr->maximum_lba);
168 	}
169 
170 	if (hdr_len > (valid_len + sizeof(*hdr))) {
171 		more_data = 1;
172 		status = ZONE_PRINT_MORE_DATA;
173 	}
174 
175 	len = MIN(valid_len - sizeof(*hdr), hdr_len);
176 
177 	if (out_flags == ZONE_OF_SCRIPT)
178 		word_sep = '_';
179 	else
180 		word_sep = ' ';
181 
182 	if ((out_flags != ZONE_OF_SCRIPT)
183 	 && (first_pass != 0)) {
184 		printf("%zu zones, Maximum LBA %#jx (%ju)\n",
185 		    hdr_len / sizeof(*desc), (uintmax_t)max_lba,
186 		    (uintmax_t)max_lba);
187 
188 		switch (hdr->byte4 & SRZ_SAME_MASK) {
189 		case SRZ_SAME_ALL_DIFFERENT:
190 			printf("Zone lengths and types may vary\n");
191 			break;
192 		case SRZ_SAME_ALL_SAME:
193 			printf("Zone lengths and types are all the same\n");
194 			break;
195 		case SRZ_SAME_LAST_DIFFERENT:
196 			printf("Zone types are the same, last zone length "
197 			    "differs\n");
198 			break;
199 		case SRZ_SAME_TYPES_DIFFERENT:
200 			printf("Zone lengths are the same, types vary\n");
201 			break;
202 		default:
203 			printf("Unknown SAME field value %#x\n",
204 			    hdr->byte4 & SRZ_SAME_MASK);
205 			break;
206 		}
207 	}
208 	if (out_flags == ZONE_OF_SUMMARY) {
209 		status = ZONE_PRINT_OK;
210 		goto bailout;
211 	}
212 
213 	if ((out_flags == ZONE_OF_NORMAL)
214 	 && (first_pass != 0)) {
215 		printf("%*s  %*s  %*s  %*s  %*s  %*s  %*s\n",
216 		    field_widths[ZONE_FW_START], "Start LBA",
217 		    field_widths[ZONE_FW_LEN], "Length",
218 		    field_widths[ZONE_FW_WP], "WP LBA",
219 		    field_widths[ZONE_FW_TYPE], "Zone Type",
220 		    field_widths[ZONE_FW_COND], "Condition",
221 		    field_widths[ZONE_FW_SEQ], "Sequential",
222 		    field_widths[ZONE_FW_RESET], "Reset");
223 	}
224 
225 	for (desc = &hdr->desc_list[0]; len >= sizeof(*desc);
226 	     len -= sizeof(*desc), desc++) {
227 		uint64_t length, start_lba, wp_lba;
228 
229 		if (ata_format == 0) {
230 			length = scsi_8btou64(desc->zone_length);
231 			start_lba = scsi_8btou64(desc->zone_start_lba);
232 			wp_lba = scsi_8btou64(desc->write_pointer_lba);
233 		} else {
234 			length = le64dec(desc->zone_length);
235 			start_lba = le64dec(desc->zone_start_lba);
236 			wp_lba = le64dec(desc->write_pointer_lba);
237 		}
238 
239 		printf("%#*jx, %*ju, %#*jx, ", field_widths[ZONE_FW_START],
240 		    (uintmax_t)start_lba, field_widths[ZONE_FW_LEN],
241 		    (uintmax_t)length, field_widths[ZONE_FW_WP],
242 		    (uintmax_t)wp_lba);
243 
244 		switch (desc->zone_type & SRZ_TYPE_MASK) {
245 		case SRZ_TYPE_CONVENTIONAL:
246 			snprintf(tmpstr, sizeof(tmpstr), "Conventional");
247 			break;
248 		case SRZ_TYPE_SEQ_PREFERRED:
249 		case SRZ_TYPE_SEQ_REQUIRED:
250 			snprintf(tmpstr, sizeof(tmpstr), "Seq%c%s",
251 			    word_sep, ((desc->zone_type & SRZ_TYPE_MASK) ==
252 			    SRZ_TYPE_SEQ_PREFERRED) ? "Preferred" :
253 			    "Required");
254 			break;
255 		default:
256 			snprintf(tmpstr, sizeof(tmpstr), "Zone%ctype%c%#x",
257 			    word_sep, word_sep,desc->zone_type &
258 			    SRZ_TYPE_MASK);
259 			break;
260 		}
261 		printf("%*s, ", field_widths[ZONE_FW_TYPE], tmpstr);
262 
263 		switch (desc->zone_flags & SRZ_ZONE_COND_MASK) {
264 		case SRZ_ZONE_COND_NWP:
265 			snprintf(tmpstr, sizeof(tmpstr), "NWP");
266 			break;
267 		case SRZ_ZONE_COND_EMPTY:
268 			snprintf(tmpstr, sizeof(tmpstr), "Empty");
269 			break;
270 		case SRZ_ZONE_COND_IMP_OPEN:
271 			snprintf(tmpstr, sizeof(tmpstr), "Implicit%cOpen",
272 			    word_sep);
273 			break;
274 		case SRZ_ZONE_COND_EXP_OPEN:
275 			snprintf(tmpstr, sizeof(tmpstr), "Explicit%cOpen",
276 			    word_sep);
277 			break;
278 		case SRZ_ZONE_COND_CLOSED:
279 			snprintf(tmpstr, sizeof(tmpstr), "Closed");
280 			break;
281 		case SRZ_ZONE_COND_READONLY:
282 			snprintf(tmpstr, sizeof(tmpstr), "Readonly");
283 			break;
284 		case SRZ_ZONE_COND_FULL:
285 			snprintf(tmpstr, sizeof(tmpstr), "Full");
286 			break;
287 		case SRZ_ZONE_COND_OFFLINE:
288 			snprintf(tmpstr, sizeof(tmpstr), "Offline");
289 			break;
290 		default:
291 			snprintf(tmpstr, sizeof(tmpstr), "%#x",
292 			    desc->zone_flags & SRZ_ZONE_COND_MASK);
293 			break;
294 		}
295 
296 		printf("%*s, ", field_widths[ZONE_FW_COND], tmpstr);
297 
298 		if (desc->zone_flags & SRZ_ZONE_NON_SEQ)
299 			snprintf(tmpstr, sizeof(tmpstr), "Non%cSequential",
300 			    word_sep);
301 		else
302 			snprintf(tmpstr, sizeof(tmpstr), "Sequential");
303 
304 		printf("%*s, ", field_widths[ZONE_FW_SEQ], tmpstr);
305 
306 		if (desc->zone_flags & SRZ_ZONE_RESET)
307 			snprintf(tmpstr, sizeof(tmpstr), "Reset%cNeeded",
308 			    word_sep);
309 		else
310 			snprintf(tmpstr, sizeof(tmpstr), "No%cReset%cNeeded",
311 			    word_sep, word_sep);
312 
313 		printf("%*s\n", field_widths[ZONE_FW_RESET], tmpstr);
314 
315 		next_lba = start_lba + length;
316 	}
317 bailout:
318 	*next_start_lba = next_lba;
319 
320 	return (status);
321 }
322 
323 int
324 zone(struct cam_device *device, int argc, char **argv, char *combinedopt,
325      int task_attr, int retry_count, int timeout, int verbosemode __unused)
326 {
327 	union ccb *ccb = NULL;
328 	int action = -1, rep_option = -1;
329 	int all_zones = 0;
330 	uint64_t lba = 0;
331 	int error = 0;
332 	uint8_t *data_ptr = NULL;
333 	uint32_t alloc_len = 65536, valid_len = 0;
334 	camcontrol_devtype devtype;
335 	int ata_format = 0, use_ncq = 0;
336 	int first_pass = 1;
337 	zone_print_status zp_status;
338 	zone_output_flags out_flags = ZONE_OF_NORMAL;
339 	uint8_t *cdb_storage = NULL;
340 	int cdb_storage_len = 32;
341 	int c;
342 
343 	ccb = cam_getccb(device);
344 	if (ccb == NULL) {
345 		warnx("%s: error allocating CCB", __func__);
346 		error = 1;
347 		goto bailout;
348 	}
349 
350 	CCB_CLEAR_ALL_EXCEPT_HDR(ccb);
351 
352 	while ((c = getopt(argc, argv, combinedopt)) != -1) {
353 		switch (c) {
354 		case 'a':
355 			all_zones = 1;
356 			break;
357 		case 'c': {
358 			scsi_nv_status status;
359 			int entry_num;
360 
361 			status = scsi_get_nv(zone_cmd_map,
362 			    (sizeof(zone_cmd_map) / sizeof(zone_cmd_map[0])),
363 			    optarg, &entry_num, SCSI_NV_FLAG_IG_CASE);
364 			if (status == SCSI_NV_FOUND)
365 				action = zone_cmd_map[entry_num].value;
366 			else {
367 				warnx("%s: %s: %s option %s", __func__,
368 				    (status == SCSI_NV_AMBIGUOUS) ?
369 				    "ambiguous" : "invalid", "zone command",
370 				    optarg);
371 				error = 1;
372 				goto bailout;
373 			}
374 			break;
375 		}
376 		case 'l': {
377 			char *endptr;
378 
379 			lba = strtoull(optarg, &endptr, 0);
380 			if (*endptr != '\0') {
381 				warnx("%s: invalid lba argument %s", __func__,
382 				    optarg);
383 				error = 1;
384 				goto bailout;
385 			}
386 			break;
387 		}
388 		case 'N':
389 			use_ncq = 1;
390 			break;
391 		case 'o': {
392 			scsi_nv_status status;
393 			int entry_num;
394 
395 			status = scsi_get_nv(zone_rep_opts,
396 			    (sizeof(zone_rep_opts) /sizeof(zone_rep_opts[0])),
397 			    optarg, &entry_num, SCSI_NV_FLAG_IG_CASE);
398 			if (status == SCSI_NV_FOUND)
399 				rep_option = zone_rep_opts[entry_num].value;
400 			else {
401 				warnx("%s: %s: %s option %s", __func__,
402 				    (status == SCSI_NV_AMBIGUOUS) ?
403 				    "ambiguous" : "invalid", "report zones",
404 				    optarg);
405 				error = 1;
406 				goto bailout;
407 			}
408 			break;
409 		}
410 		case 'P': {
411 			scsi_nv_status status;
412 			int entry_num;
413 
414 			status = scsi_get_nv(zone_print_opts,
415 			    (sizeof(zone_print_opts) /
416 			    sizeof(zone_print_opts[0])), optarg, &entry_num,
417 			    SCSI_NV_FLAG_IG_CASE);
418 			if (status == SCSI_NV_FOUND)
419 				out_flags = zone_print_opts[entry_num].value;
420 			else {
421 				warnx("%s: %s: %s option %s", __func__,
422 				    (status == SCSI_NV_AMBIGUOUS) ?
423 				    "ambiguous" : "invalid", "print",
424 				    optarg);
425 				error = 1;
426 				goto bailout;
427 			}
428 			break;
429 		}
430 		default:
431 			break;
432 		}
433 	}
434 	if (action == -1) {
435 		warnx("%s: must specify -c <zone_cmd>", __func__);
436 		error = 1;
437 		goto bailout;
438 	}
439 	error = get_device_type(device, retry_count, timeout,
440 	    /*printerrors*/ 1, &devtype);
441 	if (error != 0)
442 		errx(1, "Unable to determine device type");
443 
444 	if (action == ZBC_IN_SA_REPORT_ZONES) {
445 
446 		data_ptr = malloc(alloc_len);
447 		if (data_ptr == NULL)
448 			err(1, "unable to allocate %u bytes", alloc_len);
449 
450 restart_report:
451 		bzero(data_ptr, alloc_len);
452 
453 		switch (devtype) {
454 		case CC_DT_SCSI:
455 			scsi_zbc_in(&ccb->csio,
456 			    /*retries*/ retry_count,
457 			    /*cbfcnp*/ NULL,
458 			    /*tag_action*/ task_attr,
459 			    /*service_action*/ action,
460 			    /*zone_start_lba*/ lba,
461 			    /*zone_options*/ (rep_option != -1) ?
462 					      rep_option : 0,
463 			    /*data_ptr*/ data_ptr,
464 			    /*dxfer_len*/ alloc_len,
465 			    /*sense_len*/ SSD_FULL_SIZE,
466 			    /*timeout*/ timeout ? timeout : 60000);
467 			break;
468 		case CC_DT_ATA:
469 		case CC_DT_SATL: {
470 			uint8_t command = 0;
471 			uint8_t protocol = 0;
472 			uint16_t features = 0, sector_count = 0;
473 			uint32_t auxiliary = 0;
474 
475 			/*
476 			 * XXX KDM support the partial bit?
477 			 */
478 			if (use_ncq == 0) {
479 				command = ATA_ZAC_MANAGEMENT_IN;
480 				features = action;
481 				if (rep_option != -1)
482 					features |= (rep_option << 8);
483 				sector_count = ZAC_ATA_SECTOR_COUNT(alloc_len);
484 				protocol = AP_PROTO_DMA;
485 			} else {
486 				if (cdb_storage == NULL)
487 					cdb_storage = calloc(cdb_storage_len, 1);
488 				if (cdb_storage == NULL)
489 					err(1, "couldn't allocate memory");
490 
491 				command = ATA_RECV_FPDMA_QUEUED;
492 				features = ZAC_ATA_SECTOR_COUNT(alloc_len);
493 				sector_count = ATA_RFPDMA_ZAC_MGMT_IN << 8;
494 				auxiliary = action & 0xf;
495 				if (rep_option != -1)
496 					auxiliary |= rep_option << 8;
497 				protocol = AP_PROTO_FPDMA;
498 			}
499 
500 			error = build_ata_cmd(ccb,
501 			    /*retry_count*/ retry_count,
502 			    /*flags*/ CAM_DIR_IN | CAM_DEV_QFRZDIS,
503 			    /*tag_action*/ task_attr,
504 			    /*protocol*/ protocol,
505 			    /*ata_flags*/ AP_FLAG_BYT_BLOK_BLOCKS |
506 					  AP_FLAG_TLEN_SECT_CNT |
507 					  AP_FLAG_TDIR_FROM_DEV,
508 			    /*features*/ features,
509 			    /*sector_count*/ sector_count,
510 			    /*lba*/ lba,
511 			    /*command*/ command,
512 			    /*auxiliary*/ auxiliary,
513 			    /*data_ptr*/ data_ptr,
514 			    /*dxfer_len*/ ZAC_ATA_SECTOR_COUNT(alloc_len)*512,
515 			    /*cdb_storage*/ cdb_storage,
516 			    /*cdb_storage_len*/ cdb_storage_len,
517 			    /*sense_len*/ SSD_FULL_SIZE,
518 			    /*timeout*/ timeout ? timeout : 60000,
519 			    /*is48bit*/ 1,
520 			    /*devtype*/ devtype);
521 
522 			if (error != 0) {
523 				warnx("%s: build_ata_cmd() failed, likely "
524 				    "programmer error", __func__);
525 				goto bailout;
526 			}
527 
528 			ata_format = 1;
529 
530 			break;
531 		}
532 		default:
533 			warnx("%s: Unknown device type %d", __func__,devtype);
534 			error = 1;
535 			goto bailout;
536 			break; /*NOTREACHED*/
537 		}
538 	} else {
539 		/*
540 		 * XXX KDM the current methodology is to always send ATA
541 		 * commands to ATA devices.  Need to figure out how to
542 		 * detect whether a SCSI to ATA translation layer will
543 		 * translate ZBC IN/OUT commands to the appropriate ZAC
544 		 * command.
545 		 */
546 		switch (devtype) {
547 		case CC_DT_SCSI:
548 			scsi_zbc_out(&ccb->csio,
549 			    /*retries*/ retry_count,
550 			    /*cbfcnp*/ NULL,
551 			    /*tag_action*/ task_attr,
552 			    /*service_action*/ action,
553 			    /*zone_id*/ lba,
554 			    /*zone_flags*/ (all_zones != 0) ? ZBC_OUT_ALL : 0,
555 			    /*data_ptr*/ NULL,
556 			    /*dxfer_len*/ 0,
557 			    /*sense_len*/ SSD_FULL_SIZE,
558 			    /*timeout*/ timeout ? timeout : 60000);
559 			break;
560 		case CC_DT_ATA:
561 		case CC_DT_SATL: {
562 			uint8_t command = 0;
563 			uint8_t protocol = 0;
564 			uint16_t features = 0, sector_count = 0;
565 			uint32_t auxiliary = 0;
566 
567 			/*
568 			 * Note that we're taking advantage of the fact
569 			 * that the action numbers are the same between the
570 			 * ZBC and ZAC specs.
571 			 */
572 
573 			if (use_ncq == 0) {
574 				protocol = AP_PROTO_NON_DATA;
575 				command = ATA_ZAC_MANAGEMENT_OUT;
576 				features = action & 0xf;
577 				if (all_zones != 0)
578 					features |= (ZBC_OUT_ALL << 8);
579 			} else {
580 				cdb_storage = calloc(cdb_storage_len, 1);
581 				if (cdb_storage == NULL)
582 					err(1, "couldn't allocate memory");
583 
584 				protocol = AP_PROTO_FPDMA;
585 				command = ATA_NCQ_NON_DATA;
586 				features = ATA_NCQ_ZAC_MGMT_OUT;
587 				auxiliary = action & 0xf;
588 				if (all_zones != 0)
589 					auxiliary |= (ZBC_OUT_ALL << 8);
590 			}
591 
592 
593 			error = build_ata_cmd(ccb,
594 			    /*retry_count*/ retry_count,
595 			    /*flags*/ CAM_DIR_NONE | CAM_DEV_QFRZDIS,
596 			    /*tag_action*/ task_attr,
597 			    /*protocol*/ AP_PROTO_NON_DATA,
598 			    /*ata_flags*/ AP_FLAG_BYT_BLOK_BYTES |
599 					  AP_FLAG_TLEN_NO_DATA,
600 			    /*features*/ features,
601 			    /*sector_count*/ sector_count,
602 			    /*lba*/ lba,
603 			    /*command*/ command,
604 			    /*auxiliary*/ auxiliary,
605 			    /*data_ptr*/ NULL,
606 			    /*dxfer_len*/ 0,
607 			    /*cdb_storage*/ cdb_storage,
608 			    /*cdb_storage_len*/ cdb_storage_len,
609 			    /*sense_len*/ SSD_FULL_SIZE,
610 			    /*timeout*/ timeout ? timeout : 60000,
611 			    /*is48bit*/ 1,
612 			    /*devtype*/ devtype);
613 			if (error != 0) {
614 				warnx("%s: build_ata_cmd() failed, likely "
615 				    "programmer error", __func__);
616 				goto bailout;
617 			}
618 			ata_format = 1;
619 			break;
620 		}
621 		default:
622 			warnx("%s: Unknown device type %d", __func__,devtype);
623 			error = 1;
624 			goto bailout;
625 			break; /*NOTREACHED*/
626 		}
627 	}
628 
629 	ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
630 	if (retry_count > 0)
631 		ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
632 
633 	error = cam_send_ccb(device, ccb);
634 	if (error != 0) {
635 		warn("error sending %s %s CCB", (devtype == CC_DT_SCSI) ?
636 		     "ZBC" : "ZAC Management",
637 		     (action == ZBC_IN_SA_REPORT_ZONES) ? "In" : "Out");
638 		error = -1;
639 		goto bailout;
640 	}
641 
642 	if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
643 		cam_error_print(device, ccb, CAM_ESF_ALL, CAM_EPF_ALL,stderr);
644 		error = 1;
645 		goto bailout;
646 	}
647 
648 	/*
649 	 * If we aren't reading the list of zones, we're done.
650 	 */
651 	if (action != ZBC_IN_SA_REPORT_ZONES)
652 		goto bailout;
653 
654 	if (ccb->ccb_h.func_code == XPT_SCSI_IO)
655 		valid_len = ccb->csio.dxfer_len - ccb->csio.resid;
656 	else
657 		valid_len = ccb->ataio.dxfer_len - ccb->ataio.resid;
658 
659 	zp_status = zone_rz_print(data_ptr, valid_len, ata_format, out_flags,
660 	    first_pass, &lba);
661 
662 	if (zp_status == ZONE_PRINT_MORE_DATA) {
663 		bzero(ccb, sizeof(*ccb));
664 		first_pass = 0;
665 		if (cdb_storage != NULL)
666 			bzero(cdb_storage, cdb_storage_len);
667 		goto restart_report;
668 	} else if (zp_status == ZONE_PRINT_ERROR)
669 		error = 1;
670 bailout:
671 	if (ccb != NULL)
672 		cam_freeccb(ccb);
673 
674 	free(data_ptr);
675 	free(cdb_storage);
676 
677 	return (error);
678 }
679