1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (c) 2009 Alexander Motin <mav@FreeBSD.org>
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer,
12 * without modification, immediately at the beginning of the file.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 #include "opt_ada.h"
30
31 #include <sys/param.h>
32
33 #ifdef _KERNEL
34 #include <sys/systm.h>
35 #include <sys/kernel.h>
36 #include <sys/bio.h>
37 #include <sys/sysctl.h>
38 #include <sys/taskqueue.h>
39 #include <sys/lock.h>
40 #include <sys/mutex.h>
41 #include <sys/conf.h>
42 #include <sys/devicestat.h>
43 #include <sys/eventhandler.h>
44 #include <sys/malloc.h>
45 #include <sys/endian.h>
46 #include <sys/cons.h>
47 #include <sys/proc.h>
48 #include <sys/reboot.h>
49 #include <sys/sbuf.h>
50 #include <geom/geom.h>
51 #include <geom/geom_disk.h>
52 #endif /* _KERNEL */
53
54 #ifndef _KERNEL
55 #include <stdio.h>
56 #include <string.h>
57 #endif /* _KERNEL */
58
59 #include <cam/cam.h>
60 #include <cam/cam_ccb.h>
61 #include <cam/cam_periph.h>
62 #include <cam/cam_xpt_periph.h>
63 #include <cam/scsi/scsi_all.h>
64 #include <cam/scsi/scsi_da.h>
65 #include <cam/cam_sim.h>
66 #include <cam/cam_iosched.h>
67
68 #include <cam/ata/ata_all.h>
69
70 #ifdef _KERNEL
71
72 #define ATA_MAX_28BIT_LBA 268435455UL
73
74 extern int iosched_debug;
75
76 typedef enum {
77 ADA_STATE_RAHEAD,
78 ADA_STATE_WCACHE,
79 ADA_STATE_LOGDIR,
80 ADA_STATE_IDDIR,
81 ADA_STATE_SUP_CAP,
82 ADA_STATE_ZONE,
83 ADA_STATE_NORMAL
84 } ada_state;
85
86 typedef enum {
87 ADA_FLAG_CAN_48BIT = 0x00000002,
88 ADA_FLAG_CAN_FLUSHCACHE = 0x00000004,
89 ADA_FLAG_CAN_NCQ = 0x00000008,
90 ADA_FLAG_CAN_DMA = 0x00000010,
91 ADA_FLAG_NEED_OTAG = 0x00000020,
92 ADA_FLAG_WAS_OTAG = 0x00000040,
93 ADA_FLAG_CAN_TRIM = 0x00000080,
94 ADA_FLAG_OPEN = 0x00000100,
95 ADA_FLAG_SCTX_INIT = 0x00000200,
96 ADA_FLAG_CAN_CFA = 0x00000400,
97 ADA_FLAG_CAN_POWERMGT = 0x00000800,
98 ADA_FLAG_CAN_DMA48 = 0x00001000,
99 ADA_FLAG_CAN_LOG = 0x00002000,
100 ADA_FLAG_CAN_IDLOG = 0x00004000,
101 ADA_FLAG_CAN_SUPCAP = 0x00008000,
102 ADA_FLAG_CAN_ZONE = 0x00010000,
103 ADA_FLAG_CAN_WCACHE = 0x00020000,
104 ADA_FLAG_CAN_RAHEAD = 0x00040000,
105 ADA_FLAG_PROBED = 0x00080000,
106 ADA_FLAG_ANNOUNCED = 0x00100000,
107 ADA_FLAG_DIRTY = 0x00200000,
108 ADA_FLAG_CAN_NCQ_TRIM = 0x00400000, /* CAN_TRIM also set */
109 ADA_FLAG_PIM_ATA_EXT = 0x00800000,
110 ADA_FLAG_UNMAPPEDIO = 0x01000000,
111 ADA_FLAG_ROTATING = 0x02000000
112 } ada_flags;
113 #define ADA_FLAG_STRING \
114 "\020" \
115 "\002CAN_48BIT" \
116 "\003CAN_FLUSHCACHE" \
117 "\004CAN_NCQ" \
118 "\005CAN_DMA" \
119 "\006NEED_OTAG" \
120 "\007WAS_OTAG" \
121 "\010CAN_TRIM" \
122 "\011OPEN" \
123 "\012SCTX_INIT" \
124 "\013CAN_CFA" \
125 "\014CAN_POWERMGT" \
126 "\015CAN_DMA48" \
127 "\016CAN_LOG" \
128 "\017CAN_IDLOG" \
129 "\020CAN_SUPCAP" \
130 "\021CAN_ZONE" \
131 "\022CAN_WCACHE" \
132 "\023CAN_RAHEAD" \
133 "\024PROBED" \
134 "\025ANNOUNCED" \
135 "\026DIRTY" \
136 "\027CAN_NCQ_TRIM" \
137 "\030PIM_ATA_EXT" \
138 "\031UNMAPPEDIO" \
139 "\032ROTATING"
140
141 typedef enum {
142 ADA_Q_NONE = 0x00,
143 ADA_Q_4K = 0x01,
144 ADA_Q_NCQ_TRIM_BROKEN = 0x02,
145 ADA_Q_LOG_BROKEN = 0x04,
146 ADA_Q_SMR_DM = 0x08,
147 ADA_Q_NO_TRIM = 0x10,
148 ADA_Q_128KB = 0x20
149 } ada_quirks;
150
151 #define ADA_Q_BIT_STRING \
152 "\020" \
153 "\0014K" \
154 "\002NCQ_TRIM_BROKEN" \
155 "\003LOG_BROKEN" \
156 "\004SMR_DM" \
157 "\005NO_TRIM" \
158 "\006128KB"
159
160 typedef enum {
161 ADA_CCB_RAHEAD = 0x01,
162 ADA_CCB_WCACHE = 0x02,
163 ADA_CCB_BUFFER_IO = 0x03,
164 ADA_CCB_DUMP = 0x05,
165 ADA_CCB_TRIM = 0x06,
166 ADA_CCB_LOGDIR = 0x07,
167 ADA_CCB_IDDIR = 0x08,
168 ADA_CCB_SUP_CAP = 0x09,
169 ADA_CCB_ZONE = 0x0a,
170 ADA_CCB_TYPE_MASK = 0x0F,
171 } ada_ccb_state;
172
173 typedef enum {
174 ADA_ZONE_NONE = 0x00,
175 ADA_ZONE_DRIVE_MANAGED = 0x01,
176 ADA_ZONE_HOST_AWARE = 0x02,
177 ADA_ZONE_HOST_MANAGED = 0x03
178 } ada_zone_mode;
179
180 typedef enum {
181 ADA_ZONE_FLAG_RZ_SUP = 0x0001,
182 ADA_ZONE_FLAG_OPEN_SUP = 0x0002,
183 ADA_ZONE_FLAG_CLOSE_SUP = 0x0004,
184 ADA_ZONE_FLAG_FINISH_SUP = 0x0008,
185 ADA_ZONE_FLAG_RWP_SUP = 0x0010,
186 ADA_ZONE_FLAG_SUP_MASK = (ADA_ZONE_FLAG_RZ_SUP |
187 ADA_ZONE_FLAG_OPEN_SUP |
188 ADA_ZONE_FLAG_CLOSE_SUP |
189 ADA_ZONE_FLAG_FINISH_SUP |
190 ADA_ZONE_FLAG_RWP_SUP),
191 ADA_ZONE_FLAG_URSWRZ = 0x0020,
192 ADA_ZONE_FLAG_OPT_SEQ_SET = 0x0040,
193 ADA_ZONE_FLAG_OPT_NONSEQ_SET = 0x0080,
194 ADA_ZONE_FLAG_MAX_SEQ_SET = 0x0100,
195 ADA_ZONE_FLAG_SET_MASK = (ADA_ZONE_FLAG_OPT_SEQ_SET |
196 ADA_ZONE_FLAG_OPT_NONSEQ_SET |
197 ADA_ZONE_FLAG_MAX_SEQ_SET)
198 } ada_zone_flags;
199
200 static struct ada_zone_desc {
201 ada_zone_flags value;
202 const char *desc;
203 } ada_zone_desc_table[] = {
204 {ADA_ZONE_FLAG_RZ_SUP, "Report Zones" },
205 {ADA_ZONE_FLAG_OPEN_SUP, "Open" },
206 {ADA_ZONE_FLAG_CLOSE_SUP, "Close" },
207 {ADA_ZONE_FLAG_FINISH_SUP, "Finish" },
208 {ADA_ZONE_FLAG_RWP_SUP, "Reset Write Pointer" },
209 };
210
211 /* Offsets into our private area for storing information */
212 #define ccb_state ppriv_field0
213 #define ccb_bp ppriv_ptr1
214
215 typedef enum {
216 ADA_DELETE_NONE,
217 ADA_DELETE_DISABLE,
218 ADA_DELETE_CFA_ERASE,
219 ADA_DELETE_DSM_TRIM,
220 ADA_DELETE_NCQ_DSM_TRIM,
221 ADA_DELETE_MIN = ADA_DELETE_CFA_ERASE,
222 ADA_DELETE_MAX = ADA_DELETE_NCQ_DSM_TRIM,
223 } ada_delete_methods;
224
225 static const char *ada_delete_method_names[] =
226 { "NONE", "DISABLE", "CFA_ERASE", "DSM_TRIM", "NCQ_DSM_TRIM" };
227 #if 0
228 static const char *ada_delete_method_desc[] =
229 { "NONE", "DISABLED", "CFA Erase", "DSM Trim", "DSM Trim via NCQ" };
230 #endif
231
232 struct disk_params {
233 uint8_t heads;
234 uint8_t secs_per_track;
235 uint32_t cylinders;
236 uint32_t secsize; /* Number of bytes/logical sector */
237 uint64_t sectors; /* Total number sectors */
238 };
239
240 #define TRIM_MAX_BLOCKS 8
241 #define TRIM_MAX_RANGES (TRIM_MAX_BLOCKS * ATA_DSM_BLK_RANGES)
242 struct trim_request {
243 uint8_t data[TRIM_MAX_RANGES * ATA_DSM_RANGE_SIZE];
244 TAILQ_HEAD(, bio) bps;
245 };
246
247 struct ada_softc {
248 struct cam_iosched_softc *cam_iosched;
249 int outstanding_cmds; /* Number of active commands */
250 int refcount; /* Active xpt_action() calls */
251 ada_state state;
252 ada_flags flags;
253 ada_zone_mode zone_mode;
254 ada_zone_flags zone_flags;
255 struct ata_gp_log_dir ata_logdir;
256 int valid_logdir_len;
257 struct ata_identify_log_pages ata_iddir;
258 int valid_iddir_len;
259 uint64_t optimal_seq_zones;
260 uint64_t optimal_nonseq_zones;
261 uint64_t max_seq_zones;
262 ada_quirks quirks;
263 ada_delete_methods delete_method;
264 int trim_max_ranges;
265 int read_ahead;
266 int write_cache;
267 #ifdef CAM_TEST_FAILURE
268 int force_read_error;
269 int force_write_error;
270 int periodic_read_error;
271 int periodic_read_count;
272 #endif
273 struct ccb_pathinq cpi;
274 struct disk_params params;
275 struct disk *disk;
276 struct task sysctl_task;
277 struct sysctl_ctx_list sysctl_ctx;
278 struct sysctl_oid *sysctl_tree;
279 struct callout sendordered_c;
280 struct trim_request trim_req;
281 uint64_t trim_count;
282 uint64_t trim_ranges;
283 uint64_t trim_lbas;
284 #ifdef CAM_IO_STATS
285 struct sysctl_ctx_list sysctl_stats_ctx;
286 struct sysctl_oid *sysctl_stats_tree;
287 u_int timeouts;
288 u_int errors;
289 u_int invalidations;
290 #endif
291 #define ADA_ANNOUNCETMP_SZ 80
292 char announce_temp[ADA_ANNOUNCETMP_SZ];
293 #define ADA_ANNOUNCE_SZ 400
294 char announce_buffer[ADA_ANNOUNCE_SZ];
295 };
296
297 static uma_zone_t ada_ccb_zone;
298
299 struct ada_quirk_entry {
300 struct scsi_inquiry_pattern inq_pat;
301 ada_quirks quirks;
302 };
303
304 static struct ada_quirk_entry ada_quirk_table[] =
305 {
306 {
307 /* Sandisk X400 */
308 { T_DIRECT, SIP_MEDIA_FIXED, "*", "SanDisk?SD8SB8U1T00*", "X4162000*" },
309 /*quirks*/ADA_Q_128KB
310 },
311 {
312 /* Hitachi Advanced Format (4k) drives */
313 { T_DIRECT, SIP_MEDIA_FIXED, "*", "Hitachi H??????????E3*", "*" },
314 /*quirks*/ADA_Q_4K
315 },
316 {
317 /* Samsung Advanced Format (4k) drives */
318 { T_DIRECT, SIP_MEDIA_FIXED, "*", "SAMSUNG HD155UI*", "*" },
319 /*quirks*/ADA_Q_4K
320 },
321 {
322 /* Samsung Advanced Format (4k) drives */
323 { T_DIRECT, SIP_MEDIA_FIXED, "*", "SAMSUNG HD204UI*", "*" },
324 /*quirks*/ADA_Q_4K
325 },
326 {
327 /* Seagate Barracuda Green Advanced Format (4k) drives */
328 { T_DIRECT, SIP_MEDIA_FIXED, "*", "ST????DL*", "*" },
329 /*quirks*/ADA_Q_4K
330 },
331 {
332 /* Seagate Barracuda Advanced Format (4k) drives */
333 { T_DIRECT, SIP_MEDIA_FIXED, "*", "ST???DM*", "*" },
334 /*quirks*/ADA_Q_4K
335 },
336 {
337 /* Seagate Barracuda Advanced Format (4k) drives */
338 { T_DIRECT, SIP_MEDIA_FIXED, "*", "ST????DM*", "*" },
339 /*quirks*/ADA_Q_4K
340 },
341 {
342 /* Seagate Momentus Advanced Format (4k) drives */
343 { T_DIRECT, SIP_MEDIA_FIXED, "*", "ST9500423AS*", "*" },
344 /*quirks*/ADA_Q_4K
345 },
346 {
347 /* Seagate Momentus Advanced Format (4k) drives */
348 { T_DIRECT, SIP_MEDIA_FIXED, "*", "ST9500424AS*", "*" },
349 /*quirks*/ADA_Q_4K
350 },
351 {
352 /* Seagate Momentus Advanced Format (4k) drives */
353 { T_DIRECT, SIP_MEDIA_FIXED, "*", "ST9640423AS*", "*" },
354 /*quirks*/ADA_Q_4K
355 },
356 {
357 /* Seagate Momentus Advanced Format (4k) drives */
358 { T_DIRECT, SIP_MEDIA_FIXED, "*", "ST9640424AS*", "*" },
359 /*quirks*/ADA_Q_4K
360 },
361 {
362 /* Seagate Momentus Advanced Format (4k) drives */
363 { T_DIRECT, SIP_MEDIA_FIXED, "*", "ST9750420AS*", "*" },
364 /*quirks*/ADA_Q_4K
365 },
366 {
367 /* Seagate Momentus Advanced Format (4k) drives */
368 { T_DIRECT, SIP_MEDIA_FIXED, "*", "ST9750422AS*", "*" },
369 /*quirks*/ADA_Q_4K
370 },
371 {
372 /* Seagate Momentus Advanced Format (4k) drives */
373 { T_DIRECT, SIP_MEDIA_FIXED, "*", "ST9750423AS*", "*" },
374 /*quirks*/ADA_Q_4K
375 },
376 {
377 /* Seagate Momentus Thin Advanced Format (4k) drives */
378 { T_DIRECT, SIP_MEDIA_FIXED, "*", "ST???LT*", "*" },
379 /*quirks*/ADA_Q_4K
380 },
381 {
382 /* WDC Caviar Red Advanced Format (4k) drives */
383 { T_DIRECT, SIP_MEDIA_FIXED, "*", "WDC WD????CX*", "*" },
384 /*quirks*/ADA_Q_4K
385 },
386 {
387 /* WDC Caviar Green Advanced Format (4k) drives */
388 { T_DIRECT, SIP_MEDIA_FIXED, "*", "WDC WD????RS*", "*" },
389 /*quirks*/ADA_Q_4K
390 },
391 {
392 /* WDC Caviar Green/Red Advanced Format (4k) drives */
393 { T_DIRECT, SIP_MEDIA_FIXED, "*", "WDC WD????RX*", "*" },
394 /*quirks*/ADA_Q_4K
395 },
396 {
397 /* WDC Caviar Red Advanced Format (4k) drives */
398 { T_DIRECT, SIP_MEDIA_FIXED, "*", "WDC WD??????CX*", "*" },
399 /*quirks*/ADA_Q_4K
400 },
401 {
402 /* WDC Caviar Black Advanced Format (4k) drives */
403 { T_DIRECT, SIP_MEDIA_FIXED, "*", "WDC WD????AZEX*", "*" },
404 /*quirks*/ADA_Q_4K
405 },
406 {
407 /* WDC Caviar Black Advanced Format (4k) drives */
408 { T_DIRECT, SIP_MEDIA_FIXED, "*", "WDC WD????FZEX*", "*" },
409 /*quirks*/ADA_Q_4K
410 },
411 {
412 /* WDC Caviar Green Advanced Format (4k) drives */
413 { T_DIRECT, SIP_MEDIA_FIXED, "*", "WDC WD??????RS*", "*" },
414 /*quirks*/ADA_Q_4K
415 },
416 {
417 /* WDC Caviar Green Advanced Format (4k) drives */
418 { T_DIRECT, SIP_MEDIA_FIXED, "*", "WDC WD??????RX*", "*" },
419 /*quirks*/ADA_Q_4K
420 },
421 {
422 /* WDC Scorpio Black Advanced Format (4k) drives */
423 { T_DIRECT, SIP_MEDIA_FIXED, "*", "WDC WD???PKT*", "*" },
424 /*quirks*/ADA_Q_4K
425 },
426 {
427 /* WDC Scorpio Black Advanced Format (4k) drives */
428 { T_DIRECT, SIP_MEDIA_FIXED, "*", "WDC WD?????PKT*", "*" },
429 /*quirks*/ADA_Q_4K
430 },
431 {
432 /* WDC Scorpio Blue Advanced Format (4k) drives */
433 { T_DIRECT, SIP_MEDIA_FIXED, "*", "WDC WD???PVT*", "*" },
434 /*quirks*/ADA_Q_4K
435 },
436 {
437 /* WDC Scorpio Blue Advanced Format (4k) drives */
438 { T_DIRECT, SIP_MEDIA_FIXED, "*", "WDC WD?????PVT*", "*" },
439 /*quirks*/ADA_Q_4K
440 },
441 /* SSDs */
442 {
443 /*
444 * Corsair Force 2 SSDs
445 * 4k optimised & trim only works in 4k requests + 4k aligned
446 */
447 { T_DIRECT, SIP_MEDIA_FIXED, "*", "Corsair CSSD-F*", "*" },
448 /*quirks*/ADA_Q_4K
449 },
450 {
451 /*
452 * Corsair Force 3 SSDs
453 * 4k optimised & trim only works in 4k requests + 4k aligned
454 */
455 { T_DIRECT, SIP_MEDIA_FIXED, "*", "Corsair Force 3*", "*" },
456 /*quirks*/ADA_Q_4K
457 },
458 {
459 /*
460 * Corsair Neutron GTX SSDs
461 * 4k optimised & trim only works in 4k requests + 4k aligned
462 */
463 { T_DIRECT, SIP_MEDIA_FIXED, "*", "Corsair Neutron GTX*", "*" },
464 /*quirks*/ADA_Q_4K
465 },
466 {
467 /*
468 * Corsair Force GT & GS SSDs
469 * 4k optimised & trim only works in 4k requests + 4k aligned
470 */
471 { T_DIRECT, SIP_MEDIA_FIXED, "*", "Corsair Force G*", "*" },
472 /*quirks*/ADA_Q_4K
473 },
474 {
475 /*
476 * Crucial M4 SSDs
477 * 4k optimised & trim only works in 4k requests + 4k aligned
478 */
479 { T_DIRECT, SIP_MEDIA_FIXED, "*", "M4-CT???M4SSD2*", "*" },
480 /*quirks*/ADA_Q_4K
481 },
482 {
483 /*
484 * Crucial M500 SSDs MU07 firmware
485 * NCQ Trim works
486 */
487 { T_DIRECT, SIP_MEDIA_FIXED, "*", "Crucial CT*M500*", "MU07" },
488 /*quirks*/0
489 },
490 {
491 /*
492 * Crucial M500 SSDs all other firmware
493 * NCQ Trim doesn't work
494 */
495 { T_DIRECT, SIP_MEDIA_FIXED, "*", "Crucial CT*M500*", "*" },
496 /*quirks*/ADA_Q_NCQ_TRIM_BROKEN
497 },
498 {
499 /*
500 * Crucial M550 SSDs
501 * NCQ Trim doesn't work, but only on MU01 firmware
502 */
503 { T_DIRECT, SIP_MEDIA_FIXED, "*", "Crucial CT*M550*", "MU01" },
504 /*quirks*/ADA_Q_NCQ_TRIM_BROKEN
505 },
506 {
507 /*
508 * Crucial MX100 SSDs
509 * NCQ Trim doesn't work, but only on MU01 firmware
510 */
511 { T_DIRECT, SIP_MEDIA_FIXED, "*", "Crucial CT*MX100*", "MU01" },
512 /*quirks*/ADA_Q_NCQ_TRIM_BROKEN
513 },
514 {
515 /*
516 * Crucial RealSSD C300 SSDs
517 * 4k optimised
518 */
519 { T_DIRECT, SIP_MEDIA_FIXED, "*", "C300-CTFDDAC???MAG*",
520 "*" }, /*quirks*/ADA_Q_4K
521 },
522 {
523 /*
524 * FCCT M500 SSDs
525 * NCQ Trim doesn't work
526 */
527 { T_DIRECT, SIP_MEDIA_FIXED, "*", "FCCT*M500*", "*" },
528 /*quirks*/ADA_Q_NCQ_TRIM_BROKEN
529 },
530 {
531 /*
532 * Intel 320 Series SSDs
533 * 4k optimised & trim only works in 4k requests + 4k aligned
534 */
535 { T_DIRECT, SIP_MEDIA_FIXED, "*", "INTEL SSDSA2CW*", "*" },
536 /*quirks*/ADA_Q_4K
537 },
538 {
539 /*
540 * Intel 330 Series SSDs
541 * 4k optimised & trim only works in 4k requests + 4k aligned
542 */
543 { T_DIRECT, SIP_MEDIA_FIXED, "*", "INTEL SSDSC2CT*", "*" },
544 /*quirks*/ADA_Q_4K
545 },
546 {
547 /*
548 * Intel 510 Series SSDs
549 * 4k optimised & trim only works in 4k requests + 4k aligned
550 */
551 { T_DIRECT, SIP_MEDIA_FIXED, "*", "INTEL SSDSC2MH*", "*" },
552 /*quirks*/ADA_Q_4K
553 },
554 {
555 /*
556 * Intel 520 Series SSDs
557 * 4k optimised & trim only works in 4k requests + 4k aligned
558 */
559 { T_DIRECT, SIP_MEDIA_FIXED, "*", "INTEL SSDSC2BW*", "*" },
560 /*quirks*/ADA_Q_4K
561 },
562 {
563 /*
564 * Intel S3610 Series SSDs
565 * 4k optimised & trim only works in 4k requests + 4k aligned
566 */
567 { T_DIRECT, SIP_MEDIA_FIXED, "*", "INTEL SSDSC2BX*", "*" },
568 /*quirks*/ADA_Q_4K
569 },
570 {
571 /*
572 * Intel X25-M Series SSDs
573 * 4k optimised & trim only works in 4k requests + 4k aligned
574 */
575 { T_DIRECT, SIP_MEDIA_FIXED, "*", "INTEL SSDSA2M*", "*" },
576 /*quirks*/ADA_Q_4K
577 },
578 {
579 /*
580 * KingDian S200 60GB P0921B
581 * Trimming crash the SSD
582 */
583 { T_DIRECT, SIP_MEDIA_FIXED, "*", "KingDian S200 *", "*" },
584 /*quirks*/ADA_Q_NO_TRIM
585 },
586 {
587 /*
588 * Kingston E100 Series SSDs
589 * 4k optimised & trim only works in 4k requests + 4k aligned
590 */
591 { T_DIRECT, SIP_MEDIA_FIXED, "*", "KINGSTON SE100S3*", "*" },
592 /*quirks*/ADA_Q_4K
593 },
594 {
595 /*
596 * Kingston HyperX 3k SSDs
597 * 4k optimised & trim only works in 4k requests + 4k aligned
598 */
599 { T_DIRECT, SIP_MEDIA_FIXED, "*", "KINGSTON SH103S3*", "*" },
600 /*quirks*/ADA_Q_4K
601 },
602 {
603 /*
604 * Marvell SSDs (entry taken from OpenSolaris)
605 * 4k optimised & trim only works in 4k requests + 4k aligned
606 */
607 { T_DIRECT, SIP_MEDIA_FIXED, "*", "MARVELL SD88SA02*", "*" },
608 /*quirks*/ADA_Q_4K
609 },
610 {
611 /*
612 * Micron M500 SSDs firmware MU07
613 * NCQ Trim works?
614 */
615 { T_DIRECT, SIP_MEDIA_FIXED, "*", "Micron M500*", "MU07" },
616 /*quirks*/0
617 },
618 {
619 /*
620 * Micron M500 SSDs all other firmware
621 * NCQ Trim doesn't work
622 */
623 { T_DIRECT, SIP_MEDIA_FIXED, "*", "Micron M500*", "*" },
624 /*quirks*/ADA_Q_NCQ_TRIM_BROKEN
625 },
626 {
627 /*
628 * Micron M5[15]0 SSDs
629 * NCQ Trim doesn't work, but only MU01 firmware
630 */
631 { T_DIRECT, SIP_MEDIA_FIXED, "*", "Micron M5[15]0*", "MU01" },
632 /*quirks*/ADA_Q_NCQ_TRIM_BROKEN
633 },
634 {
635 /*
636 * Micron 5100 SSDs
637 * 4k optimised & trim only works in 4k requests + 4k aligned
638 */
639 { T_DIRECT, SIP_MEDIA_FIXED, "*", "Micron 5100 MTFDDAK*", "*" },
640 /*quirks*/ADA_Q_4K
641 },
642 {
643 /*
644 * OCZ Agility 2 SSDs
645 * 4k optimised & trim only works in 4k requests + 4k aligned
646 */
647 { T_DIRECT, SIP_MEDIA_FIXED, "*", "OCZ-AGILITY2*", "*" },
648 /*quirks*/ADA_Q_4K
649 },
650 {
651 /*
652 * OCZ Agility 3 SSDs
653 * 4k optimised & trim only works in 4k requests + 4k aligned
654 */
655 { T_DIRECT, SIP_MEDIA_FIXED, "*", "OCZ-AGILITY3*", "*" },
656 /*quirks*/ADA_Q_4K
657 },
658 {
659 /*
660 * OCZ Deneva R Series SSDs
661 * 4k optimised & trim only works in 4k requests + 4k aligned
662 */
663 { T_DIRECT, SIP_MEDIA_FIXED, "*", "DENRSTE251M45*", "*" },
664 /*quirks*/ADA_Q_4K
665 },
666 {
667 /*
668 * OCZ Vertex 2 SSDs (inc pro series)
669 * 4k optimised & trim only works in 4k requests + 4k aligned
670 */
671 { T_DIRECT, SIP_MEDIA_FIXED, "*", "OCZ?VERTEX2*", "*" },
672 /*quirks*/ADA_Q_4K
673 },
674 {
675 /*
676 * OCZ Vertex 3 SSDs
677 * 4k optimised & trim only works in 4k requests + 4k aligned
678 */
679 { T_DIRECT, SIP_MEDIA_FIXED, "*", "OCZ-VERTEX3*", "*" },
680 /*quirks*/ADA_Q_4K
681 },
682 {
683 /*
684 * OCZ Vertex 4 SSDs
685 * 4k optimised & trim only works in 4k requests + 4k aligned
686 */
687 { T_DIRECT, SIP_MEDIA_FIXED, "*", "OCZ-VERTEX4*", "*" },
688 /*quirks*/ADA_Q_4K
689 },
690 {
691 /*
692 * Samsung 750 SSDs
693 * 4k optimised, NCQ TRIM seems to work
694 */
695 { T_DIRECT, SIP_MEDIA_FIXED, "*", "Samsung SSD 750*", "*" },
696 /*quirks*/ADA_Q_4K
697 },
698 {
699 /*
700 * Samsung 830 Series SSDs
701 * 4k optimised, NCQ TRIM Broken (normal TRIM is fine)
702 */
703 { T_DIRECT, SIP_MEDIA_FIXED, "*", "SAMSUNG SSD 830 Series*", "*" },
704 /*quirks*/ADA_Q_4K | ADA_Q_NCQ_TRIM_BROKEN
705 },
706 {
707 /*
708 * Samsung 840 SSDs
709 * 4k optimised, NCQ TRIM Broken (normal TRIM is fine)
710 */
711 { T_DIRECT, SIP_MEDIA_FIXED, "*", "Samsung SSD 840*", "*" },
712 /*quirks*/ADA_Q_4K | ADA_Q_NCQ_TRIM_BROKEN
713 },
714 {
715 /*
716 * Samsung 845 SSDs
717 * 4k optimised, NCQ TRIM Broken (normal TRIM is fine)
718 */
719 { T_DIRECT, SIP_MEDIA_FIXED, "*", "Samsung SSD 845*", "*" },
720 /*quirks*/ADA_Q_4K | ADA_Q_NCQ_TRIM_BROKEN
721 },
722 {
723 /*
724 * Samsung 850 SSDs
725 * 4k optimised, NCQ TRIM broken (normal TRIM fine)
726 */
727 { T_DIRECT, SIP_MEDIA_FIXED, "*", "Samsung SSD 850*", "*" },
728 /*quirks*/ADA_Q_4K | ADA_Q_NCQ_TRIM_BROKEN
729 },
730 {
731 /*
732 * Samsung 860 SSDs
733 * 4k optimised, NCQ TRIM broken (normal TRIM fine)
734 */
735 { T_DIRECT, SIP_MEDIA_FIXED, "*", "Samsung SSD 860*", "*" },
736 /*quirks*/ADA_Q_4K | ADA_Q_NCQ_TRIM_BROKEN
737 },
738 {
739 /*
740 * Samsung 870 SSDs
741 * 4k optimised, NCQ TRIM broken (normal TRIM fine)
742 */
743 { T_DIRECT, SIP_MEDIA_FIXED, "*", "Samsung SSD 870*", "*" },
744 /*quirks*/ADA_Q_4K | ADA_Q_NCQ_TRIM_BROKEN
745 },
746 {
747 /*
748 * Samsung SM863 Series SSDs (MZ7KM*)
749 * 4k optimised, NCQ believed to be working
750 */
751 { T_DIRECT, SIP_MEDIA_FIXED, "*", "SAMSUNG MZ7KM*", "*" },
752 /*quirks*/ADA_Q_4K
753 },
754 {
755 /*
756 * Samsung 843T Series SSDs (MZ7WD*)
757 * Samsung PM851 Series SSDs (MZ7TE*)
758 * Samsung PM853T Series SSDs (MZ7GE*)
759 * 4k optimised, NCQ believed to be broken since these are
760 * appear to be built with the same controllers as the 840/850.
761 */
762 { T_DIRECT, SIP_MEDIA_FIXED, "*", "SAMSUNG MZ7*", "*" },
763 /*quirks*/ADA_Q_4K | ADA_Q_NCQ_TRIM_BROKEN
764 },
765 {
766 /*
767 * Same as for SAMSUNG MZ7* but enable the quirks for SSD
768 * starting with MZ7* too
769 */
770 { T_DIRECT, SIP_MEDIA_FIXED, "*", "MZ7*", "*" },
771 /*quirks*/ADA_Q_4K | ADA_Q_NCQ_TRIM_BROKEN
772 },
773 {
774 /*
775 * Samsung PM851 Series SSDs Dell OEM
776 * device model "SAMSUNG SSD PM851 mSATA 256GB"
777 * 4k optimised, NCQ broken
778 */
779 { T_DIRECT, SIP_MEDIA_FIXED, "*", "SAMSUNG SSD PM851*", "*" },
780 /*quirks*/ADA_Q_4K | ADA_Q_NCQ_TRIM_BROKEN
781 },
782 {
783 /*
784 * SuperTalent TeraDrive CT SSDs
785 * 4k optimised & trim only works in 4k requests + 4k aligned
786 */
787 { T_DIRECT, SIP_MEDIA_FIXED, "*", "FTM??CT25H*", "*" },
788 /*quirks*/ADA_Q_4K
789 },
790 {
791 /*
792 * XceedIOPS SATA SSDs
793 * 4k optimised
794 */
795 { T_DIRECT, SIP_MEDIA_FIXED, "*", "SG9XCS2D*", "*" },
796 /*quirks*/ADA_Q_4K
797 },
798 {
799 /*
800 * Samsung drive that doesn't support READ LOG EXT or
801 * READ LOG DMA EXT, despite reporting that it does in
802 * ATA identify data:
803 * SAMSUNG HD200HJ KF100-06
804 */
805 { T_DIRECT, SIP_MEDIA_FIXED, "*", "SAMSUNG HD200*", "*" },
806 /*quirks*/ADA_Q_LOG_BROKEN
807 },
808 {
809 /*
810 * Samsung drive that doesn't support READ LOG EXT or
811 * READ LOG DMA EXT, despite reporting that it does in
812 * ATA identify data:
813 * SAMSUNG HD501LJ CR100-10
814 */
815 { T_DIRECT, SIP_MEDIA_FIXED, "*", "SAMSUNG HD501*", "*" },
816 /*quirks*/ADA_Q_LOG_BROKEN
817 },
818 {
819 /*
820 * Seagate Lamarr 8TB Shingled Magnetic Recording (SMR)
821 * Drive Managed SATA hard drive. This drive doesn't report
822 * in firmware that it is a drive managed SMR drive.
823 */
824 { T_DIRECT, SIP_MEDIA_FIXED, "*", "ST8000AS000[23]*", "*" },
825 /*quirks*/ADA_Q_SMR_DM
826 },
827 {
828 /* WD Green SSD */
829 { T_DIRECT, SIP_MEDIA_FIXED, "*", "WDC WDS?????G0*", "*" },
830 /*quirks*/ADA_Q_4K | ADA_Q_NCQ_TRIM_BROKEN
831 },
832 {
833 /* Seagate IronWolf 110 SATA SSD NCQ Trim is unstable */
834 { T_DIRECT, SIP_MEDIA_FIXED, "*", "ZA*NM*", "*" },
835 /*quirks*/ADA_Q_4K | ADA_Q_NCQ_TRIM_BROKEN
836 },
837 {
838 /* Default */
839 {
840 T_ANY, SIP_MEDIA_REMOVABLE|SIP_MEDIA_FIXED,
841 /*vendor*/"*", /*product*/"*", /*revision*/"*"
842 },
843 /*quirks*/0
844 },
845 };
846
847 static disk_strategy_t adastrategy;
848 static dumper_t adadump;
849 static periph_init_t adainit;
850 static void adadiskgonecb(struct disk *dp);
851 static periph_oninv_t adaoninvalidate;
852 static periph_dtor_t adacleanup;
853 static void adaasync(void *callback_arg, uint32_t code,
854 struct cam_path *path, void *arg);
855 static int adabitsysctl(SYSCTL_HANDLER_ARGS);
856 static int adaflagssysctl(SYSCTL_HANDLER_ARGS);
857 static int adazonesupsysctl(SYSCTL_HANDLER_ARGS);
858 static void adasysctlinit(void *context, int pending);
859 static int adagetattr(struct bio *bp);
860 static void adasetflags(struct ada_softc *softc,
861 struct ccb_getdev *cgd);
862 static void adasetgeom(struct ada_softc *softc,
863 struct ccb_getdev *cgd);
864 static periph_ctor_t adaregister;
865 static void ada_dsmtrim(struct ada_softc *softc, struct bio *bp,
866 struct ccb_ataio *ataio);
867 static void ada_cfaerase(struct ada_softc *softc, struct bio *bp,
868 struct ccb_ataio *ataio);
869 static int ada_zone_bio_to_ata(int disk_zone_cmd);
870 static int ada_zone_cmd(struct cam_periph *periph, union ccb *ccb,
871 struct bio *bp, int *queue_ccb);
872 static periph_start_t adastart;
873 static void adaprobedone(struct cam_periph *periph, union ccb *ccb);
874 static void adazonedone(struct cam_periph *periph, union ccb *ccb);
875 static void adadone(struct cam_periph *periph,
876 union ccb *done_ccb);
877 static int adaerror(union ccb *ccb, uint32_t cam_flags,
878 uint32_t sense_flags);
879 static callout_func_t adasendorderedtag;
880 static void adashutdown(void *arg, int howto);
881 static void adasuspend(void *arg);
882 static void adaresume(void *arg);
883
884 #ifndef ADA_DEFAULT_TIMEOUT
885 #define ADA_DEFAULT_TIMEOUT 30 /* Timeout in seconds */
886 #endif
887
888 #ifndef ADA_DEFAULT_RETRY
889 #define ADA_DEFAULT_RETRY 4
890 #endif
891
892 #ifndef ADA_DEFAULT_SEND_ORDERED
893 #define ADA_DEFAULT_SEND_ORDERED 1
894 #endif
895
896 #ifndef ADA_DEFAULT_SPINDOWN_SHUTDOWN
897 #define ADA_DEFAULT_SPINDOWN_SHUTDOWN 1
898 #endif
899
900 #ifndef ADA_DEFAULT_SPINDOWN_SUSPEND
901 #define ADA_DEFAULT_SPINDOWN_SUSPEND 1
902 #endif
903
904 #ifndef ADA_DEFAULT_READ_AHEAD
905 #define ADA_DEFAULT_READ_AHEAD 1
906 #endif
907
908 #ifndef ADA_DEFAULT_WRITE_CACHE
909 #define ADA_DEFAULT_WRITE_CACHE 1
910 #endif
911
912 #define ADA_RA (softc->read_ahead >= 0 ? \
913 softc->read_ahead : ada_read_ahead)
914 #define ADA_WC (softc->write_cache >= 0 ? \
915 softc->write_cache : ada_write_cache)
916
917 static int ada_retry_count = ADA_DEFAULT_RETRY;
918 static int ada_default_timeout = ADA_DEFAULT_TIMEOUT;
919 static int ada_send_ordered = ADA_DEFAULT_SEND_ORDERED;
920 static int ada_spindown_shutdown = ADA_DEFAULT_SPINDOWN_SHUTDOWN;
921 static int ada_spindown_suspend = ADA_DEFAULT_SPINDOWN_SUSPEND;
922 static int ada_read_ahead = ADA_DEFAULT_READ_AHEAD;
923 static int ada_write_cache = ADA_DEFAULT_WRITE_CACHE;
924 static int ada_enable_biospeedup = 1;
925 static int ada_enable_uma_ccbs = 1;
926
927 static SYSCTL_NODE(_kern_cam, OID_AUTO, ada, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
928 "CAM Direct Access Disk driver");
929 SYSCTL_INT(_kern_cam_ada, OID_AUTO, retry_count, CTLFLAG_RWTUN,
930 &ada_retry_count, 0, "Normal I/O retry count");
931 SYSCTL_INT(_kern_cam_ada, OID_AUTO, default_timeout, CTLFLAG_RWTUN,
932 &ada_default_timeout, 0, "Normal I/O timeout (in seconds)");
933 SYSCTL_INT(_kern_cam_ada, OID_AUTO, send_ordered, CTLFLAG_RWTUN,
934 &ada_send_ordered, 0, "Send Ordered Tags");
935 SYSCTL_INT(_kern_cam_ada, OID_AUTO, spindown_shutdown, CTLFLAG_RWTUN,
936 &ada_spindown_shutdown, 0, "Spin down upon shutdown");
937 SYSCTL_INT(_kern_cam_ada, OID_AUTO, spindown_suspend, CTLFLAG_RWTUN,
938 &ada_spindown_suspend, 0, "Spin down upon suspend");
939 SYSCTL_INT(_kern_cam_ada, OID_AUTO, read_ahead, CTLFLAG_RWTUN,
940 &ada_read_ahead, 0, "Enable disk read-ahead");
941 SYSCTL_INT(_kern_cam_ada, OID_AUTO, write_cache, CTLFLAG_RWTUN,
942 &ada_write_cache, 0, "Enable disk write cache");
943 SYSCTL_INT(_kern_cam_ada, OID_AUTO, enable_biospeedup, CTLFLAG_RDTUN,
944 &ada_enable_biospeedup, 0, "Enable BIO_SPEEDUP processing");
945 SYSCTL_INT(_kern_cam_ada, OID_AUTO, enable_uma_ccbs, CTLFLAG_RWTUN,
946 &ada_enable_uma_ccbs, 0, "Use UMA for CCBs");
947
948 /*
949 * ADA_ORDEREDTAG_INTERVAL determines how often, relative
950 * to the default timeout, we check to see whether an ordered
951 * tagged transaction is appropriate to prevent simple tag
952 * starvation. Since we'd like to ensure that there is at least
953 * 1/2 of the timeout length left for a starved transaction to
954 * complete after we've sent an ordered tag, we must poll at least
955 * four times in every timeout period. This takes care of the worst
956 * case where a starved transaction starts during an interval that
957 * meets the requirement "don't send an ordered tag" test so it takes
958 * us two intervals to determine that a tag must be sent.
959 */
960 #ifndef ADA_ORDEREDTAG_INTERVAL
961 #define ADA_ORDEREDTAG_INTERVAL 4
962 #endif
963
964 static struct periph_driver adadriver =
965 {
966 adainit, "ada",
967 TAILQ_HEAD_INITIALIZER(adadriver.units), /* generation */ 0
968 };
969
970 static int adadeletemethodsysctl(SYSCTL_HANDLER_ARGS);
971
972 PERIPHDRIVER_DECLARE(ada, adadriver);
973
974 static MALLOC_DEFINE(M_ATADA, "ata_da", "ata_da buffers");
975
976 static int
adaopen(struct disk * dp)977 adaopen(struct disk *dp)
978 {
979 struct cam_periph *periph;
980 struct ada_softc *softc;
981 int error;
982
983 periph = (struct cam_periph *)dp->d_drv1;
984 if (cam_periph_acquire(periph) != 0) {
985 return(ENXIO);
986 }
987
988 cam_periph_lock(periph);
989 if ((error = cam_periph_hold(periph, PRIBIO|PCATCH)) != 0) {
990 cam_periph_unlock(periph);
991 cam_periph_release(periph);
992 return (error);
993 }
994
995 CAM_DEBUG(periph->path, CAM_DEBUG_TRACE | CAM_DEBUG_PERIPH,
996 ("adaopen\n"));
997
998 softc = (struct ada_softc *)periph->softc;
999 softc->flags |= ADA_FLAG_OPEN;
1000
1001 cam_periph_unhold(periph);
1002 cam_periph_unlock(periph);
1003 return (0);
1004 }
1005
1006 static int
adaclose(struct disk * dp)1007 adaclose(struct disk *dp)
1008 {
1009 struct cam_periph *periph;
1010 struct ada_softc *softc;
1011 union ccb *ccb;
1012 int error;
1013
1014 periph = (struct cam_periph *)dp->d_drv1;
1015 softc = (struct ada_softc *)periph->softc;
1016 cam_periph_lock(periph);
1017
1018 CAM_DEBUG(periph->path, CAM_DEBUG_TRACE | CAM_DEBUG_PERIPH,
1019 ("adaclose\n"));
1020
1021 /* We only sync the cache if the drive is capable of it. */
1022 if ((softc->flags & ADA_FLAG_DIRTY) != 0 &&
1023 (softc->flags & ADA_FLAG_CAN_FLUSHCACHE) != 0 &&
1024 (periph->flags & CAM_PERIPH_INVALID) == 0 &&
1025 cam_periph_hold(periph, PRIBIO) == 0) {
1026 ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
1027 cam_fill_ataio(&ccb->ataio,
1028 1,
1029 NULL,
1030 CAM_DIR_NONE,
1031 0,
1032 NULL,
1033 0,
1034 ada_default_timeout*1000);
1035
1036 if (softc->flags & ADA_FLAG_CAN_48BIT)
1037 ata_48bit_cmd(&ccb->ataio, ATA_FLUSHCACHE48, 0, 0, 0);
1038 else
1039 ata_28bit_cmd(&ccb->ataio, ATA_FLUSHCACHE, 0, 0, 0);
1040 error = cam_periph_runccb(ccb, adaerror, /*cam_flags*/0,
1041 /*sense_flags*/0, softc->disk->d_devstat);
1042
1043 if (error != 0)
1044 xpt_print(periph->path, "Synchronize cache failed\n");
1045 softc->flags &= ~ADA_FLAG_DIRTY;
1046 xpt_release_ccb(ccb);
1047 cam_periph_unhold(periph);
1048 }
1049
1050 softc->flags &= ~ADA_FLAG_OPEN;
1051
1052 while (softc->refcount != 0)
1053 cam_periph_sleep(periph, &softc->refcount, PRIBIO, "adaclose", 1);
1054 cam_periph_unlock(periph);
1055 cam_periph_release(periph);
1056 return (0);
1057 }
1058
1059 static void
adaschedule(struct cam_periph * periph)1060 adaschedule(struct cam_periph *periph)
1061 {
1062 struct ada_softc *softc = (struct ada_softc *)periph->softc;
1063
1064 if (softc->state != ADA_STATE_NORMAL)
1065 return;
1066
1067 cam_iosched_schedule(softc->cam_iosched, periph);
1068 }
1069
1070 /*
1071 * Actually translate the requested transfer into one the physical driver
1072 * can understand. The transfer is described by a buf and will include
1073 * only one physical transfer.
1074 */
1075 static void
adastrategy(struct bio * bp)1076 adastrategy(struct bio *bp)
1077 {
1078 struct cam_periph *periph;
1079 struct ada_softc *softc;
1080
1081 periph = (struct cam_periph *)bp->bio_disk->d_drv1;
1082 softc = (struct ada_softc *)periph->softc;
1083
1084 cam_periph_lock(periph);
1085
1086 CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("adastrategy(%p)\n", bp));
1087
1088 /*
1089 * If the device has been made invalid, error out
1090 */
1091 if ((periph->flags & CAM_PERIPH_INVALID) != 0) {
1092 cam_periph_unlock(periph);
1093 biofinish(bp, NULL, ENXIO);
1094 return;
1095 }
1096
1097 /*
1098 * Zone commands must be ordered, because they can depend on the
1099 * effects of previously issued commands, and they may affect
1100 * commands after them.
1101 */
1102 if (bp->bio_cmd == BIO_ZONE)
1103 bp->bio_flags |= BIO_ORDERED;
1104
1105 /*
1106 * Place it in the queue of disk activities for this disk
1107 */
1108 cam_iosched_queue_work(softc->cam_iosched, bp);
1109
1110 /*
1111 * Schedule ourselves for performing the work.
1112 */
1113 adaschedule(periph);
1114 cam_periph_unlock(periph);
1115
1116 return;
1117 }
1118
1119 static int
adadump(void * arg,void * virtual,off_t offset,size_t length)1120 adadump(void *arg, void *virtual, off_t offset, size_t length)
1121 {
1122 struct cam_periph *periph;
1123 struct ada_softc *softc;
1124 u_int secsize;
1125 struct ccb_ataio ataio;
1126 struct disk *dp;
1127 uint64_t lba;
1128 uint16_t count;
1129 int error = 0;
1130
1131 dp = arg;
1132 periph = dp->d_drv1;
1133 softc = (struct ada_softc *)periph->softc;
1134 secsize = softc->params.secsize;
1135 lba = offset / secsize;
1136 count = length / secsize;
1137 if ((periph->flags & CAM_PERIPH_INVALID) != 0)
1138 return (ENXIO);
1139
1140 memset(&ataio, 0, sizeof(ataio));
1141 if (length > 0) {
1142 xpt_setup_ccb(&ataio.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
1143 ataio.ccb_h.ccb_state = ADA_CCB_DUMP;
1144 cam_fill_ataio(&ataio,
1145 0,
1146 NULL,
1147 CAM_DIR_OUT,
1148 0,
1149 (uint8_t *) virtual,
1150 length,
1151 ada_default_timeout*1000);
1152 if ((softc->flags & ADA_FLAG_CAN_48BIT) &&
1153 (lba + count >= ATA_MAX_28BIT_LBA ||
1154 count >= 256)) {
1155 ata_48bit_cmd(&ataio, ATA_WRITE_DMA48,
1156 0, lba, count);
1157 } else {
1158 ata_28bit_cmd(&ataio, ATA_WRITE_DMA,
1159 0, lba, count);
1160 }
1161 error = cam_periph_runccb((union ccb *)&ataio, adaerror,
1162 0, SF_NO_RECOVERY | SF_NO_RETRY, NULL);
1163 if (error != 0)
1164 printf("Aborting dump due to I/O error.\n");
1165
1166 return (error);
1167 }
1168
1169 if (softc->flags & ADA_FLAG_CAN_FLUSHCACHE) {
1170 xpt_setup_ccb(&ataio.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
1171
1172 /*
1173 * Tell the drive to flush its internal cache. if we
1174 * can't flush in 5s we have big problems. No need to
1175 * wait the default 60s to detect problems.
1176 */
1177 ataio.ccb_h.ccb_state = ADA_CCB_DUMP;
1178 cam_fill_ataio(&ataio,
1179 0,
1180 NULL,
1181 CAM_DIR_NONE,
1182 0,
1183 NULL,
1184 0,
1185 5*1000);
1186
1187 if (softc->flags & ADA_FLAG_CAN_48BIT)
1188 ata_48bit_cmd(&ataio, ATA_FLUSHCACHE48, 0, 0, 0);
1189 else
1190 ata_28bit_cmd(&ataio, ATA_FLUSHCACHE, 0, 0, 0);
1191 error = cam_periph_runccb((union ccb *)&ataio, adaerror,
1192 0, SF_NO_RECOVERY | SF_NO_RETRY, NULL);
1193 if (error != 0)
1194 xpt_print(periph->path, "Synchronize cache failed\n");
1195 }
1196 return (error);
1197 }
1198
1199 static void
adainit(void)1200 adainit(void)
1201 {
1202 cam_status status;
1203
1204 ada_ccb_zone = uma_zcreate("ada_ccb",
1205 sizeof(struct ccb_ataio), NULL, NULL, NULL, NULL,
1206 UMA_ALIGN_PTR, 0);
1207
1208 /*
1209 * Install a global async callback. This callback will
1210 * receive async callbacks like "new device found".
1211 */
1212 status = xpt_register_async(AC_FOUND_DEVICE, adaasync, NULL, NULL);
1213
1214 if (status != CAM_REQ_CMP) {
1215 printf("ada: Failed to attach master async callback "
1216 "due to status 0x%x!\n", status);
1217 } else if (ada_send_ordered) {
1218 /* Register our event handlers */
1219 if ((EVENTHANDLER_REGISTER(power_suspend, adasuspend,
1220 NULL, EVENTHANDLER_PRI_LAST)) == NULL)
1221 printf("adainit: power event registration failed!\n");
1222 if ((EVENTHANDLER_REGISTER(power_resume, adaresume,
1223 NULL, EVENTHANDLER_PRI_LAST)) == NULL)
1224 printf("adainit: power event registration failed!\n");
1225 if ((EVENTHANDLER_REGISTER(shutdown_post_sync, adashutdown,
1226 NULL, SHUTDOWN_PRI_DEFAULT)) == NULL)
1227 printf("adainit: shutdown event registration failed!\n");
1228 }
1229 }
1230
1231 /*
1232 * Callback from GEOM, called when it has finished cleaning up its
1233 * resources.
1234 */
1235 static void
adadiskgonecb(struct disk * dp)1236 adadiskgonecb(struct disk *dp)
1237 {
1238 struct cam_periph *periph;
1239
1240 periph = (struct cam_periph *)dp->d_drv1;
1241
1242 cam_periph_release(periph);
1243 }
1244
1245 static void
adaoninvalidate(struct cam_periph * periph)1246 adaoninvalidate(struct cam_periph *periph)
1247 {
1248 struct ada_softc *softc;
1249
1250 softc = (struct ada_softc *)periph->softc;
1251
1252 /*
1253 * De-register any async callbacks.
1254 */
1255 xpt_register_async(0, adaasync, periph, periph->path);
1256 #ifdef CAM_IO_STATS
1257 softc->invalidations++;
1258 #endif
1259
1260 /*
1261 * Return all queued I/O with ENXIO. Transactions may be queued up here
1262 * for retry (since we are called while there's other transactions
1263 * pending). Any requests in the hardware will drain before ndacleanup
1264 * is called.
1265 */
1266 cam_iosched_flush(softc->cam_iosched, NULL, ENXIO);
1267
1268 /*
1269 * Tell GEOM that we've gone away, we'll get a callback when it is
1270 * done cleaning up its resources.
1271 */
1272 disk_gone(softc->disk);
1273 }
1274
1275 static void
adacleanup(struct cam_periph * periph)1276 adacleanup(struct cam_periph *periph)
1277 {
1278 struct ada_softc *softc;
1279
1280 softc = (struct ada_softc *)periph->softc;
1281
1282 cam_periph_unlock(periph);
1283
1284 cam_iosched_fini(softc->cam_iosched);
1285
1286 /*
1287 * If we can't free the sysctl tree, oh well...
1288 */
1289 if ((softc->flags & ADA_FLAG_SCTX_INIT) != 0) {
1290 #ifdef CAM_IO_STATS
1291 if (sysctl_ctx_free(&softc->sysctl_stats_ctx) != 0)
1292 xpt_print(periph->path,
1293 "can't remove sysctl stats context\n");
1294 #endif
1295 if (sysctl_ctx_free(&softc->sysctl_ctx) != 0)
1296 xpt_print(periph->path,
1297 "can't remove sysctl context\n");
1298 }
1299
1300 disk_destroy(softc->disk);
1301 callout_drain(&softc->sendordered_c);
1302 free(softc, M_DEVBUF);
1303 cam_periph_lock(periph);
1304 }
1305
1306 static void
adasetdeletemethod(struct ada_softc * softc)1307 adasetdeletemethod(struct ada_softc *softc)
1308 {
1309
1310 if (softc->flags & ADA_FLAG_CAN_NCQ_TRIM)
1311 softc->delete_method = ADA_DELETE_NCQ_DSM_TRIM;
1312 else if (softc->flags & ADA_FLAG_CAN_TRIM)
1313 softc->delete_method = ADA_DELETE_DSM_TRIM;
1314 else if ((softc->flags & ADA_FLAG_CAN_CFA) && !(softc->flags & ADA_FLAG_CAN_48BIT))
1315 softc->delete_method = ADA_DELETE_CFA_ERASE;
1316 else
1317 softc->delete_method = ADA_DELETE_NONE;
1318 }
1319
1320 static void
adaasync(void * callback_arg,uint32_t code,struct cam_path * path,void * arg)1321 adaasync(void *callback_arg, uint32_t code,
1322 struct cam_path *path, void *arg)
1323 {
1324 struct ccb_getdev cgd;
1325 struct cam_periph *periph;
1326 struct ada_softc *softc;
1327
1328 periph = (struct cam_periph *)callback_arg;
1329 switch (code) {
1330 case AC_FOUND_DEVICE:
1331 {
1332 struct ccb_getdev *cgd;
1333 cam_status status;
1334
1335 cgd = (struct ccb_getdev *)arg;
1336 if (cgd == NULL)
1337 break;
1338
1339 if (cgd->protocol != PROTO_ATA)
1340 break;
1341
1342 /*
1343 * Allocate a peripheral instance for
1344 * this device and start the probe
1345 * process.
1346 */
1347 status = cam_periph_alloc(adaregister, adaoninvalidate,
1348 adacleanup, adastart,
1349 "ada", CAM_PERIPH_BIO,
1350 path, adaasync,
1351 AC_FOUND_DEVICE, cgd);
1352
1353 if (status != CAM_REQ_CMP
1354 && status != CAM_REQ_INPROG)
1355 printf("adaasync: Unable to attach to new device "
1356 "due to status 0x%x\n", status);
1357 break;
1358 }
1359 case AC_GETDEV_CHANGED:
1360 {
1361 softc = (struct ada_softc *)periph->softc;
1362 memset(&cgd, 0, sizeof(cgd));
1363 xpt_setup_ccb(&cgd.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
1364 cgd.ccb_h.func_code = XPT_GDEV_TYPE;
1365 xpt_action((union ccb *)&cgd);
1366
1367 /*
1368 * Update our information based on the new Identify data.
1369 */
1370 adasetflags(softc, &cgd);
1371 adasetgeom(softc, &cgd);
1372 disk_resize(softc->disk, M_NOWAIT);
1373 break;
1374 }
1375 case AC_ADVINFO_CHANGED:
1376 {
1377 uintptr_t buftype;
1378
1379 buftype = (uintptr_t)arg;
1380 if (buftype == CDAI_TYPE_PHYS_PATH) {
1381 struct ada_softc *softc;
1382
1383 softc = periph->softc;
1384 disk_attr_changed(softc->disk, "GEOM::physpath",
1385 M_NOWAIT);
1386 }
1387 break;
1388 }
1389 case AC_SENT_BDR:
1390 case AC_BUS_RESET:
1391 {
1392 softc = (struct ada_softc *)periph->softc;
1393 if (softc->state != ADA_STATE_NORMAL)
1394 break;
1395 if (ADA_RA >= 0 && softc->flags & ADA_FLAG_CAN_RAHEAD)
1396 softc->state = ADA_STATE_RAHEAD;
1397 else if (ADA_WC >= 0 && softc->flags & ADA_FLAG_CAN_WCACHE)
1398 softc->state = ADA_STATE_WCACHE;
1399 else if ((softc->flags & ADA_FLAG_CAN_LOG)
1400 && (softc->zone_mode != ADA_ZONE_NONE))
1401 softc->state = ADA_STATE_LOGDIR;
1402 else
1403 break;
1404 if (cam_periph_acquire(periph) != 0)
1405 softc->state = ADA_STATE_NORMAL;
1406 else
1407 xpt_schedule(periph, CAM_PRIORITY_DEV);
1408 break;
1409 }
1410 default:
1411 break;
1412 }
1413 cam_periph_async(periph, code, path, arg);
1414 }
1415
1416 static int
adazonemodesysctl(SYSCTL_HANDLER_ARGS)1417 adazonemodesysctl(SYSCTL_HANDLER_ARGS)
1418 {
1419 char tmpbuf[40];
1420 struct ada_softc *softc;
1421 int error;
1422
1423 softc = (struct ada_softc *)arg1;
1424
1425 switch (softc->zone_mode) {
1426 case ADA_ZONE_DRIVE_MANAGED:
1427 snprintf(tmpbuf, sizeof(tmpbuf), "Drive Managed");
1428 break;
1429 case ADA_ZONE_HOST_AWARE:
1430 snprintf(tmpbuf, sizeof(tmpbuf), "Host Aware");
1431 break;
1432 case ADA_ZONE_HOST_MANAGED:
1433 snprintf(tmpbuf, sizeof(tmpbuf), "Host Managed");
1434 break;
1435 case ADA_ZONE_NONE:
1436 default:
1437 snprintf(tmpbuf, sizeof(tmpbuf), "Not Zoned");
1438 break;
1439 }
1440
1441 error = sysctl_handle_string(oidp, tmpbuf, sizeof(tmpbuf), req);
1442
1443 return (error);
1444 }
1445
1446 static int
adazonesupsysctl(SYSCTL_HANDLER_ARGS)1447 adazonesupsysctl(SYSCTL_HANDLER_ARGS)
1448 {
1449 struct ada_softc *softc;
1450 struct sbuf sb;
1451 int error, first;
1452 unsigned int i;
1453
1454 softc = (struct ada_softc *)arg1;
1455
1456 first = 1;
1457 sbuf_new_for_sysctl(&sb, NULL, 0, req);
1458
1459 for (i = 0; i < sizeof(ada_zone_desc_table) /
1460 sizeof(ada_zone_desc_table[0]); i++) {
1461 if (softc->zone_flags & ada_zone_desc_table[i].value) {
1462 if (first == 0)
1463 sbuf_cat(&sb, ", ");
1464 else
1465 first = 0;
1466 sbuf_cat(&sb, ada_zone_desc_table[i].desc);
1467 }
1468 }
1469
1470 if (first == 1)
1471 sbuf_cat(&sb, "None");
1472
1473 error = sbuf_finish(&sb);
1474 sbuf_delete(&sb);
1475 return (error);
1476 }
1477
1478 static void
adasysctlinit(void * context,int pending)1479 adasysctlinit(void *context, int pending)
1480 {
1481 struct cam_periph *periph;
1482 struct ada_softc *softc;
1483 char tmpstr[32], tmpstr2[16];
1484
1485 periph = (struct cam_periph *)context;
1486
1487 /* periph was held for us when this task was enqueued */
1488 if ((periph->flags & CAM_PERIPH_INVALID) != 0) {
1489 cam_periph_release(periph);
1490 return;
1491 }
1492
1493 softc = (struct ada_softc *)periph->softc;
1494 snprintf(tmpstr, sizeof(tmpstr), "CAM ADA unit %d",periph->unit_number);
1495 snprintf(tmpstr2, sizeof(tmpstr2), "%d", periph->unit_number);
1496
1497 sysctl_ctx_init(&softc->sysctl_ctx);
1498 softc->flags |= ADA_FLAG_SCTX_INIT;
1499 softc->sysctl_tree = SYSCTL_ADD_NODE_WITH_LABEL(&softc->sysctl_ctx,
1500 SYSCTL_STATIC_CHILDREN(_kern_cam_ada), OID_AUTO, tmpstr2,
1501 CTLFLAG_RD | CTLFLAG_MPSAFE, 0, tmpstr, "device_index");
1502 if (softc->sysctl_tree == NULL) {
1503 printf("adasysctlinit: unable to allocate sysctl tree\n");
1504 cam_periph_release(periph);
1505 return;
1506 }
1507
1508 SYSCTL_ADD_PROC(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
1509 OID_AUTO, "delete_method",
1510 CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_MPSAFE,
1511 softc, 0, adadeletemethodsysctl, "A",
1512 "BIO_DELETE execution method");
1513 SYSCTL_ADD_UQUAD(&softc->sysctl_ctx,
1514 SYSCTL_CHILDREN(softc->sysctl_tree), OID_AUTO,
1515 "trim_count", CTLFLAG_RD, &softc->trim_count,
1516 "Total number of dsm commands sent");
1517 SYSCTL_ADD_UQUAD(&softc->sysctl_ctx,
1518 SYSCTL_CHILDREN(softc->sysctl_tree), OID_AUTO,
1519 "trim_ranges", CTLFLAG_RD, &softc->trim_ranges,
1520 "Total number of ranges in dsm commands");
1521 SYSCTL_ADD_UQUAD(&softc->sysctl_ctx,
1522 SYSCTL_CHILDREN(softc->sysctl_tree), OID_AUTO,
1523 "trim_lbas", CTLFLAG_RD, &softc->trim_lbas,
1524 "Total lbas in the dsm commands sent");
1525 SYSCTL_ADD_INT(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
1526 OID_AUTO, "read_ahead", CTLFLAG_RW | CTLFLAG_MPSAFE,
1527 &softc->read_ahead, 0, "Enable disk read ahead.");
1528 SYSCTL_ADD_INT(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
1529 OID_AUTO, "write_cache", CTLFLAG_RW | CTLFLAG_MPSAFE,
1530 &softc->write_cache, 0, "Enable disk write cache.");
1531 SYSCTL_ADD_PROC(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
1532 OID_AUTO, "zone_mode",
1533 CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE,
1534 softc, 0, adazonemodesysctl, "A",
1535 "Zone Mode");
1536 SYSCTL_ADD_PROC(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
1537 OID_AUTO, "zone_support",
1538 CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE,
1539 softc, 0, adazonesupsysctl, "A",
1540 "Zone Support");
1541 SYSCTL_ADD_UQUAD(&softc->sysctl_ctx,
1542 SYSCTL_CHILDREN(softc->sysctl_tree), OID_AUTO,
1543 "optimal_seq_zones", CTLFLAG_RD, &softc->optimal_seq_zones,
1544 "Optimal Number of Open Sequential Write Preferred Zones");
1545 SYSCTL_ADD_UQUAD(&softc->sysctl_ctx,
1546 SYSCTL_CHILDREN(softc->sysctl_tree), OID_AUTO,
1547 "optimal_nonseq_zones", CTLFLAG_RD,
1548 &softc->optimal_nonseq_zones,
1549 "Optimal Number of Non-Sequentially Written Sequential Write "
1550 "Preferred Zones");
1551 SYSCTL_ADD_UQUAD(&softc->sysctl_ctx,
1552 SYSCTL_CHILDREN(softc->sysctl_tree), OID_AUTO,
1553 "max_seq_zones", CTLFLAG_RD, &softc->max_seq_zones,
1554 "Maximum Number of Open Sequential Write Required Zones");
1555 SYSCTL_ADD_PROC(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
1556 OID_AUTO, "flags", CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE,
1557 softc, 0, adaflagssysctl, "A",
1558 "Flags for drive");
1559 SYSCTL_ADD_PROC(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
1560 OID_AUTO, "unmapped_io", CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE,
1561 &softc->flags, (u_int)ADA_FLAG_UNMAPPEDIO, adabitsysctl, "I",
1562 "Use unmapped I/O. This sysctl is *DEPRECATED*, gone in FreeBSD 15");
1563 SYSCTL_ADD_PROC(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
1564 OID_AUTO, "rotating", CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE,
1565 &softc->flags, (u_int)ADA_FLAG_ROTATING, adabitsysctl, "I",
1566 "Rotating media. This sysctl is *DEPRECATED*, gone in FreeBSD 15");
1567
1568 #ifdef CAM_TEST_FAILURE
1569 /*
1570 * Add a 'door bell' sysctl which allows one to set it from userland
1571 * and cause something bad to happen. For the moment, we only allow
1572 * whacking the next read or write.
1573 */
1574 SYSCTL_ADD_INT(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
1575 OID_AUTO, "force_read_error", CTLFLAG_RW | CTLFLAG_MPSAFE,
1576 &softc->force_read_error, 0,
1577 "Force a read error for the next N reads.");
1578 SYSCTL_ADD_INT(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
1579 OID_AUTO, "force_write_error", CTLFLAG_RW | CTLFLAG_MPSAFE,
1580 &softc->force_write_error, 0,
1581 "Force a write error for the next N writes.");
1582 SYSCTL_ADD_INT(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
1583 OID_AUTO, "periodic_read_error", CTLFLAG_RW | CTLFLAG_MPSAFE,
1584 &softc->periodic_read_error, 0,
1585 "Force a read error every N reads (don't set too low).");
1586 SYSCTL_ADD_PROC(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
1587 OID_AUTO, "invalidate", CTLTYPE_U64 | CTLFLAG_RW | CTLFLAG_MPSAFE,
1588 periph, 0, cam_periph_invalidate_sysctl, "I",
1589 "Write 1 to invalidate the drive immediately");
1590 #endif
1591
1592 #ifdef CAM_IO_STATS
1593 softc->sysctl_stats_tree = SYSCTL_ADD_NODE(&softc->sysctl_stats_ctx,
1594 SYSCTL_CHILDREN(softc->sysctl_tree), OID_AUTO, "stats",
1595 CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "Statistics");
1596 SYSCTL_ADD_INT(&softc->sysctl_stats_ctx,
1597 SYSCTL_CHILDREN(softc->sysctl_stats_tree),
1598 OID_AUTO, "timeouts", CTLFLAG_RD | CTLFLAG_MPSAFE,
1599 &softc->timeouts, 0,
1600 "Device timeouts reported by the SIM");
1601 SYSCTL_ADD_INT(&softc->sysctl_stats_ctx,
1602 SYSCTL_CHILDREN(softc->sysctl_stats_tree),
1603 OID_AUTO, "errors", CTLFLAG_RD | CTLFLAG_MPSAFE,
1604 &softc->errors, 0,
1605 "Transport errors reported by the SIM.");
1606 SYSCTL_ADD_INT(&softc->sysctl_stats_ctx,
1607 SYSCTL_CHILDREN(softc->sysctl_stats_tree),
1608 OID_AUTO, "pack_invalidations", CTLFLAG_RD | CTLFLAG_MPSAFE,
1609 &softc->invalidations, 0,
1610 "Device pack invalidations.");
1611 #endif
1612
1613 cam_iosched_sysctl_init(softc->cam_iosched, &softc->sysctl_ctx,
1614 softc->sysctl_tree);
1615
1616 cam_periph_release(periph);
1617 }
1618
1619 static int
adagetattr(struct bio * bp)1620 adagetattr(struct bio *bp)
1621 {
1622 int ret;
1623 struct cam_periph *periph;
1624
1625 if (g_handleattr_int(bp, "GEOM::canspeedup", ada_enable_biospeedup))
1626 return (EJUSTRETURN);
1627
1628 periph = (struct cam_periph *)bp->bio_disk->d_drv1;
1629 cam_periph_lock(periph);
1630 ret = xpt_getattr(bp->bio_data, bp->bio_length, bp->bio_attribute,
1631 periph->path);
1632 cam_periph_unlock(periph);
1633 if (ret == 0)
1634 bp->bio_completed = bp->bio_length;
1635 return ret;
1636 }
1637
1638 static int
adadeletemethodsysctl(SYSCTL_HANDLER_ARGS)1639 adadeletemethodsysctl(SYSCTL_HANDLER_ARGS)
1640 {
1641 char buf[16];
1642 const char *p;
1643 struct ada_softc *softc;
1644 int i, error, value, methods;
1645
1646 softc = (struct ada_softc *)arg1;
1647
1648 value = softc->delete_method;
1649 if (value < 0 || value > ADA_DELETE_MAX)
1650 p = "UNKNOWN";
1651 else
1652 p = ada_delete_method_names[value];
1653 strncpy(buf, p, sizeof(buf));
1654 error = sysctl_handle_string(oidp, buf, sizeof(buf), req);
1655 if (error != 0 || req->newptr == NULL)
1656 return (error);
1657 methods = 1 << ADA_DELETE_DISABLE;
1658 if ((softc->flags & ADA_FLAG_CAN_CFA) &&
1659 !(softc->flags & ADA_FLAG_CAN_48BIT))
1660 methods |= 1 << ADA_DELETE_CFA_ERASE;
1661 if (softc->flags & ADA_FLAG_CAN_TRIM)
1662 methods |= 1 << ADA_DELETE_DSM_TRIM;
1663 if (softc->flags & ADA_FLAG_CAN_NCQ_TRIM)
1664 methods |= 1 << ADA_DELETE_NCQ_DSM_TRIM;
1665 for (i = 0; i <= ADA_DELETE_MAX; i++) {
1666 if (!(methods & (1 << i)) ||
1667 strcmp(buf, ada_delete_method_names[i]) != 0)
1668 continue;
1669 softc->delete_method = i;
1670 return (0);
1671 }
1672 return (EINVAL);
1673 }
1674
1675 static int
adabitsysctl(SYSCTL_HANDLER_ARGS)1676 adabitsysctl(SYSCTL_HANDLER_ARGS)
1677 {
1678 u_int *flags = arg1;
1679 u_int test = arg2;
1680 int tmpout, error;
1681
1682 tmpout = !!(*flags & test);
1683 error = SYSCTL_OUT(req, &tmpout, sizeof(tmpout));
1684 if (error || !req->newptr)
1685 return (error);
1686
1687 return (EPERM);
1688 }
1689
1690 static int
adaflagssysctl(SYSCTL_HANDLER_ARGS)1691 adaflagssysctl(SYSCTL_HANDLER_ARGS)
1692 {
1693 struct sbuf sbuf;
1694 struct ada_softc *softc = arg1;
1695 int error;
1696
1697 sbuf_new_for_sysctl(&sbuf, NULL, 0, req);
1698 if (softc->flags != 0)
1699 sbuf_printf(&sbuf, "0x%b", (unsigned)softc->flags, ADA_FLAG_STRING);
1700 else
1701 sbuf_putc(&sbuf, '0');
1702 error = sbuf_finish(&sbuf);
1703 sbuf_delete(&sbuf);
1704
1705 return (error);
1706 }
1707
1708 static void
adasetflags(struct ada_softc * softc,struct ccb_getdev * cgd)1709 adasetflags(struct ada_softc *softc, struct ccb_getdev *cgd)
1710 {
1711 if ((cgd->ident_data.capabilities1 & ATA_SUPPORT_DMA) &&
1712 (cgd->inq_flags & SID_DMA))
1713 softc->flags |= ADA_FLAG_CAN_DMA;
1714 else
1715 softc->flags &= ~ADA_FLAG_CAN_DMA;
1716
1717 if (cgd->ident_data.support.command2 & ATA_SUPPORT_ADDRESS48) {
1718 softc->flags |= ADA_FLAG_CAN_48BIT;
1719 if (cgd->inq_flags & SID_DMA48)
1720 softc->flags |= ADA_FLAG_CAN_DMA48;
1721 else
1722 softc->flags &= ~ADA_FLAG_CAN_DMA48;
1723 } else
1724 softc->flags &= ~(ADA_FLAG_CAN_48BIT | ADA_FLAG_CAN_DMA48);
1725
1726 if (cgd->ident_data.support.command2 & ATA_SUPPORT_FLUSHCACHE)
1727 softc->flags |= ADA_FLAG_CAN_FLUSHCACHE;
1728 else
1729 softc->flags &= ~ADA_FLAG_CAN_FLUSHCACHE;
1730
1731 if (cgd->ident_data.support.command1 & ATA_SUPPORT_POWERMGT)
1732 softc->flags |= ADA_FLAG_CAN_POWERMGT;
1733 else
1734 softc->flags &= ~ADA_FLAG_CAN_POWERMGT;
1735
1736 if ((cgd->ident_data.satacapabilities & ATA_SUPPORT_NCQ) &&
1737 (cgd->inq_flags & SID_DMA) && (cgd->inq_flags & SID_CmdQue))
1738 softc->flags |= ADA_FLAG_CAN_NCQ;
1739 else
1740 softc->flags &= ~ADA_FLAG_CAN_NCQ;
1741
1742 if ((cgd->ident_data.support_dsm & ATA_SUPPORT_DSM_TRIM) &&
1743 (cgd->inq_flags & SID_DMA) &&
1744 (softc->quirks & ADA_Q_NO_TRIM) == 0) {
1745 softc->flags |= ADA_FLAG_CAN_TRIM;
1746 softc->trim_max_ranges = TRIM_MAX_RANGES;
1747 if (cgd->ident_data.max_dsm_blocks != 0) {
1748 softc->trim_max_ranges =
1749 min(cgd->ident_data.max_dsm_blocks *
1750 ATA_DSM_BLK_RANGES, softc->trim_max_ranges);
1751 }
1752 /*
1753 * If we can do RCVSND_FPDMA_QUEUED commands, we may be able
1754 * to do NCQ trims, if we support trims at all. We also need
1755 * support from the SIM to do things properly. Perhaps we
1756 * should look at log 13 dword 0 bit 0 and dword 1 bit 0 are
1757 * set too...
1758 */
1759 if ((softc->quirks & ADA_Q_NCQ_TRIM_BROKEN) == 0 &&
1760 (softc->flags & ADA_FLAG_PIM_ATA_EXT) != 0 &&
1761 (cgd->ident_data.satacapabilities2 &
1762 ATA_SUPPORT_RCVSND_FPDMA_QUEUED) != 0 &&
1763 (softc->flags & ADA_FLAG_CAN_TRIM) != 0)
1764 softc->flags |= ADA_FLAG_CAN_NCQ_TRIM;
1765 else
1766 softc->flags &= ~ADA_FLAG_CAN_NCQ_TRIM;
1767 } else
1768 softc->flags &= ~(ADA_FLAG_CAN_TRIM | ADA_FLAG_CAN_NCQ_TRIM);
1769
1770 if (cgd->ident_data.support.command2 & ATA_SUPPORT_CFA)
1771 softc->flags |= ADA_FLAG_CAN_CFA;
1772 else
1773 softc->flags &= ~ADA_FLAG_CAN_CFA;
1774
1775 /*
1776 * Now that we've set the appropriate flags, setup the delete
1777 * method.
1778 */
1779 adasetdeletemethod(softc);
1780
1781 if ((cgd->ident_data.support.extension & ATA_SUPPORT_GENLOG)
1782 && ((softc->quirks & ADA_Q_LOG_BROKEN) == 0))
1783 softc->flags |= ADA_FLAG_CAN_LOG;
1784 else
1785 softc->flags &= ~ADA_FLAG_CAN_LOG;
1786
1787 if ((cgd->ident_data.support3 & ATA_SUPPORT_ZONE_MASK) ==
1788 ATA_SUPPORT_ZONE_HOST_AWARE)
1789 softc->zone_mode = ADA_ZONE_HOST_AWARE;
1790 else if (((cgd->ident_data.support3 & ATA_SUPPORT_ZONE_MASK) ==
1791 ATA_SUPPORT_ZONE_DEV_MANAGED)
1792 || (softc->quirks & ADA_Q_SMR_DM))
1793 softc->zone_mode = ADA_ZONE_DRIVE_MANAGED;
1794 else
1795 softc->zone_mode = ADA_ZONE_NONE;
1796
1797 if (cgd->ident_data.support.command1 & ATA_SUPPORT_LOOKAHEAD)
1798 softc->flags |= ADA_FLAG_CAN_RAHEAD;
1799 else
1800 softc->flags &= ~ADA_FLAG_CAN_RAHEAD;
1801
1802 if (cgd->ident_data.support.command1 & ATA_SUPPORT_WRITECACHE)
1803 softc->flags |= ADA_FLAG_CAN_WCACHE;
1804 else
1805 softc->flags &= ~ADA_FLAG_CAN_WCACHE;
1806 }
1807
1808 static cam_status
adaregister(struct cam_periph * periph,void * arg)1809 adaregister(struct cam_periph *periph, void *arg)
1810 {
1811 struct ada_softc *softc;
1812 struct ccb_getdev *cgd;
1813 struct disk_params *dp;
1814 struct sbuf sb;
1815 char *announce_buf;
1816 caddr_t match;
1817 int quirks;
1818
1819 cgd = (struct ccb_getdev *)arg;
1820 if (cgd == NULL) {
1821 printf("adaregister: no getdev CCB, can't register device\n");
1822 return(CAM_REQ_CMP_ERR);
1823 }
1824
1825 softc = (struct ada_softc *)malloc(sizeof(*softc), M_DEVBUF,
1826 M_NOWAIT|M_ZERO);
1827
1828 if (softc == NULL) {
1829 printf("adaregister: Unable to probe new device. "
1830 "Unable to allocate softc\n");
1831 return(CAM_REQ_CMP_ERR);
1832 }
1833
1834 announce_buf = softc->announce_temp;
1835 bzero(announce_buf, ADA_ANNOUNCETMP_SZ);
1836
1837 if (cam_iosched_init(&softc->cam_iosched, periph) != 0) {
1838 printf("adaregister: Unable to probe new device. "
1839 "Unable to allocate iosched memory\n");
1840 free(softc, M_DEVBUF);
1841 return(CAM_REQ_CMP_ERR);
1842 }
1843
1844 periph->softc = softc;
1845 xpt_path_inq(&softc->cpi, periph->path);
1846
1847 /*
1848 * See if this device has any quirks.
1849 */
1850 match = cam_quirkmatch((caddr_t)&cgd->ident_data,
1851 (caddr_t)ada_quirk_table,
1852 nitems(ada_quirk_table),
1853 sizeof(*ada_quirk_table), ata_identify_match);
1854 if (match != NULL)
1855 softc->quirks = ((struct ada_quirk_entry *)match)->quirks;
1856 else
1857 softc->quirks = ADA_Q_NONE;
1858
1859 TASK_INIT(&softc->sysctl_task, 0, adasysctlinit, periph);
1860
1861 /*
1862 * Take a reference on the periph while adastart is called to finish
1863 * the probe. The reference will be dropped in adaprobedone at the
1864 * end of probe.
1865 */
1866 (void)cam_periph_acquire(periph);
1867 cam_periph_unlock(periph);
1868 snprintf(announce_buf, ADA_ANNOUNCETMP_SZ,
1869 "kern.cam.ada.%d.quirks", periph->unit_number);
1870 quirks = softc->quirks;
1871 TUNABLE_INT_FETCH(announce_buf, &quirks);
1872 softc->quirks = quirks;
1873 softc->read_ahead = -1;
1874 snprintf(announce_buf, ADA_ANNOUNCETMP_SZ,
1875 "kern.cam.ada.%d.read_ahead", periph->unit_number);
1876 TUNABLE_INT_FETCH(announce_buf, &softc->read_ahead);
1877 softc->write_cache = -1;
1878 snprintf(announce_buf, ADA_ANNOUNCETMP_SZ,
1879 "kern.cam.ada.%d.write_cache", periph->unit_number);
1880 TUNABLE_INT_FETCH(announce_buf, &softc->write_cache);
1881
1882 /*
1883 * Let XPT know we can use UMA-allocated CCBs.
1884 */
1885 if (ada_enable_uma_ccbs) {
1886 KASSERT(ada_ccb_zone != NULL,
1887 ("%s: NULL ada_ccb_zone", __func__));
1888 periph->ccb_zone = ada_ccb_zone;
1889 }
1890
1891 /*
1892 * Set support flags based on the Identify data and quirks.
1893 */
1894 adasetflags(softc, cgd);
1895 if (softc->cpi.hba_misc & PIM_ATA_EXT)
1896 softc->flags |= ADA_FLAG_PIM_ATA_EXT;
1897
1898 /* Disable queue sorting for non-rotational media by default. */
1899 if (cgd->ident_data.media_rotation_rate == ATA_RATE_NON_ROTATING) {
1900 softc->flags &= ~ADA_FLAG_ROTATING;
1901 } else {
1902 softc->flags |= ADA_FLAG_ROTATING;
1903 }
1904 cam_iosched_set_sort_queue(softc->cam_iosched,
1905 (softc->flags & ADA_FLAG_ROTATING) ? -1 : 0);
1906 softc->disk = disk_alloc();
1907 adasetgeom(softc, cgd);
1908 softc->disk->d_devstat = devstat_new_entry(periph->periph_name,
1909 periph->unit_number, softc->params.secsize,
1910 DEVSTAT_ALL_SUPPORTED,
1911 DEVSTAT_TYPE_DIRECT |
1912 XPORT_DEVSTAT_TYPE(softc->cpi.transport),
1913 DEVSTAT_PRIORITY_DISK);
1914 softc->disk->d_open = adaopen;
1915 softc->disk->d_close = adaclose;
1916 softc->disk->d_strategy = adastrategy;
1917 softc->disk->d_getattr = adagetattr;
1918 if (cam_sim_pollable(periph->sim))
1919 softc->disk->d_dump = adadump;
1920 softc->disk->d_gone = adadiskgonecb;
1921 softc->disk->d_name = "ada";
1922 softc->disk->d_drv1 = periph;
1923 softc->disk->d_unit = periph->unit_number;
1924 cam_periph_lock(periph);
1925
1926 dp = &softc->params;
1927 snprintf(announce_buf, ADA_ANNOUNCETMP_SZ,
1928 "%juMB (%ju %u byte sectors)",
1929 ((uintmax_t)dp->secsize * dp->sectors) / (1024 * 1024),
1930 (uintmax_t)dp->sectors, dp->secsize);
1931
1932 sbuf_new(&sb, softc->announce_buffer, ADA_ANNOUNCE_SZ, SBUF_FIXEDLEN);
1933 xpt_announce_periph_sbuf(periph, &sb, announce_buf);
1934 xpt_announce_quirks_sbuf(periph, &sb, softc->quirks, ADA_Q_BIT_STRING);
1935 sbuf_finish(&sb);
1936 sbuf_putbuf(&sb);
1937
1938 /*
1939 * Create our sysctl variables, now that we know
1940 * we have successfully attached.
1941 */
1942 if (cam_periph_acquire(periph) == 0)
1943 taskqueue_enqueue(taskqueue_thread, &softc->sysctl_task);
1944
1945 /*
1946 * Add async callbacks for bus reset and
1947 * bus device reset calls. I don't bother
1948 * checking if this fails as, in most cases,
1949 * the system will function just fine without
1950 * them and the only alternative would be to
1951 * not attach the device on failure.
1952 */
1953 xpt_register_async(AC_SENT_BDR | AC_BUS_RESET | AC_LOST_DEVICE |
1954 AC_GETDEV_CHANGED | AC_ADVINFO_CHANGED,
1955 adaasync, periph, periph->path);
1956
1957 /*
1958 * Schedule a periodic event to occasionally send an
1959 * ordered tag to a device.
1960 */
1961 callout_init_mtx(&softc->sendordered_c, cam_periph_mtx(periph), 0);
1962 callout_reset_sbt(&softc->sendordered_c,
1963 SBT_1S / ADA_ORDEREDTAG_INTERVAL * ada_default_timeout, 0,
1964 adasendorderedtag, softc, C_PREL(1));
1965
1966 /* Released after probe when disk_create() call pass it to GEOM. */
1967 cam_periph_hold_boot(periph);
1968
1969 if (ADA_RA >= 0 && softc->flags & ADA_FLAG_CAN_RAHEAD) {
1970 softc->state = ADA_STATE_RAHEAD;
1971 } else if (ADA_WC >= 0 && softc->flags & ADA_FLAG_CAN_WCACHE) {
1972 softc->state = ADA_STATE_WCACHE;
1973 } else if ((softc->flags & ADA_FLAG_CAN_LOG)
1974 && (softc->zone_mode != ADA_ZONE_NONE)) {
1975 softc->state = ADA_STATE_LOGDIR;
1976 } else {
1977 /*
1978 * Nothing to probe, so we can just transition to the
1979 * normal state.
1980 */
1981 adaprobedone(periph, NULL);
1982 return(CAM_REQ_CMP);
1983 }
1984
1985 xpt_schedule(periph, CAM_PRIORITY_DEV);
1986 return(CAM_REQ_CMP);
1987 }
1988
1989 static int
ada_dsmtrim_req_create(struct ada_softc * softc,struct bio * bp,struct trim_request * req)1990 ada_dsmtrim_req_create(struct ada_softc *softc, struct bio *bp, struct trim_request *req)
1991 {
1992 uint64_t lastlba = (uint64_t)-1, lbas = 0;
1993 int c, lastcount = 0, off, ranges = 0;
1994
1995 bzero(req, sizeof(*req));
1996 TAILQ_INIT(&req->bps);
1997 do {
1998 uint64_t lba = bp->bio_pblkno;
1999 int count = bp->bio_bcount / softc->params.secsize;
2000
2001 /* Try to extend the previous range. */
2002 if (lba == lastlba) {
2003 c = min(count, ATA_DSM_RANGE_MAX - lastcount);
2004 lastcount += c;
2005 off = (ranges - 1) * ATA_DSM_RANGE_SIZE;
2006 req->data[off + 6] = lastcount & 0xff;
2007 req->data[off + 7] =
2008 (lastcount >> 8) & 0xff;
2009 count -= c;
2010 lba += c;
2011 lbas += c;
2012 }
2013
2014 while (count > 0) {
2015 c = min(count, ATA_DSM_RANGE_MAX);
2016 off = ranges * ATA_DSM_RANGE_SIZE;
2017 req->data[off + 0] = lba & 0xff;
2018 req->data[off + 1] = (lba >> 8) & 0xff;
2019 req->data[off + 2] = (lba >> 16) & 0xff;
2020 req->data[off + 3] = (lba >> 24) & 0xff;
2021 req->data[off + 4] = (lba >> 32) & 0xff;
2022 req->data[off + 5] = (lba >> 40) & 0xff;
2023 req->data[off + 6] = c & 0xff;
2024 req->data[off + 7] = (c >> 8) & 0xff;
2025 lba += c;
2026 lbas += c;
2027 count -= c;
2028 lastcount = c;
2029 ranges++;
2030 /*
2031 * Its the caller's responsibility to ensure the
2032 * request will fit so we don't need to check for
2033 * overrun here
2034 */
2035 }
2036 lastlba = lba;
2037 TAILQ_INSERT_TAIL(&req->bps, bp, bio_queue);
2038
2039 bp = cam_iosched_next_trim(softc->cam_iosched);
2040 if (bp == NULL)
2041 break;
2042 if (bp->bio_bcount / softc->params.secsize >
2043 (softc->trim_max_ranges - ranges) * ATA_DSM_RANGE_MAX) {
2044 cam_iosched_put_back_trim(softc->cam_iosched, bp);
2045 break;
2046 }
2047 } while (1);
2048 softc->trim_count++;
2049 softc->trim_ranges += ranges;
2050 softc->trim_lbas += lbas;
2051
2052 return (ranges);
2053 }
2054
2055 static void
ada_dsmtrim(struct ada_softc * softc,struct bio * bp,struct ccb_ataio * ataio)2056 ada_dsmtrim(struct ada_softc *softc, struct bio *bp, struct ccb_ataio *ataio)
2057 {
2058 struct trim_request *req = &softc->trim_req;
2059 int ranges;
2060
2061 ranges = ada_dsmtrim_req_create(softc, bp, req);
2062 cam_fill_ataio(ataio,
2063 ada_retry_count,
2064 adadone,
2065 CAM_DIR_OUT,
2066 0,
2067 req->data,
2068 howmany(ranges, ATA_DSM_BLK_RANGES) * ATA_DSM_BLK_SIZE,
2069 ada_default_timeout * 1000);
2070 ata_48bit_cmd(ataio, ATA_DATA_SET_MANAGEMENT,
2071 ATA_DSM_TRIM, 0, howmany(ranges, ATA_DSM_BLK_RANGES));
2072 }
2073
2074 static void
ada_ncq_dsmtrim(struct ada_softc * softc,struct bio * bp,struct ccb_ataio * ataio)2075 ada_ncq_dsmtrim(struct ada_softc *softc, struct bio *bp, struct ccb_ataio *ataio)
2076 {
2077 struct trim_request *req = &softc->trim_req;
2078 int ranges;
2079
2080 ranges = ada_dsmtrim_req_create(softc, bp, req);
2081 cam_fill_ataio(ataio,
2082 ada_retry_count,
2083 adadone,
2084 CAM_DIR_OUT,
2085 0,
2086 req->data,
2087 howmany(ranges, ATA_DSM_BLK_RANGES) * ATA_DSM_BLK_SIZE,
2088 ada_default_timeout * 1000);
2089 ata_ncq_cmd(ataio,
2090 ATA_SEND_FPDMA_QUEUED,
2091 0,
2092 howmany(ranges, ATA_DSM_BLK_RANGES));
2093 ataio->cmd.sector_count_exp = ATA_SFPDMA_DSM;
2094 ataio->ata_flags |= ATA_FLAG_AUX;
2095 ataio->aux = 1;
2096 }
2097
2098 static void
ada_cfaerase(struct ada_softc * softc,struct bio * bp,struct ccb_ataio * ataio)2099 ada_cfaerase(struct ada_softc *softc, struct bio *bp, struct ccb_ataio *ataio)
2100 {
2101 struct trim_request *req = &softc->trim_req;
2102 uint64_t lba = bp->bio_pblkno;
2103 uint16_t count = bp->bio_bcount / softc->params.secsize;
2104
2105 bzero(req, sizeof(*req));
2106 TAILQ_INIT(&req->bps);
2107 TAILQ_INSERT_TAIL(&req->bps, bp, bio_queue);
2108
2109 cam_fill_ataio(ataio,
2110 ada_retry_count,
2111 adadone,
2112 CAM_DIR_NONE,
2113 0,
2114 NULL,
2115 0,
2116 ada_default_timeout*1000);
2117
2118 if (count >= 256)
2119 count = 0;
2120 ata_28bit_cmd(ataio, ATA_CFA_ERASE, 0, lba, count);
2121 }
2122
2123 static int
ada_zone_bio_to_ata(int disk_zone_cmd)2124 ada_zone_bio_to_ata(int disk_zone_cmd)
2125 {
2126 switch (disk_zone_cmd) {
2127 case DISK_ZONE_OPEN:
2128 return ATA_ZM_OPEN_ZONE;
2129 case DISK_ZONE_CLOSE:
2130 return ATA_ZM_CLOSE_ZONE;
2131 case DISK_ZONE_FINISH:
2132 return ATA_ZM_FINISH_ZONE;
2133 case DISK_ZONE_RWP:
2134 return ATA_ZM_RWP;
2135 }
2136
2137 return -1;
2138 }
2139
2140 static int
ada_zone_cmd(struct cam_periph * periph,union ccb * ccb,struct bio * bp,int * queue_ccb)2141 ada_zone_cmd(struct cam_periph *periph, union ccb *ccb, struct bio *bp,
2142 int *queue_ccb)
2143 {
2144 struct ada_softc *softc;
2145 int error;
2146
2147 error = 0;
2148
2149 if (bp->bio_cmd != BIO_ZONE) {
2150 error = EINVAL;
2151 goto bailout;
2152 }
2153
2154 softc = periph->softc;
2155
2156 switch (bp->bio_zone.zone_cmd) {
2157 case DISK_ZONE_OPEN:
2158 case DISK_ZONE_CLOSE:
2159 case DISK_ZONE_FINISH:
2160 case DISK_ZONE_RWP: {
2161 int zone_flags;
2162 int zone_sa;
2163 uint64_t lba;
2164
2165 zone_sa = ada_zone_bio_to_ata(bp->bio_zone.zone_cmd);
2166 if (zone_sa == -1) {
2167 xpt_print(periph->path, "Cannot translate zone "
2168 "cmd %#x to ATA\n", bp->bio_zone.zone_cmd);
2169 error = EINVAL;
2170 goto bailout;
2171 }
2172
2173 zone_flags = 0;
2174 lba = bp->bio_zone.zone_params.rwp.id;
2175
2176 if (bp->bio_zone.zone_params.rwp.flags &
2177 DISK_ZONE_RWP_FLAG_ALL)
2178 zone_flags |= ZBC_OUT_ALL;
2179
2180 ata_zac_mgmt_out(&ccb->ataio,
2181 /*retries*/ ada_retry_count,
2182 /*cbfcnp*/ adadone,
2183 /*use_ncq*/ (softc->flags &
2184 ADA_FLAG_PIM_ATA_EXT) ? 1 : 0,
2185 /*zm_action*/ zone_sa,
2186 /*zone_id*/ lba,
2187 /*zone_flags*/ zone_flags,
2188 /*sector_count*/ 0,
2189 /*data_ptr*/ NULL,
2190 /*dxfer_len*/ 0,
2191 /*timeout*/ ada_default_timeout * 1000);
2192 *queue_ccb = 1;
2193
2194 break;
2195 }
2196 case DISK_ZONE_REPORT_ZONES: {
2197 uint8_t *rz_ptr;
2198 uint32_t num_entries, alloc_size;
2199 struct disk_zone_report *rep;
2200
2201 rep = &bp->bio_zone.zone_params.report;
2202
2203 num_entries = rep->entries_allocated;
2204 if (num_entries == 0) {
2205 xpt_print(periph->path, "No entries allocated for "
2206 "Report Zones request\n");
2207 error = EINVAL;
2208 goto bailout;
2209 }
2210 alloc_size = sizeof(struct scsi_report_zones_hdr) +
2211 (sizeof(struct scsi_report_zones_desc) * num_entries);
2212 alloc_size = min(alloc_size, softc->disk->d_maxsize);
2213 rz_ptr = malloc(alloc_size, M_ATADA, M_NOWAIT | M_ZERO);
2214 if (rz_ptr == NULL) {
2215 xpt_print(periph->path, "Unable to allocate memory "
2216 "for Report Zones request\n");
2217 error = ENOMEM;
2218 goto bailout;
2219 }
2220
2221 ata_zac_mgmt_in(&ccb->ataio,
2222 /*retries*/ ada_retry_count,
2223 /*cbcfnp*/ adadone,
2224 /*use_ncq*/ (softc->flags &
2225 ADA_FLAG_PIM_ATA_EXT) ? 1 : 0,
2226 /*zm_action*/ ATA_ZM_REPORT_ZONES,
2227 /*zone_id*/ rep->starting_id,
2228 /*zone_flags*/ rep->rep_options,
2229 /*data_ptr*/ rz_ptr,
2230 /*dxfer_len*/ alloc_size,
2231 /*timeout*/ ada_default_timeout * 1000);
2232
2233 /*
2234 * For BIO_ZONE, this isn't normally needed. However, it
2235 * is used by devstat_end_transaction_bio() to determine
2236 * how much data was transferred.
2237 */
2238 /*
2239 * XXX KDM we have a problem. But I'm not sure how to fix
2240 * it. devstat uses bio_bcount - bio_resid to calculate
2241 * the amount of data transferred. The GEOM disk code
2242 * uses bio_length - bio_resid to calculate the amount of
2243 * data in bio_completed. We have different structure
2244 * sizes above and below the ada(4) driver. So, if we
2245 * use the sizes above, the amount transferred won't be
2246 * quite accurate for devstat. If we use different sizes
2247 * for bio_bcount and bio_length (above and below
2248 * respectively), then the residual needs to match one or
2249 * the other. Everything is calculated after the bio
2250 * leaves the driver, so changing the values around isn't
2251 * really an option. For now, just set the count to the
2252 * passed in length. This means that the calculations
2253 * above (e.g. bio_completed) will be correct, but the
2254 * amount of data reported to devstat will be slightly
2255 * under or overstated.
2256 */
2257 bp->bio_bcount = bp->bio_length;
2258
2259 *queue_ccb = 1;
2260
2261 break;
2262 }
2263 case DISK_ZONE_GET_PARAMS: {
2264 struct disk_zone_disk_params *params;
2265
2266 params = &bp->bio_zone.zone_params.disk_params;
2267 bzero(params, sizeof(*params));
2268
2269 switch (softc->zone_mode) {
2270 case ADA_ZONE_DRIVE_MANAGED:
2271 params->zone_mode = DISK_ZONE_MODE_DRIVE_MANAGED;
2272 break;
2273 case ADA_ZONE_HOST_AWARE:
2274 params->zone_mode = DISK_ZONE_MODE_HOST_AWARE;
2275 break;
2276 case ADA_ZONE_HOST_MANAGED:
2277 params->zone_mode = DISK_ZONE_MODE_HOST_MANAGED;
2278 break;
2279 default:
2280 case ADA_ZONE_NONE:
2281 params->zone_mode = DISK_ZONE_MODE_NONE;
2282 break;
2283 }
2284
2285 if (softc->zone_flags & ADA_ZONE_FLAG_URSWRZ)
2286 params->flags |= DISK_ZONE_DISK_URSWRZ;
2287
2288 if (softc->zone_flags & ADA_ZONE_FLAG_OPT_SEQ_SET) {
2289 params->optimal_seq_zones = softc->optimal_seq_zones;
2290 params->flags |= DISK_ZONE_OPT_SEQ_SET;
2291 }
2292
2293 if (softc->zone_flags & ADA_ZONE_FLAG_OPT_NONSEQ_SET) {
2294 params->optimal_nonseq_zones =
2295 softc->optimal_nonseq_zones;
2296 params->flags |= DISK_ZONE_OPT_NONSEQ_SET;
2297 }
2298
2299 if (softc->zone_flags & ADA_ZONE_FLAG_MAX_SEQ_SET) {
2300 params->max_seq_zones = softc->max_seq_zones;
2301 params->flags |= DISK_ZONE_MAX_SEQ_SET;
2302 }
2303 if (softc->zone_flags & ADA_ZONE_FLAG_RZ_SUP)
2304 params->flags |= DISK_ZONE_RZ_SUP;
2305
2306 if (softc->zone_flags & ADA_ZONE_FLAG_OPEN_SUP)
2307 params->flags |= DISK_ZONE_OPEN_SUP;
2308
2309 if (softc->zone_flags & ADA_ZONE_FLAG_CLOSE_SUP)
2310 params->flags |= DISK_ZONE_CLOSE_SUP;
2311
2312 if (softc->zone_flags & ADA_ZONE_FLAG_FINISH_SUP)
2313 params->flags |= DISK_ZONE_FINISH_SUP;
2314
2315 if (softc->zone_flags & ADA_ZONE_FLAG_RWP_SUP)
2316 params->flags |= DISK_ZONE_RWP_SUP;
2317 break;
2318 }
2319 default:
2320 break;
2321 }
2322 bailout:
2323 return (error);
2324 }
2325
2326 static void
adastart(struct cam_periph * periph,union ccb * start_ccb)2327 adastart(struct cam_periph *periph, union ccb *start_ccb)
2328 {
2329 struct ada_softc *softc = (struct ada_softc *)periph->softc;
2330 struct ccb_ataio *ataio = &start_ccb->ataio;
2331
2332 CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("adastart\n"));
2333
2334 switch (softc->state) {
2335 case ADA_STATE_NORMAL:
2336 {
2337 struct bio *bp;
2338 uint8_t tag_code;
2339
2340 bp = cam_iosched_next_bio(softc->cam_iosched);
2341 if (bp == NULL) {
2342 xpt_release_ccb(start_ccb);
2343 break;
2344 }
2345
2346 if ((bp->bio_flags & BIO_ORDERED) != 0 ||
2347 (bp->bio_cmd != BIO_DELETE && (softc->flags & ADA_FLAG_NEED_OTAG) != 0)) {
2348 softc->flags &= ~ADA_FLAG_NEED_OTAG;
2349 softc->flags |= ADA_FLAG_WAS_OTAG;
2350 tag_code = 0;
2351 } else {
2352 tag_code = 1;
2353 }
2354 switch (bp->bio_cmd) {
2355 case BIO_WRITE:
2356 case BIO_READ:
2357 {
2358 uint64_t lba = bp->bio_pblkno;
2359 uint16_t count = bp->bio_bcount / softc->params.secsize;
2360 void *data_ptr;
2361 int rw_op;
2362
2363 if (bp->bio_cmd == BIO_WRITE) {
2364 softc->flags |= ADA_FLAG_DIRTY;
2365 rw_op = CAM_DIR_OUT;
2366 } else {
2367 rw_op = CAM_DIR_IN;
2368 }
2369
2370 data_ptr = bp->bio_data;
2371 if ((bp->bio_flags & (BIO_UNMAPPED|BIO_VLIST)) != 0) {
2372 rw_op |= CAM_DATA_BIO;
2373 data_ptr = bp;
2374 }
2375
2376 #ifdef CAM_TEST_FAILURE
2377 int fail = 0;
2378
2379 /*
2380 * Support the failure ioctls. If the command is a
2381 * read, and there are pending forced read errors, or
2382 * if a write and pending write errors, then fail this
2383 * operation with EIO. This is useful for testing
2384 * purposes. Also, support having every Nth read fail.
2385 *
2386 * This is a rather blunt tool.
2387 */
2388 if (bp->bio_cmd == BIO_READ) {
2389 if (softc->force_read_error) {
2390 softc->force_read_error--;
2391 fail = 1;
2392 }
2393 if (softc->periodic_read_error > 0) {
2394 if (++softc->periodic_read_count >=
2395 softc->periodic_read_error) {
2396 softc->periodic_read_count = 0;
2397 fail = 1;
2398 }
2399 }
2400 } else {
2401 if (softc->force_write_error) {
2402 softc->force_write_error--;
2403 fail = 1;
2404 }
2405 }
2406 if (fail) {
2407 biofinish(bp, NULL, EIO);
2408 xpt_release_ccb(start_ccb);
2409 adaschedule(periph);
2410 return;
2411 }
2412 #endif
2413 KASSERT((bp->bio_flags & BIO_UNMAPPED) == 0 ||
2414 round_page(bp->bio_bcount + bp->bio_ma_offset) /
2415 PAGE_SIZE == bp->bio_ma_n,
2416 ("Short bio %p", bp));
2417 cam_fill_ataio(ataio,
2418 ada_retry_count,
2419 adadone,
2420 rw_op,
2421 0,
2422 data_ptr,
2423 bp->bio_bcount,
2424 ada_default_timeout*1000);
2425
2426 if ((softc->flags & ADA_FLAG_CAN_NCQ) && tag_code) {
2427 if (bp->bio_cmd == BIO_READ) {
2428 ata_ncq_cmd(ataio, ATA_READ_FPDMA_QUEUED,
2429 lba, count);
2430 } else {
2431 ata_ncq_cmd(ataio, ATA_WRITE_FPDMA_QUEUED,
2432 lba, count);
2433 }
2434 } else if ((softc->flags & ADA_FLAG_CAN_48BIT) &&
2435 (lba + count >= ATA_MAX_28BIT_LBA ||
2436 count > 256)) {
2437 if (softc->flags & ADA_FLAG_CAN_DMA48) {
2438 if (bp->bio_cmd == BIO_READ) {
2439 ata_48bit_cmd(ataio, ATA_READ_DMA48,
2440 0, lba, count);
2441 } else {
2442 ata_48bit_cmd(ataio, ATA_WRITE_DMA48,
2443 0, lba, count);
2444 }
2445 } else {
2446 if (bp->bio_cmd == BIO_READ) {
2447 ata_48bit_cmd(ataio, ATA_READ_MUL48,
2448 0, lba, count);
2449 } else {
2450 ata_48bit_cmd(ataio, ATA_WRITE_MUL48,
2451 0, lba, count);
2452 }
2453 }
2454 } else {
2455 if (count == 256)
2456 count = 0;
2457 if (softc->flags & ADA_FLAG_CAN_DMA) {
2458 if (bp->bio_cmd == BIO_READ) {
2459 ata_28bit_cmd(ataio, ATA_READ_DMA,
2460 0, lba, count);
2461 } else {
2462 ata_28bit_cmd(ataio, ATA_WRITE_DMA,
2463 0, lba, count);
2464 }
2465 } else {
2466 if (bp->bio_cmd == BIO_READ) {
2467 ata_28bit_cmd(ataio, ATA_READ_MUL,
2468 0, lba, count);
2469 } else {
2470 ata_28bit_cmd(ataio, ATA_WRITE_MUL,
2471 0, lba, count);
2472 }
2473 }
2474 }
2475 break;
2476 }
2477 case BIO_DELETE:
2478 switch (softc->delete_method) {
2479 case ADA_DELETE_NCQ_DSM_TRIM:
2480 ada_ncq_dsmtrim(softc, bp, ataio);
2481 break;
2482 case ADA_DELETE_DSM_TRIM:
2483 ada_dsmtrim(softc, bp, ataio);
2484 break;
2485 case ADA_DELETE_CFA_ERASE:
2486 ada_cfaerase(softc, bp, ataio);
2487 break;
2488 default:
2489 biofinish(bp, NULL, EOPNOTSUPP);
2490 xpt_release_ccb(start_ccb);
2491 adaschedule(periph);
2492 return;
2493 }
2494 start_ccb->ccb_h.ccb_state = ADA_CCB_TRIM;
2495 start_ccb->ccb_h.flags |= CAM_UNLOCKED;
2496 cam_iosched_submit_trim(softc->cam_iosched);
2497 goto out;
2498 case BIO_FLUSH:
2499 cam_fill_ataio(ataio,
2500 1,
2501 adadone,
2502 CAM_DIR_NONE,
2503 0,
2504 NULL,
2505 0,
2506 ada_default_timeout*1000);
2507
2508 if (softc->flags & ADA_FLAG_CAN_48BIT)
2509 ata_48bit_cmd(ataio, ATA_FLUSHCACHE48, 0, 0, 0);
2510 else
2511 ata_28bit_cmd(ataio, ATA_FLUSHCACHE, 0, 0, 0);
2512 break;
2513 case BIO_ZONE: {
2514 int error, queue_ccb;
2515
2516 queue_ccb = 0;
2517
2518 error = ada_zone_cmd(periph, start_ccb, bp, &queue_ccb);
2519 if ((error != 0)
2520 || (queue_ccb == 0)) {
2521 /*
2522 * g_io_deliver will recurisvely call start
2523 * routine for ENOMEM, so drop the periph
2524 * lock to allow that recursion.
2525 */
2526 if (error == ENOMEM)
2527 cam_periph_unlock(periph);
2528 biofinish(bp, NULL, error);
2529 if (error == ENOMEM)
2530 cam_periph_lock(periph);
2531 xpt_release_ccb(start_ccb);
2532 return;
2533 }
2534 break;
2535 }
2536 default:
2537 biofinish(bp, NULL, EOPNOTSUPP);
2538 xpt_release_ccb(start_ccb);
2539 return;
2540 }
2541 start_ccb->ccb_h.ccb_state = ADA_CCB_BUFFER_IO;
2542 start_ccb->ccb_h.flags |= CAM_UNLOCKED;
2543 out:
2544 start_ccb->ccb_h.ccb_bp = bp;
2545 softc->outstanding_cmds++;
2546 softc->refcount++;
2547 cam_periph_unlock(periph);
2548 xpt_action(start_ccb);
2549 cam_periph_lock(periph);
2550
2551 /* May have more work to do, so ensure we stay scheduled */
2552 adaschedule(periph);
2553 break;
2554 }
2555 case ADA_STATE_RAHEAD:
2556 case ADA_STATE_WCACHE:
2557 {
2558 cam_fill_ataio(ataio,
2559 1,
2560 adadone,
2561 CAM_DIR_NONE,
2562 0,
2563 NULL,
2564 0,
2565 ada_default_timeout*1000);
2566
2567 if (softc->state == ADA_STATE_RAHEAD) {
2568 ata_28bit_cmd(ataio, ATA_SETFEATURES, ADA_RA ?
2569 ATA_SF_ENAB_RCACHE : ATA_SF_DIS_RCACHE, 0, 0);
2570 start_ccb->ccb_h.ccb_state = ADA_CCB_RAHEAD;
2571 } else {
2572 ata_28bit_cmd(ataio, ATA_SETFEATURES, ADA_WC ?
2573 ATA_SF_ENAB_WCACHE : ATA_SF_DIS_WCACHE, 0, 0);
2574 start_ccb->ccb_h.ccb_state = ADA_CCB_WCACHE;
2575 }
2576 start_ccb->ccb_h.flags |= CAM_DEV_QFREEZE;
2577 xpt_action(start_ccb);
2578 break;
2579 }
2580 case ADA_STATE_LOGDIR:
2581 {
2582 struct ata_gp_log_dir *log_dir;
2583
2584 if ((softc->flags & ADA_FLAG_CAN_LOG) == 0) {
2585 adaprobedone(periph, start_ccb);
2586 break;
2587 }
2588
2589 log_dir = malloc(sizeof(*log_dir), M_ATADA, M_NOWAIT|M_ZERO);
2590 if (log_dir == NULL) {
2591 xpt_print(periph->path, "Couldn't malloc log_dir "
2592 "data\n");
2593 softc->state = ADA_STATE_NORMAL;
2594 xpt_release_ccb(start_ccb);
2595 break;
2596 }
2597
2598 ata_read_log(ataio,
2599 /*retries*/1,
2600 /*cbfcnp*/adadone,
2601 /*log_address*/ ATA_LOG_DIRECTORY,
2602 /*page_number*/ 0,
2603 /*block_count*/ 1,
2604 /*protocol*/ softc->flags & ADA_FLAG_CAN_DMA ?
2605 CAM_ATAIO_DMA : 0,
2606 /*data_ptr*/ (uint8_t *)log_dir,
2607 /*dxfer_len*/sizeof(*log_dir),
2608 /*timeout*/ada_default_timeout*1000);
2609
2610 start_ccb->ccb_h.ccb_state = ADA_CCB_LOGDIR;
2611 xpt_action(start_ccb);
2612 break;
2613 }
2614 case ADA_STATE_IDDIR:
2615 {
2616 struct ata_identify_log_pages *id_dir;
2617
2618 id_dir = malloc(sizeof(*id_dir), M_ATADA, M_NOWAIT | M_ZERO);
2619 if (id_dir == NULL) {
2620 xpt_print(periph->path, "Couldn't malloc id_dir "
2621 "data\n");
2622 adaprobedone(periph, start_ccb);
2623 break;
2624 }
2625
2626 ata_read_log(ataio,
2627 /*retries*/1,
2628 /*cbfcnp*/adadone,
2629 /*log_address*/ ATA_IDENTIFY_DATA_LOG,
2630 /*page_number*/ ATA_IDL_PAGE_LIST,
2631 /*block_count*/ 1,
2632 /*protocol*/ softc->flags & ADA_FLAG_CAN_DMA ?
2633 CAM_ATAIO_DMA : 0,
2634 /*data_ptr*/ (uint8_t *)id_dir,
2635 /*dxfer_len*/ sizeof(*id_dir),
2636 /*timeout*/ada_default_timeout*1000);
2637
2638 start_ccb->ccb_h.ccb_state = ADA_CCB_IDDIR;
2639 xpt_action(start_ccb);
2640 break;
2641 }
2642 case ADA_STATE_SUP_CAP:
2643 {
2644 struct ata_identify_log_sup_cap *sup_cap;
2645
2646 sup_cap = malloc(sizeof(*sup_cap), M_ATADA, M_NOWAIT|M_ZERO);
2647 if (sup_cap == NULL) {
2648 xpt_print(periph->path, "Couldn't malloc sup_cap "
2649 "data\n");
2650 adaprobedone(periph, start_ccb);
2651 break;
2652 }
2653
2654 ata_read_log(ataio,
2655 /*retries*/1,
2656 /*cbfcnp*/adadone,
2657 /*log_address*/ ATA_IDENTIFY_DATA_LOG,
2658 /*page_number*/ ATA_IDL_SUP_CAP,
2659 /*block_count*/ 1,
2660 /*protocol*/ softc->flags & ADA_FLAG_CAN_DMA ?
2661 CAM_ATAIO_DMA : 0,
2662 /*data_ptr*/ (uint8_t *)sup_cap,
2663 /*dxfer_len*/ sizeof(*sup_cap),
2664 /*timeout*/ada_default_timeout*1000);
2665
2666 start_ccb->ccb_h.ccb_state = ADA_CCB_SUP_CAP;
2667 xpt_action(start_ccb);
2668 break;
2669 }
2670 case ADA_STATE_ZONE:
2671 {
2672 struct ata_zoned_info_log *ata_zone;
2673
2674 ata_zone = malloc(sizeof(*ata_zone), M_ATADA, M_NOWAIT|M_ZERO);
2675 if (ata_zone == NULL) {
2676 xpt_print(periph->path, "Couldn't malloc ata_zone "
2677 "data\n");
2678 adaprobedone(periph, start_ccb);
2679 break;
2680 }
2681
2682 ata_read_log(ataio,
2683 /*retries*/1,
2684 /*cbfcnp*/adadone,
2685 /*log_address*/ ATA_IDENTIFY_DATA_LOG,
2686 /*page_number*/ ATA_IDL_ZDI,
2687 /*block_count*/ 1,
2688 /*protocol*/ softc->flags & ADA_FLAG_CAN_DMA ?
2689 CAM_ATAIO_DMA : 0,
2690 /*data_ptr*/ (uint8_t *)ata_zone,
2691 /*dxfer_len*/ sizeof(*ata_zone),
2692 /*timeout*/ada_default_timeout*1000);
2693
2694 start_ccb->ccb_h.ccb_state = ADA_CCB_ZONE;
2695 xpt_action(start_ccb);
2696 break;
2697 }
2698 }
2699 }
2700
2701 static void
adaprobedone(struct cam_periph * periph,union ccb * ccb)2702 adaprobedone(struct cam_periph *periph, union ccb *ccb)
2703 {
2704 struct ada_softc *softc;
2705
2706 softc = (struct ada_softc *)periph->softc;
2707
2708 /*
2709 * Since our peripheral may be invalidated by an error we must release
2710 * our CCB before releasing the reference on the peripheral. The
2711 * peripheral will only go away once the last reference is removed, and
2712 * we need it around for the CCB release operation.
2713 */
2714 if (ccb != NULL)
2715 xpt_release_ccb(ccb);
2716
2717 softc->state = ADA_STATE_NORMAL;
2718 softc->flags |= ADA_FLAG_PROBED;
2719 adaschedule(periph);
2720 if ((softc->flags & ADA_FLAG_ANNOUNCED) == 0) {
2721 softc->flags |= ADA_FLAG_ANNOUNCED;
2722
2723 /*
2724 * We'll release this reference once GEOM calls us back via
2725 * adadiskgonecb(), telling us that our provider has been freed.
2726 */
2727 if (cam_periph_acquire(periph) == 0)
2728 disk_create(softc->disk, DISK_VERSION);
2729
2730 cam_periph_release_boot(periph);
2731 }
2732 cam_periph_release_locked(periph);
2733 }
2734
2735 static void
adazonedone(struct cam_periph * periph,union ccb * ccb)2736 adazonedone(struct cam_periph *periph, union ccb *ccb)
2737 {
2738 struct bio *bp;
2739
2740 bp = (struct bio *)ccb->ccb_h.ccb_bp;
2741
2742 switch (bp->bio_zone.zone_cmd) {
2743 case DISK_ZONE_OPEN:
2744 case DISK_ZONE_CLOSE:
2745 case DISK_ZONE_FINISH:
2746 case DISK_ZONE_RWP:
2747 break;
2748 case DISK_ZONE_REPORT_ZONES: {
2749 uint32_t avail_len;
2750 struct disk_zone_report *rep;
2751 struct scsi_report_zones_hdr *hdr;
2752 struct scsi_report_zones_desc *desc;
2753 struct disk_zone_rep_entry *entry;
2754 uint32_t hdr_len, num_avail;
2755 uint32_t num_to_fill, i;
2756
2757 rep = &bp->bio_zone.zone_params.report;
2758 avail_len = ccb->ataio.dxfer_len - ccb->ataio.resid;
2759 /*
2760 * Note that bio_resid isn't normally used for zone
2761 * commands, but it is used by devstat_end_transaction_bio()
2762 * to determine how much data was transferred. Because
2763 * the size of the SCSI/ATA data structures is different
2764 * than the size of the BIO interface structures, the
2765 * amount of data actually transferred from the drive will
2766 * be different than the amount of data transferred to
2767 * the user.
2768 */
2769 hdr = (struct scsi_report_zones_hdr *)ccb->ataio.data_ptr;
2770 if (avail_len < sizeof(*hdr)) {
2771 /*
2772 * Is there a better error than EIO here? We asked
2773 * for at least the header, and we got less than
2774 * that.
2775 */
2776 bp->bio_error = EIO;
2777 bp->bio_flags |= BIO_ERROR;
2778 bp->bio_resid = bp->bio_bcount;
2779 break;
2780 }
2781
2782 hdr_len = le32dec(hdr->length);
2783 if (hdr_len > 0)
2784 rep->entries_available = hdr_len / sizeof(*desc);
2785 else
2786 rep->entries_available = 0;
2787 /*
2788 * NOTE: using the same values for the BIO version of the
2789 * same field as the SCSI/ATA values. This means we could
2790 * get some additional values that aren't defined in bio.h
2791 * if more values of the same field are defined later.
2792 */
2793 rep->header.same = hdr->byte4 & SRZ_SAME_MASK;
2794 rep->header.maximum_lba = le64dec(hdr->maximum_lba);
2795 /*
2796 * If the drive reports no entries that match the query,
2797 * we're done.
2798 */
2799 if (hdr_len == 0) {
2800 rep->entries_filled = 0;
2801 bp->bio_resid = bp->bio_bcount;
2802 break;
2803 }
2804
2805 num_avail = min((avail_len - sizeof(*hdr)) / sizeof(*desc),
2806 hdr_len / sizeof(*desc));
2807 /*
2808 * If the drive didn't return any data, then we're done.
2809 */
2810 if (num_avail == 0) {
2811 rep->entries_filled = 0;
2812 bp->bio_resid = bp->bio_bcount;
2813 break;
2814 }
2815
2816 num_to_fill = min(num_avail, rep->entries_allocated);
2817 /*
2818 * If the user didn't allocate any entries for us to fill,
2819 * we're done.
2820 */
2821 if (num_to_fill == 0) {
2822 rep->entries_filled = 0;
2823 bp->bio_resid = bp->bio_bcount;
2824 break;
2825 }
2826
2827 for (i = 0, desc = &hdr->desc_list[0], entry=&rep->entries[0];
2828 i < num_to_fill; i++, desc++, entry++) {
2829 /*
2830 * NOTE: we're mapping the values here directly
2831 * from the SCSI/ATA bit definitions to the bio.h
2832 * definitions. There is also a warning in
2833 * disk_zone.h, but the impact is that if
2834 * additional values are added in the SCSI/ATA
2835 * specs these will be visible to consumers of
2836 * this interface.
2837 */
2838 entry->zone_type = desc->zone_type & SRZ_TYPE_MASK;
2839 entry->zone_condition =
2840 (desc->zone_flags & SRZ_ZONE_COND_MASK) >>
2841 SRZ_ZONE_COND_SHIFT;
2842 entry->zone_flags |= desc->zone_flags &
2843 (SRZ_ZONE_NON_SEQ|SRZ_ZONE_RESET);
2844 entry->zone_length = le64dec(desc->zone_length);
2845 entry->zone_start_lba = le64dec(desc->zone_start_lba);
2846 entry->write_pointer_lba =
2847 le64dec(desc->write_pointer_lba);
2848 }
2849 rep->entries_filled = num_to_fill;
2850 /*
2851 * Note that this residual is accurate from the user's
2852 * standpoint, but the amount transferred isn't accurate
2853 * from the standpoint of what actually came back from the
2854 * drive.
2855 */
2856 bp->bio_resid = bp->bio_bcount - (num_to_fill * sizeof(*entry));
2857 break;
2858 }
2859 case DISK_ZONE_GET_PARAMS:
2860 default:
2861 /*
2862 * In theory we should not get a GET_PARAMS bio, since it
2863 * should be handled without queueing the command to the
2864 * drive.
2865 */
2866 panic("%s: Invalid zone command %d", __func__,
2867 bp->bio_zone.zone_cmd);
2868 break;
2869 }
2870
2871 if (bp->bio_zone.zone_cmd == DISK_ZONE_REPORT_ZONES)
2872 free(ccb->ataio.data_ptr, M_ATADA);
2873 }
2874
2875 static void
adadone(struct cam_periph * periph,union ccb * done_ccb)2876 adadone(struct cam_periph *periph, union ccb *done_ccb)
2877 {
2878 struct ada_softc *softc;
2879 struct ccb_ataio *ataio;
2880 struct cam_path *path;
2881 uint32_t priority;
2882 int state;
2883
2884 softc = (struct ada_softc *)periph->softc;
2885 ataio = &done_ccb->ataio;
2886 path = done_ccb->ccb_h.path;
2887 priority = done_ccb->ccb_h.pinfo.priority;
2888
2889 CAM_DEBUG(path, CAM_DEBUG_TRACE, ("adadone\n"));
2890
2891 state = ataio->ccb_h.ccb_state & ADA_CCB_TYPE_MASK;
2892 switch (state) {
2893 case ADA_CCB_BUFFER_IO:
2894 case ADA_CCB_TRIM:
2895 {
2896 struct bio *bp;
2897 int error;
2898
2899 cam_periph_lock(periph);
2900 bp = (struct bio *)done_ccb->ccb_h.ccb_bp;
2901 if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
2902 error = adaerror(done_ccb, CAM_RETRY_SELTO, 0);
2903 if (error == ERESTART) {
2904 /* A retry was scheduled, so just return. */
2905 cam_periph_unlock(periph);
2906 return;
2907 }
2908 if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0)
2909 cam_release_devq(path,
2910 /*relsim_flags*/0,
2911 /*reduction*/0,
2912 /*timeout*/0,
2913 /*getcount_only*/0);
2914 /*
2915 * If we get an error on an NCQ DSM TRIM, fall back
2916 * to a non-NCQ DSM TRIM forever. Please note that if
2917 * CAN_NCQ_TRIM is set, CAN_TRIM is necessarily set too.
2918 * However, for this one trim, we treat it as advisory
2919 * and return success up the stack.
2920 */
2921 if (state == ADA_CCB_TRIM &&
2922 error != 0 &&
2923 (softc->flags & ADA_FLAG_CAN_NCQ_TRIM) != 0) {
2924 softc->flags &= ~ADA_FLAG_CAN_NCQ_TRIM;
2925 error = 0;
2926 adasetdeletemethod(softc);
2927 }
2928 } else {
2929 if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0)
2930 panic("REQ_CMP with QFRZN");
2931
2932 error = 0;
2933 }
2934 bp->bio_error = error;
2935 if (error != 0) {
2936 bp->bio_resid = bp->bio_bcount;
2937 bp->bio_flags |= BIO_ERROR;
2938 } else {
2939 if (bp->bio_cmd == BIO_ZONE)
2940 adazonedone(periph, done_ccb);
2941 else if (state == ADA_CCB_TRIM)
2942 bp->bio_resid = 0;
2943 else
2944 bp->bio_resid = ataio->resid;
2945
2946 if ((bp->bio_resid > 0)
2947 && (bp->bio_cmd != BIO_ZONE))
2948 bp->bio_flags |= BIO_ERROR;
2949 }
2950 softc->outstanding_cmds--;
2951 if (softc->outstanding_cmds == 0)
2952 softc->flags |= ADA_FLAG_WAS_OTAG;
2953
2954 /*
2955 * We need to call cam_iosched before we call biodone so that we
2956 * don't measure any activity that happens in the completion
2957 * routine, which in the case of sendfile can be quite
2958 * extensive. Release the periph refcount taken in adastart()
2959 * for each CCB.
2960 */
2961 cam_iosched_bio_complete(softc->cam_iosched, bp, done_ccb);
2962 xpt_release_ccb(done_ccb);
2963 KASSERT(softc->refcount >= 1, ("adadone softc %p refcount %d", softc, softc->refcount));
2964 softc->refcount--;
2965 if (state == ADA_CCB_TRIM) {
2966 TAILQ_HEAD(, bio) queue;
2967 struct bio *bp1;
2968
2969 TAILQ_INIT(&queue);
2970 TAILQ_CONCAT(&queue, &softc->trim_req.bps, bio_queue);
2971 /*
2972 * Normally, the xpt_release_ccb() above would make sure
2973 * that when we have more work to do, that work would
2974 * get kicked off. However, we specifically keep
2975 * trim_running set to 0 before the call above to allow
2976 * other I/O to progress when many BIO_DELETE requests
2977 * are pushed down. We set trim_running to 0 and call
2978 * daschedule again so that we don't stall if there are
2979 * no other I/Os pending apart from BIO_DELETEs.
2980 */
2981 cam_iosched_trim_done(softc->cam_iosched);
2982 adaschedule(periph);
2983 cam_periph_unlock(periph);
2984 while ((bp1 = TAILQ_FIRST(&queue)) != NULL) {
2985 TAILQ_REMOVE(&queue, bp1, bio_queue);
2986 bp1->bio_error = error;
2987 if (error != 0) {
2988 bp1->bio_flags |= BIO_ERROR;
2989 bp1->bio_resid = bp1->bio_bcount;
2990 } else
2991 bp1->bio_resid = 0;
2992 biodone(bp1);
2993 }
2994 } else {
2995 adaschedule(periph);
2996 cam_periph_unlock(periph);
2997 biodone(bp);
2998 }
2999 return;
3000 }
3001 case ADA_CCB_RAHEAD:
3002 {
3003 if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
3004 if (adaerror(done_ccb, 0, 0) == ERESTART) {
3005 /* Drop freeze taken due to CAM_DEV_QFREEZE */
3006 cam_release_devq(path, 0, 0, 0, FALSE);
3007 return;
3008 } else if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
3009 cam_release_devq(path,
3010 /*relsim_flags*/0,
3011 /*reduction*/0,
3012 /*timeout*/0,
3013 /*getcount_only*/0);
3014 }
3015 }
3016
3017 xpt_release_ccb(done_ccb);
3018 softc->state = ADA_STATE_WCACHE;
3019 xpt_schedule(periph, priority);
3020 /* Drop freeze taken due to CAM_DEV_QFREEZE */
3021 cam_release_devq(path, 0, 0, 0, FALSE);
3022 return;
3023 }
3024 case ADA_CCB_WCACHE:
3025 {
3026 if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
3027 if (adaerror(done_ccb, 0, 0) == ERESTART) {
3028 /* Drop freeze taken due to CAM_DEV_QFREEZE */
3029 cam_release_devq(path, 0, 0, 0, FALSE);
3030 return;
3031 } else if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
3032 cam_release_devq(path,
3033 /*relsim_flags*/0,
3034 /*reduction*/0,
3035 /*timeout*/0,
3036 /*getcount_only*/0);
3037 }
3038 }
3039
3040 /* Drop freeze taken due to CAM_DEV_QFREEZE */
3041 cam_release_devq(path, 0, 0, 0, FALSE);
3042
3043 if ((softc->flags & ADA_FLAG_CAN_LOG)
3044 && (softc->zone_mode != ADA_ZONE_NONE)) {
3045 xpt_release_ccb(done_ccb);
3046 softc->state = ADA_STATE_LOGDIR;
3047 xpt_schedule(periph, priority);
3048 } else {
3049 adaprobedone(periph, done_ccb);
3050 }
3051 return;
3052 }
3053 case ADA_CCB_LOGDIR:
3054 {
3055 int error;
3056
3057 if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
3058 error = 0;
3059 softc->valid_logdir_len = 0;
3060 bzero(&softc->ata_logdir, sizeof(softc->ata_logdir));
3061 softc->valid_logdir_len =
3062 ataio->dxfer_len - ataio->resid;
3063 if (softc->valid_logdir_len > 0)
3064 bcopy(ataio->data_ptr, &softc->ata_logdir,
3065 min(softc->valid_logdir_len,
3066 sizeof(softc->ata_logdir)));
3067 /*
3068 * Figure out whether the Identify Device log is
3069 * supported. The General Purpose log directory
3070 * has a header, and lists the number of pages
3071 * available for each GP log identified by the
3072 * offset into the list.
3073 */
3074 if ((softc->valid_logdir_len >=
3075 ((ATA_IDENTIFY_DATA_LOG + 1) * sizeof(uint16_t)))
3076 && (le16dec(softc->ata_logdir.header) ==
3077 ATA_GP_LOG_DIR_VERSION)
3078 && (le16dec(&softc->ata_logdir.num_pages[
3079 (ATA_IDENTIFY_DATA_LOG *
3080 sizeof(uint16_t)) - sizeof(uint16_t)]) > 0)){
3081 softc->flags |= ADA_FLAG_CAN_IDLOG;
3082 } else {
3083 softc->flags &= ~ADA_FLAG_CAN_IDLOG;
3084 }
3085 } else {
3086 error = adaerror(done_ccb, CAM_RETRY_SELTO,
3087 SF_RETRY_UA|SF_NO_PRINT);
3088 if (error == ERESTART)
3089 return;
3090 else if (error != 0) {
3091 /*
3092 * If we can't get the ATA log directory,
3093 * then ATA logs are effectively not
3094 * supported even if the bit is set in the
3095 * identify data.
3096 */
3097 softc->flags &= ~(ADA_FLAG_CAN_LOG |
3098 ADA_FLAG_CAN_IDLOG);
3099 if ((done_ccb->ccb_h.status &
3100 CAM_DEV_QFRZN) != 0) {
3101 /* Don't wedge this device's queue */
3102 cam_release_devq(done_ccb->ccb_h.path,
3103 /*relsim_flags*/0,
3104 /*reduction*/0,
3105 /*timeout*/0,
3106 /*getcount_only*/0);
3107 }
3108 }
3109 }
3110
3111 free(ataio->data_ptr, M_ATADA);
3112
3113 if ((error == 0)
3114 && (softc->flags & ADA_FLAG_CAN_IDLOG)) {
3115 softc->state = ADA_STATE_IDDIR;
3116 xpt_release_ccb(done_ccb);
3117 xpt_schedule(periph, priority);
3118 } else
3119 adaprobedone(periph, done_ccb);
3120
3121 return;
3122 }
3123 case ADA_CCB_IDDIR: {
3124 int error;
3125
3126 if ((ataio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
3127 off_t entries_offset, max_entries;
3128 error = 0;
3129
3130 softc->valid_iddir_len = 0;
3131 bzero(&softc->ata_iddir, sizeof(softc->ata_iddir));
3132 softc->flags &= ~(ADA_FLAG_CAN_SUPCAP |
3133 ADA_FLAG_CAN_ZONE);
3134 softc->valid_iddir_len =
3135 ataio->dxfer_len - ataio->resid;
3136 if (softc->valid_iddir_len > 0)
3137 bcopy(ataio->data_ptr, &softc->ata_iddir,
3138 min(softc->valid_iddir_len,
3139 sizeof(softc->ata_iddir)));
3140
3141 entries_offset =
3142 __offsetof(struct ata_identify_log_pages,entries);
3143 max_entries = softc->valid_iddir_len - entries_offset;
3144 if ((softc->valid_iddir_len > (entries_offset + 1))
3145 && (le64dec(softc->ata_iddir.header) ==
3146 ATA_IDLOG_REVISION)
3147 && (softc->ata_iddir.entry_count > 0)) {
3148 int num_entries, i;
3149
3150 num_entries = softc->ata_iddir.entry_count;
3151 num_entries = min(num_entries,
3152 softc->valid_iddir_len - entries_offset);
3153 for (i = 0; i < num_entries &&
3154 i < max_entries; i++) {
3155 if (softc->ata_iddir.entries[i] ==
3156 ATA_IDL_SUP_CAP)
3157 softc->flags |=
3158 ADA_FLAG_CAN_SUPCAP;
3159 else if (softc->ata_iddir.entries[i]==
3160 ATA_IDL_ZDI)
3161 softc->flags |=
3162 ADA_FLAG_CAN_ZONE;
3163
3164 if ((softc->flags &
3165 ADA_FLAG_CAN_SUPCAP)
3166 && (softc->flags &
3167 ADA_FLAG_CAN_ZONE))
3168 break;
3169 }
3170 }
3171 } else {
3172 error = adaerror(done_ccb, CAM_RETRY_SELTO,
3173 SF_RETRY_UA|SF_NO_PRINT);
3174 if (error == ERESTART)
3175 return;
3176 else if (error != 0) {
3177 /*
3178 * If we can't get the ATA Identify Data log
3179 * directory, then it effectively isn't
3180 * supported even if the ATA Log directory
3181 * a non-zero number of pages present for
3182 * this log.
3183 */
3184 softc->flags &= ~ADA_FLAG_CAN_IDLOG;
3185 if ((done_ccb->ccb_h.status &
3186 CAM_DEV_QFRZN) != 0) {
3187 /* Don't wedge this device's queue */
3188 cam_release_devq(done_ccb->ccb_h.path,
3189 /*relsim_flags*/0,
3190 /*reduction*/0,
3191 /*timeout*/0,
3192 /*getcount_only*/0);
3193 }
3194 }
3195 }
3196
3197 free(ataio->data_ptr, M_ATADA);
3198
3199 if ((error == 0)
3200 && (softc->flags & ADA_FLAG_CAN_SUPCAP)) {
3201 softc->state = ADA_STATE_SUP_CAP;
3202 xpt_release_ccb(done_ccb);
3203 xpt_schedule(periph, priority);
3204 } else
3205 adaprobedone(periph, done_ccb);
3206 return;
3207 }
3208 case ADA_CCB_SUP_CAP: {
3209 int error;
3210
3211 if ((ataio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
3212 uint32_t valid_len;
3213 size_t needed_size;
3214 struct ata_identify_log_sup_cap *sup_cap;
3215 error = 0;
3216
3217 sup_cap = (struct ata_identify_log_sup_cap *)
3218 ataio->data_ptr;
3219 valid_len = ataio->dxfer_len - ataio->resid;
3220 needed_size =
3221 __offsetof(struct ata_identify_log_sup_cap,
3222 sup_zac_cap) + 1 + sizeof(sup_cap->sup_zac_cap);
3223 if (valid_len >= needed_size) {
3224 uint64_t zoned, zac_cap;
3225
3226 zoned = le64dec(sup_cap->zoned_cap);
3227 if (zoned & ATA_ZONED_VALID) {
3228 /*
3229 * This should have already been
3230 * set, because this is also in the
3231 * ATA identify data.
3232 */
3233 if ((zoned & ATA_ZONED_MASK) ==
3234 ATA_SUPPORT_ZONE_HOST_AWARE)
3235 softc->zone_mode =
3236 ADA_ZONE_HOST_AWARE;
3237 else if ((zoned & ATA_ZONED_MASK) ==
3238 ATA_SUPPORT_ZONE_DEV_MANAGED)
3239 softc->zone_mode =
3240 ADA_ZONE_DRIVE_MANAGED;
3241 }
3242
3243 zac_cap = le64dec(sup_cap->sup_zac_cap);
3244 if (zac_cap & ATA_SUP_ZAC_CAP_VALID) {
3245 if (zac_cap & ATA_REPORT_ZONES_SUP)
3246 softc->zone_flags |=
3247 ADA_ZONE_FLAG_RZ_SUP;
3248 if (zac_cap & ATA_ND_OPEN_ZONE_SUP)
3249 softc->zone_flags |=
3250 ADA_ZONE_FLAG_OPEN_SUP;
3251 if (zac_cap & ATA_ND_CLOSE_ZONE_SUP)
3252 softc->zone_flags |=
3253 ADA_ZONE_FLAG_CLOSE_SUP;
3254 if (zac_cap & ATA_ND_FINISH_ZONE_SUP)
3255 softc->zone_flags |=
3256 ADA_ZONE_FLAG_FINISH_SUP;
3257 if (zac_cap & ATA_ND_RWP_SUP)
3258 softc->zone_flags |=
3259 ADA_ZONE_FLAG_RWP_SUP;
3260 } else {
3261 /*
3262 * This field was introduced in
3263 * ACS-4, r08 on April 28th, 2015.
3264 * If the drive firmware was written
3265 * to an earlier spec, it won't have
3266 * the field. So, assume all
3267 * commands are supported.
3268 */
3269 softc->zone_flags |=
3270 ADA_ZONE_FLAG_SUP_MASK;
3271 }
3272 }
3273 } else {
3274 error = adaerror(done_ccb, CAM_RETRY_SELTO,
3275 SF_RETRY_UA|SF_NO_PRINT);
3276 if (error == ERESTART)
3277 return;
3278 else if (error != 0) {
3279 /*
3280 * If we can't get the ATA Identify Data
3281 * Supported Capabilities page, clear the
3282 * flag...
3283 */
3284 softc->flags &= ~ADA_FLAG_CAN_SUPCAP;
3285 /*
3286 * And clear zone capabilities.
3287 */
3288 softc->zone_flags &= ~ADA_ZONE_FLAG_SUP_MASK;
3289 if ((done_ccb->ccb_h.status &
3290 CAM_DEV_QFRZN) != 0) {
3291 /* Don't wedge this device's queue */
3292 cam_release_devq(done_ccb->ccb_h.path,
3293 /*relsim_flags*/0,
3294 /*reduction*/0,
3295 /*timeout*/0,
3296 /*getcount_only*/0);
3297 }
3298 }
3299 }
3300
3301 free(ataio->data_ptr, M_ATADA);
3302
3303 if ((error == 0)
3304 && (softc->flags & ADA_FLAG_CAN_ZONE)) {
3305 softc->state = ADA_STATE_ZONE;
3306 xpt_release_ccb(done_ccb);
3307 xpt_schedule(periph, priority);
3308 } else
3309 adaprobedone(periph, done_ccb);
3310 return;
3311 }
3312 case ADA_CCB_ZONE: {
3313 int error;
3314
3315 if ((ataio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
3316 struct ata_zoned_info_log *zi_log;
3317 uint32_t valid_len;
3318 size_t needed_size;
3319
3320 zi_log = (struct ata_zoned_info_log *)ataio->data_ptr;
3321
3322 valid_len = ataio->dxfer_len - ataio->resid;
3323 needed_size = __offsetof(struct ata_zoned_info_log,
3324 version_info) + 1 + sizeof(zi_log->version_info);
3325 if (valid_len >= needed_size) {
3326 uint64_t tmpvar;
3327
3328 tmpvar = le64dec(zi_log->zoned_cap);
3329 if (tmpvar & ATA_ZDI_CAP_VALID) {
3330 if (tmpvar & ATA_ZDI_CAP_URSWRZ)
3331 softc->zone_flags |=
3332 ADA_ZONE_FLAG_URSWRZ;
3333 else
3334 softc->zone_flags &=
3335 ~ADA_ZONE_FLAG_URSWRZ;
3336 }
3337 tmpvar = le64dec(zi_log->optimal_seq_zones);
3338 if (tmpvar & ATA_ZDI_OPT_SEQ_VALID) {
3339 softc->zone_flags |=
3340 ADA_ZONE_FLAG_OPT_SEQ_SET;
3341 softc->optimal_seq_zones = (tmpvar &
3342 ATA_ZDI_OPT_SEQ_MASK);
3343 } else {
3344 softc->zone_flags &=
3345 ~ADA_ZONE_FLAG_OPT_SEQ_SET;
3346 softc->optimal_seq_zones = 0;
3347 }
3348
3349 tmpvar =le64dec(zi_log->optimal_nonseq_zones);
3350 if (tmpvar & ATA_ZDI_OPT_NS_VALID) {
3351 softc->zone_flags |=
3352 ADA_ZONE_FLAG_OPT_NONSEQ_SET;
3353 softc->optimal_nonseq_zones =
3354 (tmpvar & ATA_ZDI_OPT_NS_MASK);
3355 } else {
3356 softc->zone_flags &=
3357 ~ADA_ZONE_FLAG_OPT_NONSEQ_SET;
3358 softc->optimal_nonseq_zones = 0;
3359 }
3360
3361 tmpvar = le64dec(zi_log->max_seq_req_zones);
3362 if (tmpvar & ATA_ZDI_MAX_SEQ_VALID) {
3363 softc->zone_flags |=
3364 ADA_ZONE_FLAG_MAX_SEQ_SET;
3365 softc->max_seq_zones =
3366 (tmpvar & ATA_ZDI_MAX_SEQ_MASK);
3367 } else {
3368 softc->zone_flags &=
3369 ~ADA_ZONE_FLAG_MAX_SEQ_SET;
3370 softc->max_seq_zones = 0;
3371 }
3372 }
3373 } else {
3374 error = adaerror(done_ccb, CAM_RETRY_SELTO,
3375 SF_RETRY_UA|SF_NO_PRINT);
3376 if (error == ERESTART)
3377 return;
3378 else if (error != 0) {
3379 softc->flags &= ~ADA_FLAG_CAN_ZONE;
3380 softc->flags &= ~ADA_ZONE_FLAG_SET_MASK;
3381
3382 if ((done_ccb->ccb_h.status &
3383 CAM_DEV_QFRZN) != 0) {
3384 /* Don't wedge this device's queue */
3385 cam_release_devq(done_ccb->ccb_h.path,
3386 /*relsim_flags*/0,
3387 /*reduction*/0,
3388 /*timeout*/0,
3389 /*getcount_only*/0);
3390 }
3391 }
3392 }
3393 free(ataio->data_ptr, M_ATADA);
3394
3395 adaprobedone(periph, done_ccb);
3396 return;
3397 }
3398 case ADA_CCB_DUMP:
3399 /* No-op. We're polling */
3400 return;
3401 default:
3402 break;
3403 }
3404 xpt_release_ccb(done_ccb);
3405 }
3406
3407 static int
adaerror(union ccb * ccb,uint32_t cam_flags,uint32_t sense_flags)3408 adaerror(union ccb *ccb, uint32_t cam_flags, uint32_t sense_flags)
3409 {
3410 #ifdef CAM_IO_STATS
3411 struct ada_softc *softc;
3412 struct cam_periph *periph;
3413
3414 periph = xpt_path_periph(ccb->ccb_h.path);
3415 softc = (struct ada_softc *)periph->softc;
3416
3417 switch (ccb->ccb_h.status & CAM_STATUS_MASK) {
3418 case CAM_CMD_TIMEOUT:
3419 softc->timeouts++;
3420 break;
3421 case CAM_REQ_ABORTED:
3422 case CAM_REQ_CMP_ERR:
3423 case CAM_REQ_TERMIO:
3424 case CAM_UNREC_HBA_ERROR:
3425 case CAM_DATA_RUN_ERR:
3426 case CAM_ATA_STATUS_ERROR:
3427 softc->errors++;
3428 break;
3429 default:
3430 break;
3431 }
3432 #endif
3433
3434 return(cam_periph_error(ccb, cam_flags, sense_flags));
3435 }
3436
3437 static void
adasetgeom(struct ada_softc * softc,struct ccb_getdev * cgd)3438 adasetgeom(struct ada_softc *softc, struct ccb_getdev *cgd)
3439 {
3440 struct disk_params *dp = &softc->params;
3441 uint64_t lbasize48;
3442 uint32_t lbasize;
3443 u_int maxio, d_flags;
3444 size_t tmpsize;
3445
3446 dp->secsize = ata_logical_sector_size(&cgd->ident_data);
3447 if ((cgd->ident_data.atavalid & ATA_FLAG_54_58) &&
3448 cgd->ident_data.current_heads != 0 &&
3449 cgd->ident_data.current_sectors != 0) {
3450 dp->heads = cgd->ident_data.current_heads;
3451 dp->secs_per_track = cgd->ident_data.current_sectors;
3452 dp->cylinders = cgd->ident_data.cylinders;
3453 dp->sectors = (uint32_t)cgd->ident_data.current_size_1 |
3454 ((uint32_t)cgd->ident_data.current_size_2 << 16);
3455 } else {
3456 dp->heads = cgd->ident_data.heads;
3457 dp->secs_per_track = cgd->ident_data.sectors;
3458 dp->cylinders = cgd->ident_data.cylinders;
3459 dp->sectors = cgd->ident_data.cylinders *
3460 (uint32_t)(dp->heads * dp->secs_per_track);
3461 }
3462 lbasize = (uint32_t)cgd->ident_data.lba_size_1 |
3463 ((uint32_t)cgd->ident_data.lba_size_2 << 16);
3464
3465 /* use the 28bit LBA size if valid or bigger than the CHS mapping */
3466 if (cgd->ident_data.cylinders == 16383 || dp->sectors < lbasize)
3467 dp->sectors = lbasize;
3468
3469 /* use the 48bit LBA size if valid */
3470 lbasize48 = ((uint64_t)cgd->ident_data.lba_size48_1) |
3471 ((uint64_t)cgd->ident_data.lba_size48_2 << 16) |
3472 ((uint64_t)cgd->ident_data.lba_size48_3 << 32) |
3473 ((uint64_t)cgd->ident_data.lba_size48_4 << 48);
3474 if ((cgd->ident_data.support.command2 & ATA_SUPPORT_ADDRESS48) &&
3475 lbasize48 > ATA_MAX_28BIT_LBA)
3476 dp->sectors = lbasize48;
3477
3478 maxio = softc->cpi.maxio; /* Honor max I/O size of SIM */
3479 if (maxio == 0)
3480 maxio = DFLTPHYS; /* traditional default */
3481 else if (maxio > maxphys)
3482 maxio = maxphys; /* for safety */
3483 if (softc->flags & ADA_FLAG_CAN_48BIT)
3484 maxio = min(maxio, 65536 * softc->params.secsize);
3485 else /* 28bit ATA command limit */
3486 maxio = min(maxio, 256 * softc->params.secsize);
3487 if (softc->quirks & ADA_Q_128KB)
3488 maxio = min(maxio, 128 * 1024);
3489 softc->disk->d_maxsize = maxio;
3490 d_flags = DISKFLAG_DIRECT_COMPLETION | DISKFLAG_CANZONE;
3491 if (softc->flags & ADA_FLAG_CAN_FLUSHCACHE)
3492 d_flags |= DISKFLAG_CANFLUSHCACHE;
3493 if (softc->flags & ADA_FLAG_CAN_TRIM) {
3494 d_flags |= DISKFLAG_CANDELETE;
3495 softc->disk->d_delmaxsize = softc->params.secsize *
3496 ATA_DSM_RANGE_MAX * softc->trim_max_ranges;
3497 } else if ((softc->flags & ADA_FLAG_CAN_CFA) &&
3498 !(softc->flags & ADA_FLAG_CAN_48BIT)) {
3499 d_flags |= DISKFLAG_CANDELETE;
3500 softc->disk->d_delmaxsize = 256 * softc->params.secsize;
3501 } else
3502 softc->disk->d_delmaxsize = maxio;
3503 if ((softc->cpi.hba_misc & PIM_UNMAPPED) != 0) {
3504 d_flags |= DISKFLAG_UNMAPPED_BIO;
3505 softc->flags |= ADA_FLAG_UNMAPPEDIO;
3506 }
3507 softc->disk->d_flags = d_flags;
3508
3509 /*
3510 * ata_param_fixup will strip trailing padding spaces and add a NUL,
3511 * but if the field has no padding (as is common for serial numbers)
3512 * there will still be no NUL terminator. We cannot use strlcpy, since
3513 * it keeps reading src until it finds a NUL in order to compute the
3514 * return value (and will truncate the final character due to having a
3515 * single dsize rather than separate ssize and dsize), and strncpy does
3516 * not add a NUL to the destination if it reaches the character limit.
3517 */
3518 tmpsize = MIN(sizeof(softc->disk->d_descr) - 1,
3519 sizeof(cgd->ident_data.model));
3520 memcpy(softc->disk->d_descr, cgd->ident_data.model, tmpsize);
3521 softc->disk->d_descr[tmpsize] = '\0';
3522
3523 tmpsize = MIN(sizeof(softc->disk->d_ident) - 1,
3524 sizeof(cgd->ident_data.serial));
3525 memcpy(softc->disk->d_ident, cgd->ident_data.serial, tmpsize);
3526 softc->disk->d_ident[tmpsize] = '\0';
3527
3528 softc->disk->d_sectorsize = softc->params.secsize;
3529 softc->disk->d_mediasize = (off_t)softc->params.sectors *
3530 softc->params.secsize;
3531 if (ata_physical_sector_size(&cgd->ident_data) !=
3532 softc->params.secsize) {
3533 softc->disk->d_stripesize =
3534 ata_physical_sector_size(&cgd->ident_data);
3535 softc->disk->d_stripeoffset = (softc->disk->d_stripesize -
3536 ata_logical_sector_offset(&cgd->ident_data)) %
3537 softc->disk->d_stripesize;
3538 } else if (softc->quirks & ADA_Q_4K) {
3539 softc->disk->d_stripesize = 4096;
3540 softc->disk->d_stripeoffset = 0;
3541 }
3542 softc->disk->d_fwsectors = softc->params.secs_per_track;
3543 softc->disk->d_fwheads = softc->params.heads;
3544 softc->disk->d_rotation_rate = cgd->ident_data.media_rotation_rate;
3545 snprintf(softc->disk->d_attachment, sizeof(softc->disk->d_attachment),
3546 "%s%d", softc->cpi.dev_name, softc->cpi.unit_number);
3547 }
3548
3549 static void
adasendorderedtag(void * arg)3550 adasendorderedtag(void *arg)
3551 {
3552 struct ada_softc *softc = arg;
3553
3554 if (ada_send_ordered) {
3555 if (softc->outstanding_cmds > 0) {
3556 if ((softc->flags & ADA_FLAG_WAS_OTAG) == 0)
3557 softc->flags |= ADA_FLAG_NEED_OTAG;
3558 softc->flags &= ~ADA_FLAG_WAS_OTAG;
3559 }
3560 }
3561
3562 /* Queue us up again */
3563 callout_schedule_sbt(&softc->sendordered_c,
3564 SBT_1S / ADA_ORDEREDTAG_INTERVAL * ada_default_timeout, 0,
3565 C_PREL(1));
3566 }
3567
3568 /*
3569 * Step through all ADA peripheral drivers, and if the device is still open,
3570 * sync the disk cache to physical media.
3571 */
3572 static void
adaflush(void)3573 adaflush(void)
3574 {
3575 struct cam_periph *periph;
3576 struct ada_softc *softc;
3577 union ccb *ccb;
3578 int error;
3579
3580 CAM_PERIPH_FOREACH(periph, &adadriver) {
3581 softc = (struct ada_softc *)periph->softc;
3582 if (SCHEDULER_STOPPED()) {
3583 /* If we panicked with the lock held, do not recurse. */
3584 if (!cam_periph_owned(periph) &&
3585 (softc->flags & ADA_FLAG_OPEN)) {
3586 adadump(softc->disk, NULL, 0, 0);
3587 }
3588 continue;
3589 }
3590 cam_periph_lock(periph);
3591 /*
3592 * We only sync the cache if the drive is still open, and
3593 * if the drive is capable of it..
3594 */
3595 if (((softc->flags & ADA_FLAG_OPEN) == 0) ||
3596 (softc->flags & ADA_FLAG_CAN_FLUSHCACHE) == 0) {
3597 cam_periph_unlock(periph);
3598 continue;
3599 }
3600
3601 ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
3602 cam_fill_ataio(&ccb->ataio,
3603 0,
3604 NULL,
3605 CAM_DIR_NONE,
3606 0,
3607 NULL,
3608 0,
3609 ada_default_timeout*1000);
3610 if (softc->flags & ADA_FLAG_CAN_48BIT)
3611 ata_48bit_cmd(&ccb->ataio, ATA_FLUSHCACHE48, 0, 0, 0);
3612 else
3613 ata_28bit_cmd(&ccb->ataio, ATA_FLUSHCACHE, 0, 0, 0);
3614
3615 error = cam_periph_runccb(ccb, adaerror, /*cam_flags*/0,
3616 /*sense_flags*/ SF_NO_RECOVERY | SF_NO_RETRY,
3617 softc->disk->d_devstat);
3618 if (error != 0)
3619 xpt_print(periph->path, "Synchronize cache failed\n");
3620 xpt_release_ccb(ccb);
3621 cam_periph_unlock(periph);
3622 }
3623 }
3624
3625 static void
adaspindown(uint8_t cmd,int flags)3626 adaspindown(uint8_t cmd, int flags)
3627 {
3628 struct cam_periph *periph;
3629 struct ada_softc *softc;
3630 struct ccb_ataio local_ccb;
3631 int error;
3632 int mode;
3633
3634 CAM_PERIPH_FOREACH(periph, &adadriver) {
3635 /* If we panicked with lock held - not recurse here. */
3636 if (cam_periph_owned(periph))
3637 continue;
3638 cam_periph_lock(periph);
3639 softc = (struct ada_softc *)periph->softc;
3640 /*
3641 * We only spin-down the drive if it is capable of it..
3642 */
3643 if ((softc->flags & ADA_FLAG_CAN_POWERMGT) == 0) {
3644 cam_periph_unlock(periph);
3645 continue;
3646 }
3647
3648 /*
3649 * Additionally check if we would spin up the drive instead of
3650 * spinning it down.
3651 */
3652 if (cmd == ATA_IDLE_IMMEDIATE) {
3653 memset(&local_ccb, 0, sizeof(local_ccb));
3654 xpt_setup_ccb(&local_ccb.ccb_h, periph->path,
3655 CAM_PRIORITY_NORMAL);
3656 local_ccb.ccb_h.ccb_state = ADA_CCB_DUMP;
3657
3658 cam_fill_ataio(&local_ccb, 0, NULL, CAM_DIR_NONE,
3659 0, NULL, 0, ada_default_timeout * 1000);
3660 ata_28bit_cmd(&local_ccb, ATA_CHECK_POWER_MODE,
3661 0, 0, 0);
3662 local_ccb.cmd.flags |= CAM_ATAIO_NEEDRESULT;
3663
3664 error = cam_periph_runccb((union ccb *)&local_ccb,
3665 adaerror, /*cam_flags*/0,
3666 /*sense_flags*/ SF_NO_RECOVERY | SF_NO_RETRY,
3667 softc->disk->d_devstat);
3668 if (error != 0) {
3669 xpt_print(periph->path,
3670 "Failed to read current power mode\n");
3671 } else {
3672 mode = local_ccb.res.sector_count;
3673 #ifdef DIAGNOSTIC
3674 if (bootverbose) {
3675 xpt_print(periph->path,
3676 "disk power mode 0x%02x\n", mode);
3677 }
3678 #endif
3679 switch (mode) {
3680 case ATA_PM_STANDBY:
3681 case ATA_PM_STANDBY_Y:
3682 if (bootverbose) {
3683 xpt_print(periph->path,
3684 "already spun down\n");
3685 }
3686 cam_periph_unlock(periph);
3687 continue;
3688 default:
3689 break;
3690 }
3691 }
3692 }
3693
3694 if (bootverbose)
3695 xpt_print(periph->path, "spin-down\n");
3696
3697 memset(&local_ccb, 0, sizeof(local_ccb));
3698 xpt_setup_ccb(&local_ccb.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
3699 local_ccb.ccb_h.ccb_state = ADA_CCB_DUMP;
3700
3701 cam_fill_ataio(&local_ccb,
3702 0,
3703 NULL,
3704 CAM_DIR_NONE | flags,
3705 0,
3706 NULL,
3707 0,
3708 ada_default_timeout*1000);
3709 ata_28bit_cmd(&local_ccb, cmd, 0, 0, 0);
3710 error = cam_periph_runccb((union ccb *)&local_ccb, adaerror,
3711 /*cam_flags*/0, /*sense_flags*/ SF_NO_RECOVERY | SF_NO_RETRY,
3712 softc->disk->d_devstat);
3713 if (error != 0)
3714 xpt_print(periph->path, "Spin-down disk failed\n");
3715 cam_periph_unlock(periph);
3716 }
3717 }
3718
3719 static void
adashutdown(void * arg,int howto)3720 adashutdown(void *arg, int howto)
3721 {
3722 int how;
3723
3724 if ((howto & RB_NOSYNC) != 0)
3725 return;
3726
3727 adaflush();
3728
3729 /*
3730 * STANDBY IMMEDIATE saves any volatile data to the drive. It also spins
3731 * down hard drives. IDLE IMMEDIATE also saves the volatile data without
3732 * a spindown. We send the former when we expect to lose power soon. For
3733 * a warm boot, we send the latter to avoid a thundering herd of spinups
3734 * just after the kernel loads while probing. We have to do something to
3735 * flush the data because the BIOS in many systems resets the HBA
3736 * causing a COMINIT/COMRESET negotiation, which some drives interpret
3737 * as license to toss the volatile data, and others count as unclean
3738 * shutdown when in the Active PM state in SMART attributes.
3739 *
3740 * adaspindown will ensure that we don't send this to a drive that
3741 * doesn't support it.
3742 */
3743 if (ada_spindown_shutdown != 0) {
3744 how = (howto & (RB_HALT | RB_POWEROFF | RB_POWERCYCLE)) ?
3745 ATA_STANDBY_IMMEDIATE : ATA_IDLE_IMMEDIATE;
3746 adaspindown(how, 0);
3747 }
3748 }
3749
3750 static void
adasuspend(void * arg)3751 adasuspend(void *arg)
3752 {
3753
3754 adaflush();
3755 /*
3756 * SLEEP also fushes any volatile data, like STANDBY IMEDIATE,
3757 * so we don't need to send it as well.
3758 */
3759 if (ada_spindown_suspend != 0)
3760 adaspindown(ATA_SLEEP, CAM_DEV_QFREEZE);
3761 }
3762
3763 static void
adaresume(void * arg)3764 adaresume(void *arg)
3765 {
3766 struct cam_periph *periph;
3767 struct ada_softc *softc;
3768
3769 if (ada_spindown_suspend == 0)
3770 return;
3771
3772 CAM_PERIPH_FOREACH(periph, &adadriver) {
3773 cam_periph_lock(periph);
3774 softc = (struct ada_softc *)periph->softc;
3775 /*
3776 * We only spin-down the drive if it is capable of it..
3777 */
3778 if ((softc->flags & ADA_FLAG_CAN_POWERMGT) == 0) {
3779 cam_periph_unlock(periph);
3780 continue;
3781 }
3782
3783 if (bootverbose)
3784 xpt_print(periph->path, "resume\n");
3785
3786 /*
3787 * Drop freeze taken due to CAM_DEV_QFREEZE flag set on
3788 * sleep request.
3789 */
3790 cam_release_devq(periph->path,
3791 /*relsim_flags*/0,
3792 /*openings*/0,
3793 /*timeout*/0,
3794 /*getcount_only*/0);
3795
3796 cam_periph_unlock(periph);
3797 }
3798 }
3799
3800 #endif /* _KERNEL */
3801