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 periph->softc = softc;
1838 xpt_path_inq(&softc->cpi, periph->path);
1839
1840 /*
1841 * See if this device has any quirks.
1842 */
1843 match = cam_quirkmatch((caddr_t)&cgd->ident_data,
1844 (caddr_t)ada_quirk_table,
1845 nitems(ada_quirk_table),
1846 sizeof(*ada_quirk_table), ata_identify_match);
1847 if (match != NULL)
1848 softc->quirks = ((struct ada_quirk_entry *)match)->quirks;
1849 else
1850 softc->quirks = ADA_Q_NONE;
1851
1852 TASK_INIT(&softc->sysctl_task, 0, adasysctlinit, periph);
1853
1854 /*
1855 * Take a reference on the periph while adastart is called to finish
1856 * the probe. The reference will be dropped in adaprobedone at the
1857 * end of probe.
1858 */
1859 (void)cam_periph_acquire(periph);
1860 cam_periph_unlock(periph);
1861 snprintf(announce_buf, ADA_ANNOUNCETMP_SZ,
1862 "kern.cam.ada.%d.quirks", periph->unit_number);
1863 quirks = softc->quirks;
1864 TUNABLE_INT_FETCH(announce_buf, &quirks);
1865 softc->quirks = quirks;
1866 softc->read_ahead = -1;
1867 snprintf(announce_buf, ADA_ANNOUNCETMP_SZ,
1868 "kern.cam.ada.%d.read_ahead", periph->unit_number);
1869 TUNABLE_INT_FETCH(announce_buf, &softc->read_ahead);
1870 softc->write_cache = -1;
1871 snprintf(announce_buf, ADA_ANNOUNCETMP_SZ,
1872 "kern.cam.ada.%d.write_cache", periph->unit_number);
1873 TUNABLE_INT_FETCH(announce_buf, &softc->write_cache);
1874
1875 /*
1876 * Let XPT know we can use UMA-allocated CCBs.
1877 */
1878 if (ada_enable_uma_ccbs) {
1879 KASSERT(ada_ccb_zone != NULL,
1880 ("%s: NULL ada_ccb_zone", __func__));
1881 periph->ccb_zone = ada_ccb_zone;
1882 }
1883
1884 /*
1885 * Set support flags based on the Identify data and quirks.
1886 */
1887 adasetflags(softc, cgd);
1888 if (softc->cpi.hba_misc & PIM_ATA_EXT)
1889 softc->flags |= ADA_FLAG_PIM_ATA_EXT;
1890
1891 /* Disable queue sorting for non-rotational media by default. */
1892 if (cgd->ident_data.media_rotation_rate == ATA_RATE_NON_ROTATING) {
1893 softc->flags &= ~ADA_FLAG_ROTATING;
1894 } else {
1895 softc->flags |= ADA_FLAG_ROTATING;
1896 }
1897 softc->disk = disk_alloc();
1898 adasetgeom(softc, cgd);
1899 softc->disk->d_devstat = devstat_new_entry(periph->periph_name,
1900 periph->unit_number, softc->params.secsize,
1901 DEVSTAT_ALL_SUPPORTED,
1902 DEVSTAT_TYPE_DIRECT |
1903 XPORT_DEVSTAT_TYPE(softc->cpi.transport),
1904 DEVSTAT_PRIORITY_DISK);
1905 softc->disk->d_open = adaopen;
1906 softc->disk->d_close = adaclose;
1907 softc->disk->d_strategy = adastrategy;
1908 softc->disk->d_getattr = adagetattr;
1909 if (cam_sim_pollable(periph->sim))
1910 softc->disk->d_dump = adadump;
1911 softc->disk->d_gone = adadiskgonecb;
1912 softc->disk->d_name = "ada";
1913 softc->disk->d_drv1 = periph;
1914 softc->disk->d_unit = periph->unit_number;
1915
1916 if (cam_iosched_init(&softc->cam_iosched, periph, softc->disk,
1917 adaschedule) != 0) {
1918 printf("adaregister: Unable to probe new device. "
1919 "Unable to allocate iosched memory\n");
1920 free(softc, M_DEVBUF);
1921 return(CAM_REQ_CMP_ERR);
1922 }
1923 cam_iosched_set_sort_queue(softc->cam_iosched,
1924 (softc->flags & ADA_FLAG_ROTATING) ? -1 : 0);
1925
1926 cam_periph_lock(periph);
1927
1928 dp = &softc->params;
1929 snprintf(announce_buf, ADA_ANNOUNCETMP_SZ,
1930 "%juMB (%ju %u byte sectors)",
1931 ((uintmax_t)dp->secsize * dp->sectors) / (1024 * 1024),
1932 (uintmax_t)dp->sectors, dp->secsize);
1933
1934 sbuf_new(&sb, softc->announce_buffer, ADA_ANNOUNCE_SZ, SBUF_FIXEDLEN);
1935 xpt_announce_periph_sbuf(periph, &sb, announce_buf);
1936 xpt_announce_quirks_sbuf(periph, &sb, softc->quirks, ADA_Q_BIT_STRING);
1937 sbuf_finish(&sb);
1938 sbuf_putbuf(&sb);
1939
1940 /*
1941 * Create our sysctl variables, now that we know
1942 * we have successfully attached.
1943 */
1944 if (cam_periph_acquire(periph) == 0)
1945 taskqueue_enqueue(taskqueue_thread, &softc->sysctl_task);
1946
1947 /*
1948 * Add async callbacks for bus reset and
1949 * bus device reset calls. I don't bother
1950 * checking if this fails as, in most cases,
1951 * the system will function just fine without
1952 * them and the only alternative would be to
1953 * not attach the device on failure.
1954 */
1955 xpt_register_async(AC_SENT_BDR | AC_BUS_RESET | AC_LOST_DEVICE |
1956 AC_GETDEV_CHANGED | AC_ADVINFO_CHANGED,
1957 adaasync, periph, periph->path);
1958
1959 /*
1960 * Schedule a periodic event to occasionally send an
1961 * ordered tag to a device.
1962 */
1963 callout_init_mtx(&softc->sendordered_c, cam_periph_mtx(periph), 0);
1964 callout_reset_sbt(&softc->sendordered_c,
1965 SBT_1S / ADA_ORDEREDTAG_INTERVAL * ada_default_timeout, 0,
1966 adasendorderedtag, softc, C_PREL(1));
1967
1968 /* Released after probe when disk_create() call pass it to GEOM. */
1969 cam_periph_hold_boot(periph);
1970
1971 if (ADA_RA >= 0 && softc->flags & ADA_FLAG_CAN_RAHEAD) {
1972 softc->state = ADA_STATE_RAHEAD;
1973 } else if (ADA_WC >= 0 && softc->flags & ADA_FLAG_CAN_WCACHE) {
1974 softc->state = ADA_STATE_WCACHE;
1975 } else if ((softc->flags & ADA_FLAG_CAN_LOG)
1976 && (softc->zone_mode != ADA_ZONE_NONE)) {
1977 softc->state = ADA_STATE_LOGDIR;
1978 } else {
1979 /*
1980 * Nothing to probe, so we can just transition to the
1981 * normal state.
1982 */
1983 adaprobedone(periph, NULL);
1984 return(CAM_REQ_CMP);
1985 }
1986
1987 xpt_schedule(periph, CAM_PRIORITY_DEV);
1988 return(CAM_REQ_CMP);
1989 }
1990
1991 static int
ada_dsmtrim_req_create(struct ada_softc * softc,struct bio * bp,struct trim_request * req)1992 ada_dsmtrim_req_create(struct ada_softc *softc, struct bio *bp, struct trim_request *req)
1993 {
1994 uint64_t lastlba = (uint64_t)-1, lbas = 0;
1995 int c, lastcount = 0, off, ranges = 0;
1996
1997 bzero(req, sizeof(*req));
1998 TAILQ_INIT(&req->bps);
1999 do {
2000 uint64_t lba = bp->bio_pblkno;
2001 int count = bp->bio_bcount / softc->params.secsize;
2002
2003 /* Try to extend the previous range. */
2004 if (lba == lastlba) {
2005 c = min(count, ATA_DSM_RANGE_MAX - lastcount);
2006 lastcount += c;
2007 off = (ranges - 1) * ATA_DSM_RANGE_SIZE;
2008 req->data[off + 6] = lastcount & 0xff;
2009 req->data[off + 7] =
2010 (lastcount >> 8) & 0xff;
2011 count -= c;
2012 lba += c;
2013 lbas += c;
2014 }
2015
2016 while (count > 0) {
2017 c = min(count, ATA_DSM_RANGE_MAX);
2018 off = ranges * ATA_DSM_RANGE_SIZE;
2019 req->data[off + 0] = lba & 0xff;
2020 req->data[off + 1] = (lba >> 8) & 0xff;
2021 req->data[off + 2] = (lba >> 16) & 0xff;
2022 req->data[off + 3] = (lba >> 24) & 0xff;
2023 req->data[off + 4] = (lba >> 32) & 0xff;
2024 req->data[off + 5] = (lba >> 40) & 0xff;
2025 req->data[off + 6] = c & 0xff;
2026 req->data[off + 7] = (c >> 8) & 0xff;
2027 lba += c;
2028 lbas += c;
2029 count -= c;
2030 lastcount = c;
2031 ranges++;
2032 /*
2033 * Its the caller's responsibility to ensure the
2034 * request will fit so we don't need to check for
2035 * overrun here
2036 */
2037 }
2038 lastlba = lba;
2039 TAILQ_INSERT_TAIL(&req->bps, bp, bio_queue);
2040
2041 bp = cam_iosched_next_trim(softc->cam_iosched);
2042 if (bp == NULL)
2043 break;
2044 if (bp->bio_bcount / softc->params.secsize >
2045 (softc->trim_max_ranges - ranges) * ATA_DSM_RANGE_MAX) {
2046 cam_iosched_put_back_trim(softc->cam_iosched, bp);
2047 break;
2048 }
2049 } while (1);
2050 softc->trim_count++;
2051 softc->trim_ranges += ranges;
2052 softc->trim_lbas += lbas;
2053
2054 return (ranges);
2055 }
2056
2057 static void
ada_dsmtrim(struct ada_softc * softc,struct bio * bp,struct ccb_ataio * ataio)2058 ada_dsmtrim(struct ada_softc *softc, struct bio *bp, struct ccb_ataio *ataio)
2059 {
2060 struct trim_request *req = &softc->trim_req;
2061 int ranges;
2062
2063 ranges = ada_dsmtrim_req_create(softc, bp, req);
2064 cam_fill_ataio(ataio,
2065 ada_retry_count,
2066 adadone,
2067 CAM_DIR_OUT,
2068 0,
2069 req->data,
2070 howmany(ranges, ATA_DSM_BLK_RANGES) * ATA_DSM_BLK_SIZE,
2071 ada_default_timeout * 1000);
2072 ata_48bit_cmd(ataio, ATA_DATA_SET_MANAGEMENT,
2073 ATA_DSM_TRIM, 0, howmany(ranges, ATA_DSM_BLK_RANGES));
2074 }
2075
2076 static void
ada_ncq_dsmtrim(struct ada_softc * softc,struct bio * bp,struct ccb_ataio * ataio)2077 ada_ncq_dsmtrim(struct ada_softc *softc, struct bio *bp, struct ccb_ataio *ataio)
2078 {
2079 struct trim_request *req = &softc->trim_req;
2080 int ranges;
2081
2082 ranges = ada_dsmtrim_req_create(softc, bp, req);
2083 cam_fill_ataio(ataio,
2084 ada_retry_count,
2085 adadone,
2086 CAM_DIR_OUT,
2087 0,
2088 req->data,
2089 howmany(ranges, ATA_DSM_BLK_RANGES) * ATA_DSM_BLK_SIZE,
2090 ada_default_timeout * 1000);
2091 ata_ncq_cmd(ataio,
2092 ATA_SEND_FPDMA_QUEUED,
2093 0,
2094 howmany(ranges, ATA_DSM_BLK_RANGES));
2095 ataio->cmd.sector_count_exp = ATA_SFPDMA_DSM;
2096 ataio->ata_flags |= ATA_FLAG_AUX;
2097 ataio->aux = 1;
2098 }
2099
2100 static void
ada_cfaerase(struct ada_softc * softc,struct bio * bp,struct ccb_ataio * ataio)2101 ada_cfaerase(struct ada_softc *softc, struct bio *bp, struct ccb_ataio *ataio)
2102 {
2103 struct trim_request *req = &softc->trim_req;
2104 uint64_t lba = bp->bio_pblkno;
2105 uint16_t count = bp->bio_bcount / softc->params.secsize;
2106
2107 bzero(req, sizeof(*req));
2108 TAILQ_INIT(&req->bps);
2109 TAILQ_INSERT_TAIL(&req->bps, bp, bio_queue);
2110
2111 cam_fill_ataio(ataio,
2112 ada_retry_count,
2113 adadone,
2114 CAM_DIR_NONE,
2115 0,
2116 NULL,
2117 0,
2118 ada_default_timeout*1000);
2119
2120 if (count >= 256)
2121 count = 0;
2122 ata_28bit_cmd(ataio, ATA_CFA_ERASE, 0, lba, count);
2123 }
2124
2125 static int
ada_zone_bio_to_ata(int disk_zone_cmd)2126 ada_zone_bio_to_ata(int disk_zone_cmd)
2127 {
2128 switch (disk_zone_cmd) {
2129 case DISK_ZONE_OPEN:
2130 return ATA_ZM_OPEN_ZONE;
2131 case DISK_ZONE_CLOSE:
2132 return ATA_ZM_CLOSE_ZONE;
2133 case DISK_ZONE_FINISH:
2134 return ATA_ZM_FINISH_ZONE;
2135 case DISK_ZONE_RWP:
2136 return ATA_ZM_RWP;
2137 }
2138
2139 return -1;
2140 }
2141
2142 static int
ada_zone_cmd(struct cam_periph * periph,union ccb * ccb,struct bio * bp,int * queue_ccb)2143 ada_zone_cmd(struct cam_periph *periph, union ccb *ccb, struct bio *bp,
2144 int *queue_ccb)
2145 {
2146 struct ada_softc *softc;
2147 int error;
2148
2149 error = 0;
2150
2151 if (bp->bio_cmd != BIO_ZONE) {
2152 error = EINVAL;
2153 goto bailout;
2154 }
2155
2156 softc = periph->softc;
2157
2158 switch (bp->bio_zone.zone_cmd) {
2159 case DISK_ZONE_OPEN:
2160 case DISK_ZONE_CLOSE:
2161 case DISK_ZONE_FINISH:
2162 case DISK_ZONE_RWP: {
2163 int zone_flags;
2164 int zone_sa;
2165 uint64_t lba;
2166
2167 zone_sa = ada_zone_bio_to_ata(bp->bio_zone.zone_cmd);
2168 if (zone_sa == -1) {
2169 xpt_print(periph->path, "Cannot translate zone "
2170 "cmd %#x to ATA\n", bp->bio_zone.zone_cmd);
2171 error = EINVAL;
2172 goto bailout;
2173 }
2174
2175 zone_flags = 0;
2176 lba = bp->bio_zone.zone_params.rwp.id;
2177
2178 if (bp->bio_zone.zone_params.rwp.flags &
2179 DISK_ZONE_RWP_FLAG_ALL)
2180 zone_flags |= ZBC_OUT_ALL;
2181
2182 ata_zac_mgmt_out(&ccb->ataio,
2183 /*retries*/ ada_retry_count,
2184 /*cbfcnp*/ adadone,
2185 /*use_ncq*/ (softc->flags &
2186 ADA_FLAG_PIM_ATA_EXT) ? 1 : 0,
2187 /*zm_action*/ zone_sa,
2188 /*zone_id*/ lba,
2189 /*zone_flags*/ zone_flags,
2190 /*sector_count*/ 0,
2191 /*data_ptr*/ NULL,
2192 /*dxfer_len*/ 0,
2193 /*timeout*/ ada_default_timeout * 1000);
2194 *queue_ccb = 1;
2195
2196 break;
2197 }
2198 case DISK_ZONE_REPORT_ZONES: {
2199 uint8_t *rz_ptr;
2200 uint32_t num_entries, alloc_size;
2201 struct disk_zone_report *rep;
2202
2203 rep = &bp->bio_zone.zone_params.report;
2204
2205 num_entries = rep->entries_allocated;
2206 if (num_entries == 0) {
2207 xpt_print(periph->path, "No entries allocated for "
2208 "Report Zones request\n");
2209 error = EINVAL;
2210 goto bailout;
2211 }
2212 alloc_size = sizeof(struct scsi_report_zones_hdr) +
2213 (sizeof(struct scsi_report_zones_desc) * num_entries);
2214 alloc_size = min(alloc_size, softc->disk->d_maxsize);
2215 rz_ptr = malloc(alloc_size, M_ATADA, M_NOWAIT | M_ZERO);
2216 if (rz_ptr == NULL) {
2217 xpt_print(periph->path, "Unable to allocate memory "
2218 "for Report Zones request\n");
2219 error = ENOMEM;
2220 goto bailout;
2221 }
2222
2223 ata_zac_mgmt_in(&ccb->ataio,
2224 /*retries*/ ada_retry_count,
2225 /*cbcfnp*/ adadone,
2226 /*use_ncq*/ (softc->flags &
2227 ADA_FLAG_PIM_ATA_EXT) ? 1 : 0,
2228 /*zm_action*/ ATA_ZM_REPORT_ZONES,
2229 /*zone_id*/ rep->starting_id,
2230 /*zone_flags*/ rep->rep_options,
2231 /*data_ptr*/ rz_ptr,
2232 /*dxfer_len*/ alloc_size,
2233 /*timeout*/ ada_default_timeout * 1000);
2234
2235 /*
2236 * For BIO_ZONE, this isn't normally needed. However, it
2237 * is used by devstat_end_transaction_bio() to determine
2238 * how much data was transferred.
2239 */
2240 /*
2241 * XXX KDM we have a problem. But I'm not sure how to fix
2242 * it. devstat uses bio_bcount - bio_resid to calculate
2243 * the amount of data transferred. The GEOM disk code
2244 * uses bio_length - bio_resid to calculate the amount of
2245 * data in bio_completed. We have different structure
2246 * sizes above and below the ada(4) driver. So, if we
2247 * use the sizes above, the amount transferred won't be
2248 * quite accurate for devstat. If we use different sizes
2249 * for bio_bcount and bio_length (above and below
2250 * respectively), then the residual needs to match one or
2251 * the other. Everything is calculated after the bio
2252 * leaves the driver, so changing the values around isn't
2253 * really an option. For now, just set the count to the
2254 * passed in length. This means that the calculations
2255 * above (e.g. bio_completed) will be correct, but the
2256 * amount of data reported to devstat will be slightly
2257 * under or overstated.
2258 */
2259 bp->bio_bcount = bp->bio_length;
2260
2261 *queue_ccb = 1;
2262
2263 break;
2264 }
2265 case DISK_ZONE_GET_PARAMS: {
2266 struct disk_zone_disk_params *params;
2267
2268 params = &bp->bio_zone.zone_params.disk_params;
2269 bzero(params, sizeof(*params));
2270
2271 switch (softc->zone_mode) {
2272 case ADA_ZONE_DRIVE_MANAGED:
2273 params->zone_mode = DISK_ZONE_MODE_DRIVE_MANAGED;
2274 break;
2275 case ADA_ZONE_HOST_AWARE:
2276 params->zone_mode = DISK_ZONE_MODE_HOST_AWARE;
2277 break;
2278 case ADA_ZONE_HOST_MANAGED:
2279 params->zone_mode = DISK_ZONE_MODE_HOST_MANAGED;
2280 break;
2281 default:
2282 case ADA_ZONE_NONE:
2283 params->zone_mode = DISK_ZONE_MODE_NONE;
2284 break;
2285 }
2286
2287 if (softc->zone_flags & ADA_ZONE_FLAG_URSWRZ)
2288 params->flags |= DISK_ZONE_DISK_URSWRZ;
2289
2290 if (softc->zone_flags & ADA_ZONE_FLAG_OPT_SEQ_SET) {
2291 params->optimal_seq_zones = softc->optimal_seq_zones;
2292 params->flags |= DISK_ZONE_OPT_SEQ_SET;
2293 }
2294
2295 if (softc->zone_flags & ADA_ZONE_FLAG_OPT_NONSEQ_SET) {
2296 params->optimal_nonseq_zones =
2297 softc->optimal_nonseq_zones;
2298 params->flags |= DISK_ZONE_OPT_NONSEQ_SET;
2299 }
2300
2301 if (softc->zone_flags & ADA_ZONE_FLAG_MAX_SEQ_SET) {
2302 params->max_seq_zones = softc->max_seq_zones;
2303 params->flags |= DISK_ZONE_MAX_SEQ_SET;
2304 }
2305 if (softc->zone_flags & ADA_ZONE_FLAG_RZ_SUP)
2306 params->flags |= DISK_ZONE_RZ_SUP;
2307
2308 if (softc->zone_flags & ADA_ZONE_FLAG_OPEN_SUP)
2309 params->flags |= DISK_ZONE_OPEN_SUP;
2310
2311 if (softc->zone_flags & ADA_ZONE_FLAG_CLOSE_SUP)
2312 params->flags |= DISK_ZONE_CLOSE_SUP;
2313
2314 if (softc->zone_flags & ADA_ZONE_FLAG_FINISH_SUP)
2315 params->flags |= DISK_ZONE_FINISH_SUP;
2316
2317 if (softc->zone_flags & ADA_ZONE_FLAG_RWP_SUP)
2318 params->flags |= DISK_ZONE_RWP_SUP;
2319 break;
2320 }
2321 default:
2322 break;
2323 }
2324 bailout:
2325 return (error);
2326 }
2327
2328 static void
adastart(struct cam_periph * periph,union ccb * start_ccb)2329 adastart(struct cam_periph *periph, union ccb *start_ccb)
2330 {
2331 struct ada_softc *softc = (struct ada_softc *)periph->softc;
2332 struct ccb_ataio *ataio = &start_ccb->ataio;
2333
2334 CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("adastart\n"));
2335
2336 switch (softc->state) {
2337 case ADA_STATE_NORMAL:
2338 {
2339 struct bio *bp;
2340 uint8_t tag_code;
2341
2342 bp = cam_iosched_next_bio(softc->cam_iosched);
2343 if (bp == NULL) {
2344 xpt_release_ccb(start_ccb);
2345 break;
2346 }
2347
2348 if ((bp->bio_flags & BIO_ORDERED) != 0 ||
2349 (bp->bio_cmd != BIO_DELETE && (softc->flags & ADA_FLAG_NEED_OTAG) != 0)) {
2350 softc->flags &= ~ADA_FLAG_NEED_OTAG;
2351 softc->flags |= ADA_FLAG_WAS_OTAG;
2352 tag_code = 0;
2353 } else {
2354 tag_code = 1;
2355 }
2356 switch (bp->bio_cmd) {
2357 case BIO_WRITE:
2358 case BIO_READ:
2359 {
2360 uint64_t lba = bp->bio_pblkno;
2361 uint16_t count = bp->bio_bcount / softc->params.secsize;
2362 void *data_ptr;
2363 int rw_op;
2364
2365 if (bp->bio_cmd == BIO_WRITE) {
2366 softc->flags |= ADA_FLAG_DIRTY;
2367 rw_op = CAM_DIR_OUT;
2368 } else {
2369 rw_op = CAM_DIR_IN;
2370 }
2371
2372 data_ptr = bp->bio_data;
2373 if ((bp->bio_flags & (BIO_UNMAPPED|BIO_VLIST)) != 0) {
2374 rw_op |= CAM_DATA_BIO;
2375 data_ptr = bp;
2376 }
2377
2378 #ifdef CAM_TEST_FAILURE
2379 int fail = 0;
2380
2381 /*
2382 * Support the failure ioctls. If the command is a
2383 * read, and there are pending forced read errors, or
2384 * if a write and pending write errors, then fail this
2385 * operation with EIO. This is useful for testing
2386 * purposes. Also, support having every Nth read fail.
2387 *
2388 * This is a rather blunt tool.
2389 */
2390 if (bp->bio_cmd == BIO_READ) {
2391 if (softc->force_read_error) {
2392 softc->force_read_error--;
2393 fail = 1;
2394 }
2395 if (softc->periodic_read_error > 0) {
2396 if (++softc->periodic_read_count >=
2397 softc->periodic_read_error) {
2398 softc->periodic_read_count = 0;
2399 fail = 1;
2400 }
2401 }
2402 } else {
2403 if (softc->force_write_error) {
2404 softc->force_write_error--;
2405 fail = 1;
2406 }
2407 }
2408 if (fail) {
2409 biofinish(bp, NULL, EIO);
2410 xpt_release_ccb(start_ccb);
2411 adaschedule(periph);
2412 return;
2413 }
2414 #endif
2415 KASSERT((bp->bio_flags & BIO_UNMAPPED) == 0 ||
2416 round_page(bp->bio_bcount + bp->bio_ma_offset) /
2417 PAGE_SIZE == bp->bio_ma_n,
2418 ("Short bio %p", bp));
2419 cam_fill_ataio(ataio,
2420 ada_retry_count,
2421 adadone,
2422 rw_op,
2423 0,
2424 data_ptr,
2425 bp->bio_bcount,
2426 ada_default_timeout*1000);
2427
2428 if ((softc->flags & ADA_FLAG_CAN_NCQ) && tag_code) {
2429 if (bp->bio_cmd == BIO_READ) {
2430 ata_ncq_cmd(ataio, ATA_READ_FPDMA_QUEUED,
2431 lba, count);
2432 } else {
2433 ata_ncq_cmd(ataio, ATA_WRITE_FPDMA_QUEUED,
2434 lba, count);
2435 }
2436 } else if ((softc->flags & ADA_FLAG_CAN_48BIT) &&
2437 (lba + count >= ATA_MAX_28BIT_LBA ||
2438 count > 256)) {
2439 if (softc->flags & ADA_FLAG_CAN_DMA48) {
2440 if (bp->bio_cmd == BIO_READ) {
2441 ata_48bit_cmd(ataio, ATA_READ_DMA48,
2442 0, lba, count);
2443 } else {
2444 ata_48bit_cmd(ataio, ATA_WRITE_DMA48,
2445 0, lba, count);
2446 }
2447 } else {
2448 if (bp->bio_cmd == BIO_READ) {
2449 ata_48bit_cmd(ataio, ATA_READ_MUL48,
2450 0, lba, count);
2451 } else {
2452 ata_48bit_cmd(ataio, ATA_WRITE_MUL48,
2453 0, lba, count);
2454 }
2455 }
2456 } else {
2457 if (count == 256)
2458 count = 0;
2459 if (softc->flags & ADA_FLAG_CAN_DMA) {
2460 if (bp->bio_cmd == BIO_READ) {
2461 ata_28bit_cmd(ataio, ATA_READ_DMA,
2462 0, lba, count);
2463 } else {
2464 ata_28bit_cmd(ataio, ATA_WRITE_DMA,
2465 0, lba, count);
2466 }
2467 } else {
2468 if (bp->bio_cmd == BIO_READ) {
2469 ata_28bit_cmd(ataio, ATA_READ_MUL,
2470 0, lba, count);
2471 } else {
2472 ata_28bit_cmd(ataio, ATA_WRITE_MUL,
2473 0, lba, count);
2474 }
2475 }
2476 }
2477 break;
2478 }
2479 case BIO_DELETE:
2480 switch (softc->delete_method) {
2481 case ADA_DELETE_NCQ_DSM_TRIM:
2482 ada_ncq_dsmtrim(softc, bp, ataio);
2483 break;
2484 case ADA_DELETE_DSM_TRIM:
2485 ada_dsmtrim(softc, bp, ataio);
2486 break;
2487 case ADA_DELETE_CFA_ERASE:
2488 ada_cfaerase(softc, bp, ataio);
2489 break;
2490 default:
2491 biofinish(bp, NULL, EOPNOTSUPP);
2492 xpt_release_ccb(start_ccb);
2493 adaschedule(periph);
2494 return;
2495 }
2496 start_ccb->ccb_h.ccb_state = ADA_CCB_TRIM;
2497 start_ccb->ccb_h.flags |= CAM_UNLOCKED;
2498 cam_iosched_submit_trim(softc->cam_iosched);
2499 goto out;
2500 case BIO_FLUSH:
2501 cam_fill_ataio(ataio,
2502 1,
2503 adadone,
2504 CAM_DIR_NONE,
2505 0,
2506 NULL,
2507 0,
2508 ada_default_timeout*1000);
2509
2510 if (softc->flags & ADA_FLAG_CAN_48BIT)
2511 ata_48bit_cmd(ataio, ATA_FLUSHCACHE48, 0, 0, 0);
2512 else
2513 ata_28bit_cmd(ataio, ATA_FLUSHCACHE, 0, 0, 0);
2514 break;
2515 case BIO_ZONE: {
2516 int error, queue_ccb;
2517
2518 queue_ccb = 0;
2519
2520 error = ada_zone_cmd(periph, start_ccb, bp, &queue_ccb);
2521 if ((error != 0)
2522 || (queue_ccb == 0)) {
2523 /*
2524 * g_io_deliver will recurisvely call start
2525 * routine for ENOMEM, so drop the periph
2526 * lock to allow that recursion.
2527 */
2528 if (error == ENOMEM)
2529 cam_periph_unlock(periph);
2530 biofinish(bp, NULL, error);
2531 if (error == ENOMEM)
2532 cam_periph_lock(periph);
2533 xpt_release_ccb(start_ccb);
2534 return;
2535 }
2536 break;
2537 }
2538 default:
2539 biofinish(bp, NULL, EOPNOTSUPP);
2540 xpt_release_ccb(start_ccb);
2541 return;
2542 }
2543 start_ccb->ccb_h.ccb_state = ADA_CCB_BUFFER_IO;
2544 start_ccb->ccb_h.flags |= CAM_UNLOCKED;
2545 out:
2546 start_ccb->ccb_h.ccb_bp = bp;
2547 softc->outstanding_cmds++;
2548 softc->refcount++;
2549 cam_periph_unlock(periph);
2550 xpt_action(start_ccb);
2551 cam_periph_lock(periph);
2552
2553 /* May have more work to do, so ensure we stay scheduled */
2554 adaschedule(periph);
2555 break;
2556 }
2557 case ADA_STATE_RAHEAD:
2558 case ADA_STATE_WCACHE:
2559 {
2560 cam_fill_ataio(ataio,
2561 1,
2562 adadone,
2563 CAM_DIR_NONE,
2564 0,
2565 NULL,
2566 0,
2567 ada_default_timeout*1000);
2568
2569 if (softc->state == ADA_STATE_RAHEAD) {
2570 ata_28bit_cmd(ataio, ATA_SETFEATURES, ADA_RA ?
2571 ATA_SF_ENAB_RCACHE : ATA_SF_DIS_RCACHE, 0, 0);
2572 start_ccb->ccb_h.ccb_state = ADA_CCB_RAHEAD;
2573 } else {
2574 ata_28bit_cmd(ataio, ATA_SETFEATURES, ADA_WC ?
2575 ATA_SF_ENAB_WCACHE : ATA_SF_DIS_WCACHE, 0, 0);
2576 start_ccb->ccb_h.ccb_state = ADA_CCB_WCACHE;
2577 }
2578 start_ccb->ccb_h.flags |= CAM_DEV_QFREEZE;
2579 xpt_action(start_ccb);
2580 break;
2581 }
2582 case ADA_STATE_LOGDIR:
2583 {
2584 struct ata_gp_log_dir *log_dir;
2585
2586 if ((softc->flags & ADA_FLAG_CAN_LOG) == 0) {
2587 adaprobedone(periph, start_ccb);
2588 break;
2589 }
2590
2591 log_dir = malloc(sizeof(*log_dir), M_ATADA, M_NOWAIT|M_ZERO);
2592 if (log_dir == NULL) {
2593 xpt_print(periph->path, "Couldn't malloc log_dir "
2594 "data\n");
2595 softc->state = ADA_STATE_NORMAL;
2596 xpt_release_ccb(start_ccb);
2597 break;
2598 }
2599
2600 ata_read_log(ataio,
2601 /*retries*/1,
2602 /*cbfcnp*/adadone,
2603 /*log_address*/ ATA_LOG_DIRECTORY,
2604 /*page_number*/ 0,
2605 /*block_count*/ 1,
2606 /*protocol*/ softc->flags & ADA_FLAG_CAN_DMA ?
2607 CAM_ATAIO_DMA : 0,
2608 /*data_ptr*/ (uint8_t *)log_dir,
2609 /*dxfer_len*/sizeof(*log_dir),
2610 /*timeout*/ada_default_timeout*1000);
2611
2612 start_ccb->ccb_h.ccb_state = ADA_CCB_LOGDIR;
2613 xpt_action(start_ccb);
2614 break;
2615 }
2616 case ADA_STATE_IDDIR:
2617 {
2618 struct ata_identify_log_pages *id_dir;
2619
2620 id_dir = malloc(sizeof(*id_dir), M_ATADA, M_NOWAIT | M_ZERO);
2621 if (id_dir == NULL) {
2622 xpt_print(periph->path, "Couldn't malloc id_dir "
2623 "data\n");
2624 adaprobedone(periph, start_ccb);
2625 break;
2626 }
2627
2628 ata_read_log(ataio,
2629 /*retries*/1,
2630 /*cbfcnp*/adadone,
2631 /*log_address*/ ATA_IDENTIFY_DATA_LOG,
2632 /*page_number*/ ATA_IDL_PAGE_LIST,
2633 /*block_count*/ 1,
2634 /*protocol*/ softc->flags & ADA_FLAG_CAN_DMA ?
2635 CAM_ATAIO_DMA : 0,
2636 /*data_ptr*/ (uint8_t *)id_dir,
2637 /*dxfer_len*/ sizeof(*id_dir),
2638 /*timeout*/ada_default_timeout*1000);
2639
2640 start_ccb->ccb_h.ccb_state = ADA_CCB_IDDIR;
2641 xpt_action(start_ccb);
2642 break;
2643 }
2644 case ADA_STATE_SUP_CAP:
2645 {
2646 struct ata_identify_log_sup_cap *sup_cap;
2647
2648 sup_cap = malloc(sizeof(*sup_cap), M_ATADA, M_NOWAIT|M_ZERO);
2649 if (sup_cap == NULL) {
2650 xpt_print(periph->path, "Couldn't malloc sup_cap "
2651 "data\n");
2652 adaprobedone(periph, start_ccb);
2653 break;
2654 }
2655
2656 ata_read_log(ataio,
2657 /*retries*/1,
2658 /*cbfcnp*/adadone,
2659 /*log_address*/ ATA_IDENTIFY_DATA_LOG,
2660 /*page_number*/ ATA_IDL_SUP_CAP,
2661 /*block_count*/ 1,
2662 /*protocol*/ softc->flags & ADA_FLAG_CAN_DMA ?
2663 CAM_ATAIO_DMA : 0,
2664 /*data_ptr*/ (uint8_t *)sup_cap,
2665 /*dxfer_len*/ sizeof(*sup_cap),
2666 /*timeout*/ada_default_timeout*1000);
2667
2668 start_ccb->ccb_h.ccb_state = ADA_CCB_SUP_CAP;
2669 xpt_action(start_ccb);
2670 break;
2671 }
2672 case ADA_STATE_ZONE:
2673 {
2674 struct ata_zoned_info_log *ata_zone;
2675
2676 ata_zone = malloc(sizeof(*ata_zone), M_ATADA, M_NOWAIT|M_ZERO);
2677 if (ata_zone == NULL) {
2678 xpt_print(periph->path, "Couldn't malloc ata_zone "
2679 "data\n");
2680 adaprobedone(periph, start_ccb);
2681 break;
2682 }
2683
2684 ata_read_log(ataio,
2685 /*retries*/1,
2686 /*cbfcnp*/adadone,
2687 /*log_address*/ ATA_IDENTIFY_DATA_LOG,
2688 /*page_number*/ ATA_IDL_ZDI,
2689 /*block_count*/ 1,
2690 /*protocol*/ softc->flags & ADA_FLAG_CAN_DMA ?
2691 CAM_ATAIO_DMA : 0,
2692 /*data_ptr*/ (uint8_t *)ata_zone,
2693 /*dxfer_len*/ sizeof(*ata_zone),
2694 /*timeout*/ada_default_timeout*1000);
2695
2696 start_ccb->ccb_h.ccb_state = ADA_CCB_ZONE;
2697 xpt_action(start_ccb);
2698 break;
2699 }
2700 }
2701 }
2702
2703 static void
adaprobedone(struct cam_periph * periph,union ccb * ccb)2704 adaprobedone(struct cam_periph *periph, union ccb *ccb)
2705 {
2706 struct ada_softc *softc;
2707
2708 softc = (struct ada_softc *)periph->softc;
2709
2710 /*
2711 * Since our peripheral may be invalidated by an error we must release
2712 * our CCB before releasing the reference on the peripheral. The
2713 * peripheral will only go away once the last reference is removed, and
2714 * we need it around for the CCB release operation.
2715 */
2716 if (ccb != NULL)
2717 xpt_release_ccb(ccb);
2718
2719 softc->state = ADA_STATE_NORMAL;
2720 softc->flags |= ADA_FLAG_PROBED;
2721 adaschedule(periph);
2722 if ((softc->flags & ADA_FLAG_ANNOUNCED) == 0) {
2723 softc->flags |= ADA_FLAG_ANNOUNCED;
2724
2725 /*
2726 * We'll release this reference once GEOM calls us back via
2727 * adadiskgonecb(), telling us that our provider has been freed.
2728 */
2729 if (cam_periph_acquire(periph) == 0)
2730 disk_create(softc->disk, DISK_VERSION);
2731
2732 cam_periph_release_boot(periph);
2733 }
2734 cam_periph_release_locked(periph);
2735 }
2736
2737 static void
adazonedone(struct cam_periph * periph,union ccb * ccb)2738 adazonedone(struct cam_periph *periph, union ccb *ccb)
2739 {
2740 struct bio *bp;
2741
2742 bp = (struct bio *)ccb->ccb_h.ccb_bp;
2743
2744 switch (bp->bio_zone.zone_cmd) {
2745 case DISK_ZONE_OPEN:
2746 case DISK_ZONE_CLOSE:
2747 case DISK_ZONE_FINISH:
2748 case DISK_ZONE_RWP:
2749 break;
2750 case DISK_ZONE_REPORT_ZONES: {
2751 uint32_t avail_len;
2752 struct disk_zone_report *rep;
2753 struct scsi_report_zones_hdr *hdr;
2754 struct scsi_report_zones_desc *desc;
2755 struct disk_zone_rep_entry *entry;
2756 uint32_t hdr_len, num_avail;
2757 uint32_t num_to_fill, i;
2758
2759 rep = &bp->bio_zone.zone_params.report;
2760 avail_len = ccb->ataio.dxfer_len - ccb->ataio.resid;
2761 /*
2762 * Note that bio_resid isn't normally used for zone
2763 * commands, but it is used by devstat_end_transaction_bio()
2764 * to determine how much data was transferred. Because
2765 * the size of the SCSI/ATA data structures is different
2766 * than the size of the BIO interface structures, the
2767 * amount of data actually transferred from the drive will
2768 * be different than the amount of data transferred to
2769 * the user.
2770 */
2771 hdr = (struct scsi_report_zones_hdr *)ccb->ataio.data_ptr;
2772 if (avail_len < sizeof(*hdr)) {
2773 /*
2774 * Is there a better error than EIO here? We asked
2775 * for at least the header, and we got less than
2776 * that.
2777 */
2778 bp->bio_error = EIO;
2779 bp->bio_flags |= BIO_ERROR;
2780 bp->bio_resid = bp->bio_bcount;
2781 break;
2782 }
2783
2784 hdr_len = le32dec(hdr->length);
2785 if (hdr_len > 0)
2786 rep->entries_available = hdr_len / sizeof(*desc);
2787 else
2788 rep->entries_available = 0;
2789 /*
2790 * NOTE: using the same values for the BIO version of the
2791 * same field as the SCSI/ATA values. This means we could
2792 * get some additional values that aren't defined in bio.h
2793 * if more values of the same field are defined later.
2794 */
2795 rep->header.same = hdr->byte4 & SRZ_SAME_MASK;
2796 rep->header.maximum_lba = le64dec(hdr->maximum_lba);
2797 /*
2798 * If the drive reports no entries that match the query,
2799 * we're done.
2800 */
2801 if (hdr_len == 0) {
2802 rep->entries_filled = 0;
2803 bp->bio_resid = bp->bio_bcount;
2804 break;
2805 }
2806
2807 num_avail = min((avail_len - sizeof(*hdr)) / sizeof(*desc),
2808 hdr_len / sizeof(*desc));
2809 /*
2810 * If the drive didn't return any data, then we're done.
2811 */
2812 if (num_avail == 0) {
2813 rep->entries_filled = 0;
2814 bp->bio_resid = bp->bio_bcount;
2815 break;
2816 }
2817
2818 num_to_fill = min(num_avail, rep->entries_allocated);
2819 /*
2820 * If the user didn't allocate any entries for us to fill,
2821 * we're done.
2822 */
2823 if (num_to_fill == 0) {
2824 rep->entries_filled = 0;
2825 bp->bio_resid = bp->bio_bcount;
2826 break;
2827 }
2828
2829 for (i = 0, desc = &hdr->desc_list[0], entry=&rep->entries[0];
2830 i < num_to_fill; i++, desc++, entry++) {
2831 /*
2832 * NOTE: we're mapping the values here directly
2833 * from the SCSI/ATA bit definitions to the bio.h
2834 * definitions. There is also a warning in
2835 * disk_zone.h, but the impact is that if
2836 * additional values are added in the SCSI/ATA
2837 * specs these will be visible to consumers of
2838 * this interface.
2839 */
2840 entry->zone_type = desc->zone_type & SRZ_TYPE_MASK;
2841 entry->zone_condition =
2842 (desc->zone_flags & SRZ_ZONE_COND_MASK) >>
2843 SRZ_ZONE_COND_SHIFT;
2844 entry->zone_flags |= desc->zone_flags &
2845 (SRZ_ZONE_NON_SEQ|SRZ_ZONE_RESET);
2846 entry->zone_length = le64dec(desc->zone_length);
2847 entry->zone_start_lba = le64dec(desc->zone_start_lba);
2848 entry->write_pointer_lba =
2849 le64dec(desc->write_pointer_lba);
2850 }
2851 rep->entries_filled = num_to_fill;
2852 /*
2853 * Note that this residual is accurate from the user's
2854 * standpoint, but the amount transferred isn't accurate
2855 * from the standpoint of what actually came back from the
2856 * drive.
2857 */
2858 bp->bio_resid = bp->bio_bcount - (num_to_fill * sizeof(*entry));
2859 break;
2860 }
2861 case DISK_ZONE_GET_PARAMS:
2862 default:
2863 /*
2864 * In theory we should not get a GET_PARAMS bio, since it
2865 * should be handled without queueing the command to the
2866 * drive.
2867 */
2868 panic("%s: Invalid zone command %d", __func__,
2869 bp->bio_zone.zone_cmd);
2870 break;
2871 }
2872
2873 if (bp->bio_zone.zone_cmd == DISK_ZONE_REPORT_ZONES)
2874 free(ccb->ataio.data_ptr, M_ATADA);
2875 }
2876
2877 static void
adadone(struct cam_periph * periph,union ccb * done_ccb)2878 adadone(struct cam_periph *periph, union ccb *done_ccb)
2879 {
2880 struct ada_softc *softc;
2881 struct ccb_ataio *ataio;
2882 struct cam_path *path;
2883 uint32_t priority;
2884 int state;
2885
2886 softc = (struct ada_softc *)periph->softc;
2887 ataio = &done_ccb->ataio;
2888 path = done_ccb->ccb_h.path;
2889 priority = done_ccb->ccb_h.pinfo.priority;
2890
2891 CAM_DEBUG(path, CAM_DEBUG_TRACE, ("adadone\n"));
2892
2893 state = ataio->ccb_h.ccb_state & ADA_CCB_TYPE_MASK;
2894 switch (state) {
2895 case ADA_CCB_BUFFER_IO:
2896 case ADA_CCB_TRIM:
2897 {
2898 struct bio *bp;
2899 int error;
2900
2901 cam_periph_lock(periph);
2902 bp = (struct bio *)done_ccb->ccb_h.ccb_bp;
2903 if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
2904 error = adaerror(done_ccb, CAM_RETRY_SELTO, 0);
2905 if (error == ERESTART) {
2906 /* A retry was scheduled, so just return. */
2907 cam_periph_unlock(periph);
2908 return;
2909 }
2910 if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0)
2911 cam_release_devq(path,
2912 /*relsim_flags*/0,
2913 /*reduction*/0,
2914 /*timeout*/0,
2915 /*getcount_only*/0);
2916 /*
2917 * If we get an error on an NCQ DSM TRIM, fall back
2918 * to a non-NCQ DSM TRIM forever. Please note that if
2919 * CAN_NCQ_TRIM is set, CAN_TRIM is necessarily set too.
2920 * However, for this one trim, we treat it as advisory
2921 * and return success up the stack.
2922 */
2923 if (state == ADA_CCB_TRIM &&
2924 error != 0 &&
2925 (softc->flags & ADA_FLAG_CAN_NCQ_TRIM) != 0) {
2926 softc->flags &= ~ADA_FLAG_CAN_NCQ_TRIM;
2927 error = 0;
2928 adasetdeletemethod(softc);
2929 }
2930 } else {
2931 if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0)
2932 panic("REQ_CMP with QFRZN");
2933
2934 error = 0;
2935 }
2936 bp->bio_error = error;
2937 if (error != 0) {
2938 bp->bio_resid = bp->bio_bcount;
2939 bp->bio_flags |= BIO_ERROR;
2940 } else {
2941 if (bp->bio_cmd == BIO_ZONE)
2942 adazonedone(periph, done_ccb);
2943 else if (state == ADA_CCB_TRIM)
2944 bp->bio_resid = 0;
2945 else
2946 bp->bio_resid = ataio->resid;
2947
2948 if ((bp->bio_resid > 0)
2949 && (bp->bio_cmd != BIO_ZONE))
2950 bp->bio_flags |= BIO_ERROR;
2951 }
2952 softc->outstanding_cmds--;
2953 if (softc->outstanding_cmds == 0)
2954 softc->flags |= ADA_FLAG_WAS_OTAG;
2955
2956 /*
2957 * We need to call cam_iosched before we call biodone so that we
2958 * don't measure any activity that happens in the completion
2959 * routine, which in the case of sendfile can be quite
2960 * extensive. Release the periph refcount taken in adastart()
2961 * for each CCB.
2962 */
2963 cam_iosched_bio_complete(softc->cam_iosched, bp, done_ccb);
2964 xpt_release_ccb(done_ccb);
2965 KASSERT(softc->refcount >= 1, ("adadone softc %p refcount %d", softc, softc->refcount));
2966 softc->refcount--;
2967 if (state == ADA_CCB_TRIM) {
2968 TAILQ_HEAD(, bio) queue;
2969 struct bio *bp1;
2970
2971 TAILQ_INIT(&queue);
2972 TAILQ_CONCAT(&queue, &softc->trim_req.bps, bio_queue);
2973 /*
2974 * Normally, the xpt_release_ccb() above would make sure
2975 * that when we have more work to do, that work would
2976 * get kicked off. However, we specifically keep
2977 * trim_running set to 0 before the call above to allow
2978 * other I/O to progress when many BIO_DELETE requests
2979 * are pushed down. We set trim_running to 0 and call
2980 * daschedule again so that we don't stall if there are
2981 * no other I/Os pending apart from BIO_DELETEs.
2982 */
2983 cam_iosched_trim_done(softc->cam_iosched);
2984 adaschedule(periph);
2985 cam_periph_unlock(periph);
2986 while ((bp1 = TAILQ_FIRST(&queue)) != NULL) {
2987 TAILQ_REMOVE(&queue, bp1, bio_queue);
2988 bp1->bio_error = error;
2989 if (error != 0) {
2990 bp1->bio_flags |= BIO_ERROR;
2991 bp1->bio_resid = bp1->bio_bcount;
2992 } else
2993 bp1->bio_resid = 0;
2994 biodone(bp1);
2995 }
2996 } else {
2997 adaschedule(periph);
2998 cam_periph_unlock(periph);
2999 biodone(bp);
3000 }
3001 return;
3002 }
3003 case ADA_CCB_RAHEAD:
3004 {
3005 if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
3006 if (adaerror(done_ccb, 0, 0) == ERESTART) {
3007 /* Drop freeze taken due to CAM_DEV_QFREEZE */
3008 cam_release_devq(path, 0, 0, 0, FALSE);
3009 return;
3010 } else if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
3011 cam_release_devq(path,
3012 /*relsim_flags*/0,
3013 /*reduction*/0,
3014 /*timeout*/0,
3015 /*getcount_only*/0);
3016 }
3017 }
3018
3019 xpt_release_ccb(done_ccb);
3020 softc->state = ADA_STATE_WCACHE;
3021 xpt_schedule(periph, priority);
3022 /* Drop freeze taken due to CAM_DEV_QFREEZE */
3023 cam_release_devq(path, 0, 0, 0, FALSE);
3024 return;
3025 }
3026 case ADA_CCB_WCACHE:
3027 {
3028 if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
3029 if (adaerror(done_ccb, 0, 0) == ERESTART) {
3030 /* Drop freeze taken due to CAM_DEV_QFREEZE */
3031 cam_release_devq(path, 0, 0, 0, FALSE);
3032 return;
3033 } else if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
3034 cam_release_devq(path,
3035 /*relsim_flags*/0,
3036 /*reduction*/0,
3037 /*timeout*/0,
3038 /*getcount_only*/0);
3039 }
3040 }
3041
3042 /* Drop freeze taken due to CAM_DEV_QFREEZE */
3043 cam_release_devq(path, 0, 0, 0, FALSE);
3044
3045 if ((softc->flags & ADA_FLAG_CAN_LOG)
3046 && (softc->zone_mode != ADA_ZONE_NONE)) {
3047 xpt_release_ccb(done_ccb);
3048 softc->state = ADA_STATE_LOGDIR;
3049 xpt_schedule(periph, priority);
3050 } else {
3051 adaprobedone(periph, done_ccb);
3052 }
3053 return;
3054 }
3055 case ADA_CCB_LOGDIR:
3056 {
3057 int error;
3058
3059 if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
3060 error = 0;
3061 softc->valid_logdir_len = 0;
3062 bzero(&softc->ata_logdir, sizeof(softc->ata_logdir));
3063 softc->valid_logdir_len =
3064 ataio->dxfer_len - ataio->resid;
3065 if (softc->valid_logdir_len > 0)
3066 bcopy(ataio->data_ptr, &softc->ata_logdir,
3067 min(softc->valid_logdir_len,
3068 sizeof(softc->ata_logdir)));
3069 /*
3070 * Figure out whether the Identify Device log is
3071 * supported. The General Purpose log directory
3072 * has a header, and lists the number of pages
3073 * available for each GP log identified by the
3074 * offset into the list.
3075 */
3076 if ((softc->valid_logdir_len >=
3077 ((ATA_IDENTIFY_DATA_LOG + 1) * sizeof(uint16_t)))
3078 && (le16dec(softc->ata_logdir.header) ==
3079 ATA_GP_LOG_DIR_VERSION)
3080 && (le16dec(&softc->ata_logdir.num_pages[
3081 (ATA_IDENTIFY_DATA_LOG *
3082 sizeof(uint16_t)) - sizeof(uint16_t)]) > 0)){
3083 softc->flags |= ADA_FLAG_CAN_IDLOG;
3084 } else {
3085 softc->flags &= ~ADA_FLAG_CAN_IDLOG;
3086 }
3087 } else {
3088 error = adaerror(done_ccb, CAM_RETRY_SELTO,
3089 SF_RETRY_UA|SF_NO_PRINT);
3090 if (error == ERESTART)
3091 return;
3092 else if (error != 0) {
3093 /*
3094 * If we can't get the ATA log directory,
3095 * then ATA logs are effectively not
3096 * supported even if the bit is set in the
3097 * identify data.
3098 */
3099 softc->flags &= ~(ADA_FLAG_CAN_LOG |
3100 ADA_FLAG_CAN_IDLOG);
3101 if ((done_ccb->ccb_h.status &
3102 CAM_DEV_QFRZN) != 0) {
3103 /* Don't wedge this device's queue */
3104 cam_release_devq(done_ccb->ccb_h.path,
3105 /*relsim_flags*/0,
3106 /*reduction*/0,
3107 /*timeout*/0,
3108 /*getcount_only*/0);
3109 }
3110 }
3111 }
3112
3113 free(ataio->data_ptr, M_ATADA);
3114
3115 if ((error == 0)
3116 && (softc->flags & ADA_FLAG_CAN_IDLOG)) {
3117 softc->state = ADA_STATE_IDDIR;
3118 xpt_release_ccb(done_ccb);
3119 xpt_schedule(periph, priority);
3120 } else
3121 adaprobedone(periph, done_ccb);
3122
3123 return;
3124 }
3125 case ADA_CCB_IDDIR: {
3126 int error;
3127
3128 if ((ataio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
3129 off_t entries_offset, max_entries;
3130 error = 0;
3131
3132 softc->valid_iddir_len = 0;
3133 bzero(&softc->ata_iddir, sizeof(softc->ata_iddir));
3134 softc->flags &= ~(ADA_FLAG_CAN_SUPCAP |
3135 ADA_FLAG_CAN_ZONE);
3136 softc->valid_iddir_len =
3137 ataio->dxfer_len - ataio->resid;
3138 if (softc->valid_iddir_len > 0)
3139 bcopy(ataio->data_ptr, &softc->ata_iddir,
3140 min(softc->valid_iddir_len,
3141 sizeof(softc->ata_iddir)));
3142
3143 entries_offset =
3144 __offsetof(struct ata_identify_log_pages,entries);
3145 max_entries = softc->valid_iddir_len - entries_offset;
3146 if ((softc->valid_iddir_len > (entries_offset + 1))
3147 && (le64dec(softc->ata_iddir.header) ==
3148 ATA_IDLOG_REVISION)
3149 && (softc->ata_iddir.entry_count > 0)) {
3150 int num_entries, i;
3151
3152 num_entries = softc->ata_iddir.entry_count;
3153 num_entries = min(num_entries,
3154 softc->valid_iddir_len - entries_offset);
3155 for (i = 0; i < num_entries &&
3156 i < max_entries; i++) {
3157 if (softc->ata_iddir.entries[i] ==
3158 ATA_IDL_SUP_CAP)
3159 softc->flags |=
3160 ADA_FLAG_CAN_SUPCAP;
3161 else if (softc->ata_iddir.entries[i]==
3162 ATA_IDL_ZDI)
3163 softc->flags |=
3164 ADA_FLAG_CAN_ZONE;
3165
3166 if ((softc->flags &
3167 ADA_FLAG_CAN_SUPCAP)
3168 && (softc->flags &
3169 ADA_FLAG_CAN_ZONE))
3170 break;
3171 }
3172 }
3173 } else {
3174 error = adaerror(done_ccb, CAM_RETRY_SELTO,
3175 SF_RETRY_UA|SF_NO_PRINT);
3176 if (error == ERESTART)
3177 return;
3178 else if (error != 0) {
3179 /*
3180 * If we can't get the ATA Identify Data log
3181 * directory, then it effectively isn't
3182 * supported even if the ATA Log directory
3183 * a non-zero number of pages present for
3184 * this log.
3185 */
3186 softc->flags &= ~ADA_FLAG_CAN_IDLOG;
3187 if ((done_ccb->ccb_h.status &
3188 CAM_DEV_QFRZN) != 0) {
3189 /* Don't wedge this device's queue */
3190 cam_release_devq(done_ccb->ccb_h.path,
3191 /*relsim_flags*/0,
3192 /*reduction*/0,
3193 /*timeout*/0,
3194 /*getcount_only*/0);
3195 }
3196 }
3197 }
3198
3199 free(ataio->data_ptr, M_ATADA);
3200
3201 if ((error == 0)
3202 && (softc->flags & ADA_FLAG_CAN_SUPCAP)) {
3203 softc->state = ADA_STATE_SUP_CAP;
3204 xpt_release_ccb(done_ccb);
3205 xpt_schedule(periph, priority);
3206 } else
3207 adaprobedone(periph, done_ccb);
3208 return;
3209 }
3210 case ADA_CCB_SUP_CAP: {
3211 int error;
3212
3213 if ((ataio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
3214 uint32_t valid_len;
3215 size_t needed_size;
3216 struct ata_identify_log_sup_cap *sup_cap;
3217 error = 0;
3218
3219 sup_cap = (struct ata_identify_log_sup_cap *)
3220 ataio->data_ptr;
3221 valid_len = ataio->dxfer_len - ataio->resid;
3222 needed_size =
3223 __offsetof(struct ata_identify_log_sup_cap,
3224 sup_zac_cap) + 1 + sizeof(sup_cap->sup_zac_cap);
3225 if (valid_len >= needed_size) {
3226 uint64_t zoned, zac_cap;
3227
3228 zoned = le64dec(sup_cap->zoned_cap);
3229 if (zoned & ATA_ZONED_VALID) {
3230 /*
3231 * This should have already been
3232 * set, because this is also in the
3233 * ATA identify data.
3234 */
3235 if ((zoned & ATA_ZONED_MASK) ==
3236 ATA_SUPPORT_ZONE_HOST_AWARE)
3237 softc->zone_mode =
3238 ADA_ZONE_HOST_AWARE;
3239 else if ((zoned & ATA_ZONED_MASK) ==
3240 ATA_SUPPORT_ZONE_DEV_MANAGED)
3241 softc->zone_mode =
3242 ADA_ZONE_DRIVE_MANAGED;
3243 }
3244
3245 zac_cap = le64dec(sup_cap->sup_zac_cap);
3246 if (zac_cap & ATA_SUP_ZAC_CAP_VALID) {
3247 if (zac_cap & ATA_REPORT_ZONES_SUP)
3248 softc->zone_flags |=
3249 ADA_ZONE_FLAG_RZ_SUP;
3250 if (zac_cap & ATA_ND_OPEN_ZONE_SUP)
3251 softc->zone_flags |=
3252 ADA_ZONE_FLAG_OPEN_SUP;
3253 if (zac_cap & ATA_ND_CLOSE_ZONE_SUP)
3254 softc->zone_flags |=
3255 ADA_ZONE_FLAG_CLOSE_SUP;
3256 if (zac_cap & ATA_ND_FINISH_ZONE_SUP)
3257 softc->zone_flags |=
3258 ADA_ZONE_FLAG_FINISH_SUP;
3259 if (zac_cap & ATA_ND_RWP_SUP)
3260 softc->zone_flags |=
3261 ADA_ZONE_FLAG_RWP_SUP;
3262 } else {
3263 /*
3264 * This field was introduced in
3265 * ACS-4, r08 on April 28th, 2015.
3266 * If the drive firmware was written
3267 * to an earlier spec, it won't have
3268 * the field. So, assume all
3269 * commands are supported.
3270 */
3271 softc->zone_flags |=
3272 ADA_ZONE_FLAG_SUP_MASK;
3273 }
3274 }
3275 } else {
3276 error = adaerror(done_ccb, CAM_RETRY_SELTO,
3277 SF_RETRY_UA|SF_NO_PRINT);
3278 if (error == ERESTART)
3279 return;
3280 else if (error != 0) {
3281 /*
3282 * If we can't get the ATA Identify Data
3283 * Supported Capabilities page, clear the
3284 * flag...
3285 */
3286 softc->flags &= ~ADA_FLAG_CAN_SUPCAP;
3287 /*
3288 * And clear zone capabilities.
3289 */
3290 softc->zone_flags &= ~ADA_ZONE_FLAG_SUP_MASK;
3291 if ((done_ccb->ccb_h.status &
3292 CAM_DEV_QFRZN) != 0) {
3293 /* Don't wedge this device's queue */
3294 cam_release_devq(done_ccb->ccb_h.path,
3295 /*relsim_flags*/0,
3296 /*reduction*/0,
3297 /*timeout*/0,
3298 /*getcount_only*/0);
3299 }
3300 }
3301 }
3302
3303 free(ataio->data_ptr, M_ATADA);
3304
3305 if ((error == 0)
3306 && (softc->flags & ADA_FLAG_CAN_ZONE)) {
3307 softc->state = ADA_STATE_ZONE;
3308 xpt_release_ccb(done_ccb);
3309 xpt_schedule(periph, priority);
3310 } else
3311 adaprobedone(periph, done_ccb);
3312 return;
3313 }
3314 case ADA_CCB_ZONE: {
3315 int error;
3316
3317 if ((ataio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
3318 struct ata_zoned_info_log *zi_log;
3319 uint32_t valid_len;
3320 size_t needed_size;
3321
3322 zi_log = (struct ata_zoned_info_log *)ataio->data_ptr;
3323
3324 valid_len = ataio->dxfer_len - ataio->resid;
3325 needed_size = __offsetof(struct ata_zoned_info_log,
3326 version_info) + 1 + sizeof(zi_log->version_info);
3327 if (valid_len >= needed_size) {
3328 uint64_t tmpvar;
3329
3330 tmpvar = le64dec(zi_log->zoned_cap);
3331 if (tmpvar & ATA_ZDI_CAP_VALID) {
3332 if (tmpvar & ATA_ZDI_CAP_URSWRZ)
3333 softc->zone_flags |=
3334 ADA_ZONE_FLAG_URSWRZ;
3335 else
3336 softc->zone_flags &=
3337 ~ADA_ZONE_FLAG_URSWRZ;
3338 }
3339 tmpvar = le64dec(zi_log->optimal_seq_zones);
3340 if (tmpvar & ATA_ZDI_OPT_SEQ_VALID) {
3341 softc->zone_flags |=
3342 ADA_ZONE_FLAG_OPT_SEQ_SET;
3343 softc->optimal_seq_zones = (tmpvar &
3344 ATA_ZDI_OPT_SEQ_MASK);
3345 } else {
3346 softc->zone_flags &=
3347 ~ADA_ZONE_FLAG_OPT_SEQ_SET;
3348 softc->optimal_seq_zones = 0;
3349 }
3350
3351 tmpvar =le64dec(zi_log->optimal_nonseq_zones);
3352 if (tmpvar & ATA_ZDI_OPT_NS_VALID) {
3353 softc->zone_flags |=
3354 ADA_ZONE_FLAG_OPT_NONSEQ_SET;
3355 softc->optimal_nonseq_zones =
3356 (tmpvar & ATA_ZDI_OPT_NS_MASK);
3357 } else {
3358 softc->zone_flags &=
3359 ~ADA_ZONE_FLAG_OPT_NONSEQ_SET;
3360 softc->optimal_nonseq_zones = 0;
3361 }
3362
3363 tmpvar = le64dec(zi_log->max_seq_req_zones);
3364 if (tmpvar & ATA_ZDI_MAX_SEQ_VALID) {
3365 softc->zone_flags |=
3366 ADA_ZONE_FLAG_MAX_SEQ_SET;
3367 softc->max_seq_zones =
3368 (tmpvar & ATA_ZDI_MAX_SEQ_MASK);
3369 } else {
3370 softc->zone_flags &=
3371 ~ADA_ZONE_FLAG_MAX_SEQ_SET;
3372 softc->max_seq_zones = 0;
3373 }
3374 }
3375 } else {
3376 error = adaerror(done_ccb, CAM_RETRY_SELTO,
3377 SF_RETRY_UA|SF_NO_PRINT);
3378 if (error == ERESTART)
3379 return;
3380 else if (error != 0) {
3381 softc->flags &= ~ADA_FLAG_CAN_ZONE;
3382 softc->flags &= ~ADA_ZONE_FLAG_SET_MASK;
3383
3384 if ((done_ccb->ccb_h.status &
3385 CAM_DEV_QFRZN) != 0) {
3386 /* Don't wedge this device's queue */
3387 cam_release_devq(done_ccb->ccb_h.path,
3388 /*relsim_flags*/0,
3389 /*reduction*/0,
3390 /*timeout*/0,
3391 /*getcount_only*/0);
3392 }
3393 }
3394 }
3395 free(ataio->data_ptr, M_ATADA);
3396
3397 adaprobedone(periph, done_ccb);
3398 return;
3399 }
3400 case ADA_CCB_DUMP:
3401 /* No-op. We're polling */
3402 return;
3403 default:
3404 break;
3405 }
3406 xpt_release_ccb(done_ccb);
3407 }
3408
3409 static int
adaerror(union ccb * ccb,uint32_t cam_flags,uint32_t sense_flags)3410 adaerror(union ccb *ccb, uint32_t cam_flags, uint32_t sense_flags)
3411 {
3412 #ifdef CAM_IO_STATS
3413 struct ada_softc *softc;
3414 struct cam_periph *periph;
3415
3416 periph = xpt_path_periph(ccb->ccb_h.path);
3417 softc = (struct ada_softc *)periph->softc;
3418
3419 switch (ccb->ccb_h.status & CAM_STATUS_MASK) {
3420 case CAM_CMD_TIMEOUT:
3421 softc->timeouts++;
3422 break;
3423 case CAM_REQ_ABORTED:
3424 case CAM_REQ_CMP_ERR:
3425 case CAM_REQ_TERMIO:
3426 case CAM_UNREC_HBA_ERROR:
3427 case CAM_DATA_RUN_ERR:
3428 case CAM_ATA_STATUS_ERROR:
3429 softc->errors++;
3430 break;
3431 default:
3432 break;
3433 }
3434 #endif
3435
3436 return(cam_periph_error(ccb, cam_flags, sense_flags));
3437 }
3438
3439 static void
adasetgeom(struct ada_softc * softc,struct ccb_getdev * cgd)3440 adasetgeom(struct ada_softc *softc, struct ccb_getdev *cgd)
3441 {
3442 struct disk_params *dp = &softc->params;
3443 uint64_t lbasize48;
3444 uint32_t lbasize;
3445 u_int maxio, d_flags;
3446 size_t tmpsize;
3447
3448 dp->secsize = ata_logical_sector_size(&cgd->ident_data);
3449 if ((cgd->ident_data.atavalid & ATA_FLAG_54_58) &&
3450 cgd->ident_data.current_heads != 0 &&
3451 cgd->ident_data.current_sectors != 0) {
3452 dp->heads = cgd->ident_data.current_heads;
3453 dp->secs_per_track = cgd->ident_data.current_sectors;
3454 dp->cylinders = cgd->ident_data.cylinders;
3455 dp->sectors = (uint32_t)cgd->ident_data.current_size_1 |
3456 ((uint32_t)cgd->ident_data.current_size_2 << 16);
3457 } else {
3458 dp->heads = cgd->ident_data.heads;
3459 dp->secs_per_track = cgd->ident_data.sectors;
3460 dp->cylinders = cgd->ident_data.cylinders;
3461 dp->sectors = cgd->ident_data.cylinders *
3462 (uint32_t)(dp->heads * dp->secs_per_track);
3463 }
3464 lbasize = (uint32_t)cgd->ident_data.lba_size_1 |
3465 ((uint32_t)cgd->ident_data.lba_size_2 << 16);
3466
3467 /* use the 28bit LBA size if valid or bigger than the CHS mapping */
3468 if (cgd->ident_data.cylinders == 16383 || dp->sectors < lbasize)
3469 dp->sectors = lbasize;
3470
3471 /* use the 48bit LBA size if valid */
3472 lbasize48 = ((uint64_t)cgd->ident_data.lba_size48_1) |
3473 ((uint64_t)cgd->ident_data.lba_size48_2 << 16) |
3474 ((uint64_t)cgd->ident_data.lba_size48_3 << 32) |
3475 ((uint64_t)cgd->ident_data.lba_size48_4 << 48);
3476 if ((cgd->ident_data.support.command2 & ATA_SUPPORT_ADDRESS48) &&
3477 lbasize48 > ATA_MAX_28BIT_LBA)
3478 dp->sectors = lbasize48;
3479
3480 maxio = softc->cpi.maxio; /* Honor max I/O size of SIM */
3481 if (maxio == 0)
3482 maxio = DFLTPHYS; /* traditional default */
3483 else if (maxio > maxphys)
3484 maxio = maxphys; /* for safety */
3485 if (softc->flags & ADA_FLAG_CAN_48BIT)
3486 maxio = min(maxio, 65536 * softc->params.secsize);
3487 else /* 28bit ATA command limit */
3488 maxio = min(maxio, 256 * softc->params.secsize);
3489 if (softc->quirks & ADA_Q_128KB)
3490 maxio = min(maxio, 128 * 1024);
3491 softc->disk->d_maxsize = maxio;
3492 d_flags = DISKFLAG_DIRECT_COMPLETION | DISKFLAG_CANZONE;
3493 if (softc->flags & ADA_FLAG_CAN_FLUSHCACHE)
3494 d_flags |= DISKFLAG_CANFLUSHCACHE;
3495 if (softc->flags & ADA_FLAG_CAN_TRIM) {
3496 d_flags |= DISKFLAG_CANDELETE;
3497 softc->disk->d_delmaxsize = softc->params.secsize *
3498 ATA_DSM_RANGE_MAX * softc->trim_max_ranges;
3499 } else if ((softc->flags & ADA_FLAG_CAN_CFA) &&
3500 !(softc->flags & ADA_FLAG_CAN_48BIT)) {
3501 d_flags |= DISKFLAG_CANDELETE;
3502 softc->disk->d_delmaxsize = 256 * softc->params.secsize;
3503 } else
3504 softc->disk->d_delmaxsize = maxio;
3505 if ((softc->cpi.hba_misc & PIM_UNMAPPED) != 0) {
3506 d_flags |= DISKFLAG_UNMAPPED_BIO;
3507 softc->flags |= ADA_FLAG_UNMAPPEDIO;
3508 }
3509 softc->disk->d_flags = d_flags;
3510
3511 /*
3512 * ata_param_fixup will strip trailing padding spaces and add a NUL,
3513 * but if the field has no padding (as is common for serial numbers)
3514 * there will still be no NUL terminator. We cannot use strlcpy, since
3515 * it keeps reading src until it finds a NUL in order to compute the
3516 * return value (and will truncate the final character due to having a
3517 * single dsize rather than separate ssize and dsize), and strncpy does
3518 * not add a NUL to the destination if it reaches the character limit.
3519 */
3520 tmpsize = MIN(sizeof(softc->disk->d_descr) - 1,
3521 sizeof(cgd->ident_data.model));
3522 memcpy(softc->disk->d_descr, cgd->ident_data.model, tmpsize);
3523 softc->disk->d_descr[tmpsize] = '\0';
3524
3525 tmpsize = MIN(sizeof(softc->disk->d_ident) - 1,
3526 sizeof(cgd->ident_data.serial));
3527 memcpy(softc->disk->d_ident, cgd->ident_data.serial, tmpsize);
3528 softc->disk->d_ident[tmpsize] = '\0';
3529
3530 softc->disk->d_sectorsize = softc->params.secsize;
3531 softc->disk->d_mediasize = (off_t)softc->params.sectors *
3532 softc->params.secsize;
3533 if (ata_physical_sector_size(&cgd->ident_data) !=
3534 softc->params.secsize) {
3535 softc->disk->d_stripesize =
3536 ata_physical_sector_size(&cgd->ident_data);
3537 softc->disk->d_stripeoffset = (softc->disk->d_stripesize -
3538 ata_logical_sector_offset(&cgd->ident_data)) %
3539 softc->disk->d_stripesize;
3540 } else if (softc->quirks & ADA_Q_4K) {
3541 softc->disk->d_stripesize = 4096;
3542 softc->disk->d_stripeoffset = 0;
3543 }
3544 softc->disk->d_fwsectors = softc->params.secs_per_track;
3545 softc->disk->d_fwheads = softc->params.heads;
3546 softc->disk->d_rotation_rate = cgd->ident_data.media_rotation_rate;
3547 snprintf(softc->disk->d_attachment, sizeof(softc->disk->d_attachment),
3548 "%s%d", softc->cpi.dev_name, softc->cpi.unit_number);
3549 }
3550
3551 static void
adasendorderedtag(void * arg)3552 adasendorderedtag(void *arg)
3553 {
3554 struct ada_softc *softc = arg;
3555
3556 if (ada_send_ordered) {
3557 if (softc->outstanding_cmds > 0) {
3558 if ((softc->flags & ADA_FLAG_WAS_OTAG) == 0)
3559 softc->flags |= ADA_FLAG_NEED_OTAG;
3560 softc->flags &= ~ADA_FLAG_WAS_OTAG;
3561 }
3562 }
3563
3564 /* Queue us up again */
3565 callout_schedule_sbt(&softc->sendordered_c,
3566 SBT_1S / ADA_ORDEREDTAG_INTERVAL * ada_default_timeout, 0,
3567 C_PREL(1));
3568 }
3569
3570 /*
3571 * Step through all ADA peripheral drivers, and if the device is still open,
3572 * sync the disk cache to physical media.
3573 */
3574 static void
adaflush(void)3575 adaflush(void)
3576 {
3577 struct cam_periph *periph;
3578 struct ada_softc *softc;
3579 union ccb *ccb;
3580 int error;
3581
3582 CAM_PERIPH_FOREACH(periph, &adadriver) {
3583 softc = (struct ada_softc *)periph->softc;
3584 if (SCHEDULER_STOPPED()) {
3585 /* If we panicked with the lock held, do not recurse. */
3586 if (!cam_periph_owned(periph) &&
3587 (softc->flags & ADA_FLAG_OPEN)) {
3588 adadump(softc->disk, NULL, 0, 0);
3589 }
3590 continue;
3591 }
3592 cam_periph_lock(periph);
3593 /*
3594 * We only sync the cache if the drive is still open, and
3595 * if the drive is capable of it..
3596 */
3597 if (((softc->flags & ADA_FLAG_OPEN) == 0) ||
3598 (softc->flags & ADA_FLAG_CAN_FLUSHCACHE) == 0) {
3599 cam_periph_unlock(periph);
3600 continue;
3601 }
3602
3603 ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
3604 cam_fill_ataio(&ccb->ataio,
3605 0,
3606 NULL,
3607 CAM_DIR_NONE,
3608 0,
3609 NULL,
3610 0,
3611 ada_default_timeout*1000);
3612 if (softc->flags & ADA_FLAG_CAN_48BIT)
3613 ata_48bit_cmd(&ccb->ataio, ATA_FLUSHCACHE48, 0, 0, 0);
3614 else
3615 ata_28bit_cmd(&ccb->ataio, ATA_FLUSHCACHE, 0, 0, 0);
3616
3617 error = cam_periph_runccb(ccb, adaerror, /*cam_flags*/0,
3618 /*sense_flags*/ SF_NO_RECOVERY | SF_NO_RETRY,
3619 softc->disk->d_devstat);
3620 if (error != 0)
3621 xpt_print(periph->path, "Synchronize cache failed\n");
3622 xpt_release_ccb(ccb);
3623 cam_periph_unlock(periph);
3624 }
3625 }
3626
3627 static void
adaspindown(uint8_t cmd,int flags)3628 adaspindown(uint8_t cmd, int flags)
3629 {
3630 struct cam_periph *periph;
3631 struct ada_softc *softc;
3632 struct ccb_ataio local_ccb;
3633 int error;
3634 int mode;
3635
3636 CAM_PERIPH_FOREACH(periph, &adadriver) {
3637 /* If we panicked with lock held - not recurse here. */
3638 if (cam_periph_owned(periph))
3639 continue;
3640 cam_periph_lock(periph);
3641 softc = (struct ada_softc *)periph->softc;
3642 /*
3643 * We only spin-down the drive if it is capable of it..
3644 */
3645 if ((softc->flags & ADA_FLAG_CAN_POWERMGT) == 0) {
3646 cam_periph_unlock(periph);
3647 continue;
3648 }
3649
3650 /*
3651 * Additionally check if we would spin up the drive instead of
3652 * spinning it down.
3653 */
3654 if (cmd == ATA_IDLE_IMMEDIATE) {
3655 memset(&local_ccb, 0, sizeof(local_ccb));
3656 xpt_setup_ccb(&local_ccb.ccb_h, periph->path,
3657 CAM_PRIORITY_NORMAL);
3658 local_ccb.ccb_h.ccb_state = ADA_CCB_DUMP;
3659
3660 cam_fill_ataio(&local_ccb, 0, NULL, CAM_DIR_NONE,
3661 0, NULL, 0, ada_default_timeout * 1000);
3662 ata_28bit_cmd(&local_ccb, ATA_CHECK_POWER_MODE,
3663 0, 0, 0);
3664 local_ccb.cmd.flags |= CAM_ATAIO_NEEDRESULT;
3665
3666 error = cam_periph_runccb((union ccb *)&local_ccb,
3667 adaerror, /*cam_flags*/0,
3668 /*sense_flags*/ SF_NO_RECOVERY | SF_NO_RETRY,
3669 softc->disk->d_devstat);
3670 if (error != 0) {
3671 xpt_print(periph->path,
3672 "Failed to read current power mode\n");
3673 } else {
3674 mode = local_ccb.res.sector_count;
3675 #ifdef DIAGNOSTIC
3676 if (bootverbose) {
3677 xpt_print(periph->path,
3678 "disk power mode 0x%02x\n", mode);
3679 }
3680 #endif
3681 switch (mode) {
3682 case ATA_PM_STANDBY:
3683 case ATA_PM_STANDBY_Y:
3684 if (bootverbose) {
3685 xpt_print(periph->path,
3686 "already spun down\n");
3687 }
3688 cam_periph_unlock(periph);
3689 continue;
3690 default:
3691 break;
3692 }
3693 }
3694 }
3695
3696 if (bootverbose)
3697 xpt_print(periph->path, "spin-down\n");
3698
3699 memset(&local_ccb, 0, sizeof(local_ccb));
3700 xpt_setup_ccb(&local_ccb.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
3701 local_ccb.ccb_h.ccb_state = ADA_CCB_DUMP;
3702
3703 cam_fill_ataio(&local_ccb,
3704 0,
3705 NULL,
3706 CAM_DIR_NONE | flags,
3707 0,
3708 NULL,
3709 0,
3710 ada_default_timeout*1000);
3711 ata_28bit_cmd(&local_ccb, cmd, 0, 0, 0);
3712 error = cam_periph_runccb((union ccb *)&local_ccb, adaerror,
3713 /*cam_flags*/0, /*sense_flags*/ SF_NO_RECOVERY | SF_NO_RETRY,
3714 softc->disk->d_devstat);
3715 if (error != 0)
3716 xpt_print(periph->path, "Spin-down disk failed\n");
3717 cam_periph_unlock(periph);
3718 }
3719 }
3720
3721 static void
adashutdown(void * arg,int howto)3722 adashutdown(void *arg, int howto)
3723 {
3724 int how;
3725
3726 if ((howto & RB_NOSYNC) != 0)
3727 return;
3728
3729 adaflush();
3730
3731 /*
3732 * STANDBY IMMEDIATE saves any volatile data to the drive. It also spins
3733 * down hard drives. IDLE IMMEDIATE also saves the volatile data without
3734 * a spindown. We send the former when we expect to lose power soon. For
3735 * a warm boot, we send the latter to avoid a thundering herd of spinups
3736 * just after the kernel loads while probing. We have to do something to
3737 * flush the data because the BIOS in many systems resets the HBA
3738 * causing a COMINIT/COMRESET negotiation, which some drives interpret
3739 * as license to toss the volatile data, and others count as unclean
3740 * shutdown when in the Active PM state in SMART attributes.
3741 *
3742 * adaspindown will ensure that we don't send this to a drive that
3743 * doesn't support it.
3744 */
3745 if (ada_spindown_shutdown != 0) {
3746 how = (howto & (RB_HALT | RB_POWEROFF | RB_POWERCYCLE)) ?
3747 ATA_STANDBY_IMMEDIATE : ATA_IDLE_IMMEDIATE;
3748 adaspindown(how, 0);
3749 }
3750 }
3751
3752 static void
adasuspend(void * arg)3753 adasuspend(void *arg)
3754 {
3755
3756 adaflush();
3757 /*
3758 * SLEEP also fushes any volatile data, like STANDBY IMEDIATE,
3759 * so we don't need to send it as well.
3760 */
3761 if (ada_spindown_suspend != 0)
3762 adaspindown(ATA_SLEEP, CAM_DEV_QFREEZE);
3763 }
3764
3765 static void
adaresume(void * arg)3766 adaresume(void *arg)
3767 {
3768 struct cam_periph *periph;
3769 struct ada_softc *softc;
3770
3771 if (ada_spindown_suspend == 0)
3772 return;
3773
3774 CAM_PERIPH_FOREACH(periph, &adadriver) {
3775 cam_periph_lock(periph);
3776 softc = (struct ada_softc *)periph->softc;
3777 /*
3778 * We only spin-down the drive if it is capable of it..
3779 */
3780 if ((softc->flags & ADA_FLAG_CAN_POWERMGT) == 0) {
3781 cam_periph_unlock(periph);
3782 continue;
3783 }
3784
3785 if (bootverbose)
3786 xpt_print(periph->path, "resume\n");
3787
3788 /*
3789 * Drop freeze taken due to CAM_DEV_QFREEZE flag set on
3790 * sleep request.
3791 */
3792 cam_release_devq(periph->path,
3793 /*relsim_flags*/0,
3794 /*openings*/0,
3795 /*timeout*/0,
3796 /*getcount_only*/0);
3797
3798 cam_periph_unlock(periph);
3799 }
3800 }
3801
3802 #endif /* _KERNEL */
3803