1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 /*
27 * pseudo scsi disk driver
28 */
29
30 #include <sys/scsi/scsi.h>
31 #include <sys/ddi.h>
32 #include <sys/sunddi.h>
33 #include <sys/kmem.h>
34 #include <sys/taskq.h>
35 #include <sys/disp.h>
36 #include <sys/types.h>
37 #include <sys/buf.h>
38
39 #include <sys/emul64.h>
40 #include <sys/emul64cmd.h>
41 #include <sys/emul64var.h>
42
43 /*
44 * Mode sense/select page control
45 */
46 #define MODE_SENSE_PC_CURRENT 0
47 #define MODE_SENSE_PC_CHANGEABLE 1
48 #define MODE_SENSE_PC_DEFAULT 2
49 #define MODE_SENSE_PC_SAVED 3
50
51 /*
52 * Byte conversion macros
53 */
54 #if defined(_BIG_ENDIAN)
55 #define ushort_to_scsi_ushort(n) (n)
56 #define uint32_to_scsi_uint32(n) (n)
57 #define uint64_to_scsi_uint64(n) (n)
58 #elif defined(_LITTLE_ENDIAN)
59
60 #define ushort_to_scsi_ushort(n) \
61 ((((n) & 0x00ff) << 8) | \
62 (((n) & 0xff00) >> 8))
63
64 #define uint32_to_scsi_uint32(n) \
65 ((((n) & 0x000000ff) << 24) | \
66 (((n) & 0x0000ff00) << 8) | \
67 (((n) & 0x00ff0000) >> 8) | \
68 (((n) & 0xff000000) >> 24))
69 #define uint64_to_scsi_uint64(n) \
70 ((((n) & 0x00000000000000ff) << 56) | \
71 (((n) & 0x000000000000ff00) << 40) | \
72 (((n) & 0x0000000000ff0000) << 24) | \
73 (((n) & 0x00000000ff000000) << 8) | \
74 (((n) & 0x000000ff00000000) >> 8) | \
75 (((n) & 0x0000ff0000000000) >> 24) | \
76 (((n) & 0x00ff000000000000) >> 40) | \
77 (((n) & 0xff00000000000000) >> 56))
78 #else
79 error no _BIG_ENDIAN or _LITTLE_ENDIAN
80 #endif
81 #define uint_to_byte0(n) ((n) & 0xff)
82 #define uint_to_byte1(n) (((n)>>8) & 0xff)
83 #define uint_to_byte2(n) (((n)>>16) & 0xff)
84 #define uint_to_byte3(n) (((n)>>24) & 0xff)
85
86 /*
87 * struct prop_map
88 *
89 * This structure maps a property name to the place to store its value.
90 */
91 struct prop_map {
92 char *pm_name; /* Name of the property. */
93 int *pm_value; /* Place to store the value. */
94 };
95
96 static int emul64_debug_blklist = 0;
97
98 /*
99 * Some interesting statistics. These are protected by the
100 * emul64_stats_mutex. It would be nice to have an ioctl to print them out,
101 * but we don't have the development time for that now. You can at least
102 * look at them with adb.
103 */
104
105 int emul64_collect_stats = 1; /* Collect stats if non-zero */
106 kmutex_t emul64_stats_mutex; /* Protect these variables */
107 long emul64_nowrite_count = 0; /* # active nowrite ranges */
108 static uint64_t emul64_skipped_io = 0; /* Skipped I/O operations, because of */
109 /* EMUL64_WRITE_OFF. */
110 static uint64_t emul64_skipped_blk = 0; /* Skipped blocks because of */
111 /* EMUL64_WRITE_OFF. */
112 static uint64_t emul64_io_ops = 0; /* Total number of I/O operations */
113 /* including skipped and actual. */
114 static uint64_t emul64_io_blocks = 0; /* Total number of blocks involved */
115 /* in I/O operations. */
116 static uint64_t emul64_nonzero = 0; /* Number of non-zero data blocks */
117 /* currently held in memory */
118 static uint64_t emul64_max_list_length = 0; /* Maximum size of a linked */
119 /* list of non-zero blocks. */
120 uint64_t emul64_taskq_max = 0; /* emul64_scsi_start uses the taskq */
121 /* mechanism to dispatch work. */
122 /* If the number of entries in the */
123 /* exceeds the maximum for the queue */
124 /* the queue a 1 second delay is */
125 /* encountered in taskq_ent_alloc. */
126 /* This counter counts the number */
127 /* times that this happens. */
128
129 /*
130 * Since emul64 does no physical I/O, operations that would normally be I/O
131 * intensive become CPU bound. An example of this is RAID 5
132 * initialization. When the kernel becomes CPU bound, it looks as if the
133 * machine is hung.
134 *
135 * To avoid this problem, we provide a function, emul64_yield_check, that does a
136 * delay from time to time to yield up the CPU. The following variables
137 * are tunables for this algorithm.
138 *
139 * emul64_num_delay_called Number of times we called delay. This is
140 * not really a tunable. Rather it is a
141 * counter that provides useful information
142 * for adjusting the tunables.
143 * emul64_yield_length Number of microseconds to yield the CPU.
144 * emul64_yield_period Number of I/O operations between yields.
145 * emul64_yield_enable emul64 will yield the CPU, only if this
146 * variable contains a non-zero value. This
147 * allows the yield functionality to be turned
148 * off for experimentation purposes.
149 *
150 * The value of 1000 for emul64_yield_period has been determined by
151 * experience with running the tests.
152 */
153 static uint64_t emul64_num_delay_called = 0;
154 static int emul64_yield_length = 1000;
155 static int emul64_yield_period = 1000;
156 static int emul64_yield_enable = 1;
157 static kmutex_t emul64_yield_mutex;
158 static kcondvar_t emul64_yield_cv;
159
160 /*
161 * This array establishes a set of tunable variables that can be set by
162 * defining properties in the emul64.conf file.
163 */
164 struct prop_map emul64_properties[] = {
165 { "emul64_collect_stats", &emul64_collect_stats },
166 { "emul64_yield_length", &emul64_yield_length },
167 { "emul64_yield_period", &emul64_yield_period },
168 { "emul64_yield_enable", &emul64_yield_enable },
169 { "emul64_max_task", &emul64_max_task },
170 { "emul64_task_nthreads", &emul64_task_nthreads }
171 };
172
173 static unsigned char *emul64_zeros = NULL; /* Block of 0s for comparison */
174
175 extern void emul64_check_cond(struct scsi_pkt *pkt, uchar_t key,
176 uchar_t asc, uchar_t ascq);
177 /* ncyl=250000 acyl=2 nhead=24 nsect=357 */
178 uint_t dkg_rpm = 3600;
179
180 static int bsd_mode_sense_dad_mode_geometry(struct scsi_pkt *);
181 static int bsd_mode_sense_dad_mode_err_recov(struct scsi_pkt *);
182 static int bsd_mode_sense_modepage_disco_reco(struct scsi_pkt *);
183 static int bsd_mode_sense_dad_mode_format(struct scsi_pkt *);
184 static int bsd_mode_sense_dad_mode_cache(struct scsi_pkt *);
185 static int bsd_readblks(struct emul64 *, ushort_t, ushort_t, diskaddr_t,
186 int, unsigned char *);
187 static int bsd_writeblks(struct emul64 *, ushort_t, ushort_t, diskaddr_t,
188 int, unsigned char *);
189 emul64_tgt_t *find_tgt(struct emul64 *, ushort_t, ushort_t);
190 static blklist_t *bsd_findblk(emul64_tgt_t *, diskaddr_t, avl_index_t *);
191 static void bsd_allocblk(emul64_tgt_t *, diskaddr_t, caddr_t, avl_index_t);
192 static void bsd_freeblk(emul64_tgt_t *, blklist_t *);
193 static void emul64_yield_check();
194 static emul64_rng_overlap_t bsd_tgt_overlap(emul64_tgt_t *, diskaddr_t, int);
195
196 char *emul64_name = "emul64";
197
198
199 /*
200 * Initialize globals in this file.
201 */
202 void
203 emul64_bsd_init()
204 {
205 emul64_zeros = (unsigned char *) kmem_zalloc(DEV_BSIZE, KM_SLEEP);
206 mutex_init(&emul64_stats_mutex, NULL, MUTEX_DRIVER, NULL);
207 mutex_init(&emul64_yield_mutex, NULL, MUTEX_DRIVER, NULL);
208 cv_init(&emul64_yield_cv, NULL, CV_DRIVER, NULL);
209 }
210
211 /*
212 * Clean up globals in this file.
213 */
214 void
215 emul64_bsd_fini()
216 {
217 cv_destroy(&emul64_yield_cv);
218 mutex_destroy(&emul64_yield_mutex);
219 mutex_destroy(&emul64_stats_mutex);
220 if (emul64_zeros != NULL) {
221 kmem_free(emul64_zeros, DEV_BSIZE);
222 emul64_zeros = NULL;
223 }
224 }
225
226 /*
227 * Attempt to get the values of the properties that are specified in the
228 * emul64_properties array. If the property exists, copy its value to the
229 * specified location. All the properties have been assigned default
230 * values in this driver, so if we cannot get the property that is not a
231 * problem.
232 */
233 void
234 emul64_bsd_get_props(dev_info_t *dip)
235 {
236 uint_t count;
237 uint_t i;
238 struct prop_map *pmp;
239 int *properties;
240
241 for (pmp = emul64_properties, i = 0;
242 i < sizeof (emul64_properties) / sizeof (struct prop_map);
243 i++, pmp++) {
244 if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, dip,
245 DDI_PROP_DONTPASS, pmp->pm_name, &properties,
246 &count) == DDI_PROP_SUCCESS) {
247 if (count >= 1) {
248 *pmp->pm_value = *properties;
249 }
250 ddi_prop_free((void *) properties);
251 }
252 }
253 }
254
255 int
256 emul64_bsd_blkcompare(const void *a1, const void *b1)
257 {
258 blklist_t *a = (blklist_t *)a1;
259 blklist_t *b = (blklist_t *)b1;
260
261 if (a->bl_blkno < b->bl_blkno)
262 return (-1);
263 if (a->bl_blkno == b->bl_blkno)
264 return (0);
265 return (1);
266 }
267
268 /* ARGSUSED 0 */
269 int
270 bsd_scsi_start_stop_unit(struct scsi_pkt *pkt)
271 {
272 return (0);
273 }
274
275 /* ARGSUSED 0 */
276 int
277 bsd_scsi_test_unit_ready(struct scsi_pkt *pkt)
278 {
279 return (0);
280 }
281
282 /* ARGSUSED 0 */
283 int
284 bsd_scsi_request_sense(struct scsi_pkt *pkt)
285 {
286 return (0);
287 }
288
289 int
290 bsd_scsi_inq_page0(struct scsi_pkt *pkt, uchar_t pqdtype)
291 {
292 struct emul64_cmd *sp = PKT2CMD(pkt);
293
294 if (sp->cmd_count < 6) {
295 cmn_err(CE_CONT, "%s: bsd_scsi_inq_page0: size %d required\n",
296 emul64_name, 6);
297 return (EIO);
298 }
299
300 sp->cmd_addr[0] = pqdtype; /* periph qual., dtype */
301 sp->cmd_addr[1] = 0; /* page code */
302 sp->cmd_addr[2] = 0; /* reserved */
303 sp->cmd_addr[3] = 6 - 3; /* length */
304 sp->cmd_addr[4] = 0; /* 1st page */
305 sp->cmd_addr[5] = 0x83; /* 2nd page */
306
307 pkt->pkt_resid = sp->cmd_count - 6;
308 return (0);
309 }
310
311 int
312 bsd_scsi_inq_page83(struct scsi_pkt *pkt, uchar_t pqdtype)
313 {
314 struct emul64 *emul64 = PKT2EMUL64(pkt);
315 struct emul64_cmd *sp = PKT2CMD(pkt);
316 int instance = ddi_get_instance(emul64->emul64_dip);
317
318 if (sp->cmd_count < 22) {
319 cmn_err(CE_CONT, "%s: bsd_scsi_inq_page83: size %d required\n",
320 emul64_name, 22);
321 return (EIO);
322 }
323
324 sp->cmd_addr[0] = pqdtype; /* periph qual., dtype */
325 sp->cmd_addr[1] = 0x83; /* page code */
326 sp->cmd_addr[2] = 0; /* reserved */
327 sp->cmd_addr[3] = (22 - 8) + 4; /* length */
328
329 sp->cmd_addr[4] = 1; /* code set - binary */
330 sp->cmd_addr[5] = 3; /* association and device ID type 3 */
331 sp->cmd_addr[6] = 0; /* reserved */
332 sp->cmd_addr[7] = 22 - 8; /* ID length */
333
334 sp->cmd_addr[8] = 0xde; /* @8: identifier, byte 0 */
335 sp->cmd_addr[9] = 0xca;
336 sp->cmd_addr[10] = 0xde;
337 sp->cmd_addr[11] = 0x80;
338
339 sp->cmd_addr[12] = 0xba;
340 sp->cmd_addr[13] = 0xbe;
341 sp->cmd_addr[14] = 0xab;
342 sp->cmd_addr[15] = 0xba;
343 /* @22: */
344
345 /*
346 * Instances seem to be assigned sequentially, so it unlikely that we
347 * will have more than 65535 of them.
348 */
349 sp->cmd_addr[16] = uint_to_byte1(instance);
350 sp->cmd_addr[17] = uint_to_byte0(instance);
351 sp->cmd_addr[18] = uint_to_byte1(TGT(sp));
352 sp->cmd_addr[19] = uint_to_byte0(TGT(sp));
353 sp->cmd_addr[20] = uint_to_byte1(LUN(sp));
354 sp->cmd_addr[21] = uint_to_byte0(LUN(sp));
355
356 pkt->pkt_resid = sp->cmd_count - 22;
357 return (0);
358 }
359
360 int
361 bsd_scsi_inquiry(struct scsi_pkt *pkt)
362 {
363 struct emul64_cmd *sp = PKT2CMD(pkt);
364 union scsi_cdb *cdb = (union scsi_cdb *)pkt->pkt_cdbp;
365 emul64_tgt_t *tgt;
366 uchar_t pqdtype;
367 struct scsi_inquiry inq;
368
369 EMUL64_MUTEX_ENTER(sp->cmd_emul64);
370 tgt = find_tgt(sp->cmd_emul64,
371 pkt->pkt_address.a_target, pkt->pkt_address.a_lun);
372 EMUL64_MUTEX_EXIT(sp->cmd_emul64);
373
374 if (sp->cmd_count < sizeof (inq)) {
375 cmn_err(CE_CONT, "%s: bsd_scsi_inquiry: size %d required\n",
376 emul64_name, (int)sizeof (inq));
377 return (EIO);
378 }
379
380 if (cdb->cdb_opaque[1] & 0xfc) {
381 cmn_err(CE_WARN, "%s: bsd_scsi_inquiry: 0x%x",
382 emul64_name, cdb->cdb_opaque[1]);
383 emul64_check_cond(pkt, 0x5, 0x24, 0x0); /* inv. fld in cdb */
384 return (0);
385 }
386
387 pqdtype = tgt->emul64_tgt_dtype;
388 if (cdb->cdb_opaque[1] & 0x1) {
389 switch (cdb->cdb_opaque[2]) {
390 case 0x00:
391 return (bsd_scsi_inq_page0(pkt, pqdtype));
392 case 0x83:
393 return (bsd_scsi_inq_page83(pkt, pqdtype));
394 default:
395 cmn_err(CE_WARN, "%s: bsd_scsi_inquiry: "
396 "unsupported 0x%x",
397 emul64_name, cdb->cdb_opaque[2]);
398 return (0);
399 }
400 }
401
402 /* set up the inquiry data we return */
403 (void) bzero((void *)&inq, sizeof (inq));
404
405 inq.inq_dtype = pqdtype;
406 inq.inq_ansi = 2;
407 inq.inq_rdf = 2;
408 inq.inq_len = sizeof (inq) - 4;
409 inq.inq_wbus16 = 1;
410 inq.inq_cmdque = 1;
411
412 (void) bcopy(tgt->emul64_tgt_inq, inq.inq_vid,
413 sizeof (tgt->emul64_tgt_inq));
414 (void) bcopy("1", inq.inq_revision, 2);
415 (void) bcopy((void *)&inq, sp->cmd_addr, sizeof (inq));
416
417 pkt->pkt_resid = sp->cmd_count - sizeof (inq);
418 return (0);
419 }
420
421 /* ARGSUSED 0 */
422 int
423 bsd_scsi_format(struct scsi_pkt *pkt)
424 {
425 return (0);
426 }
427
428 int
429 bsd_scsi_io(struct scsi_pkt *pkt)
430 {
431 struct emul64_cmd *sp = PKT2CMD(pkt);
432 union scsi_cdb *cdb = (union scsi_cdb *)pkt->pkt_cdbp;
433 diskaddr_t lblkno;
434 int nblks;
435
436 switch (cdb->scc_cmd) {
437 case SCMD_READ:
438 lblkno = (uint32_t)GETG0ADDR(cdb);
439 nblks = GETG0COUNT(cdb);
440 pkt->pkt_resid = bsd_readblks(sp->cmd_emul64,
441 pkt->pkt_address.a_target, pkt->pkt_address.a_lun,
442 lblkno, nblks, sp->cmd_addr);
443 if (emul64debug) {
444 cmn_err(CE_CONT, "%s: bsd_scsi_io: "
445 "read g0 blk=%lld (0x%llx) nblks=%d\n",
446 emul64_name, lblkno, lblkno, nblks);
447 }
448 break;
449 case SCMD_WRITE:
450 lblkno = (uint32_t)GETG0ADDR(cdb);
451 nblks = GETG0COUNT(cdb);
452 pkt->pkt_resid = bsd_writeblks(sp->cmd_emul64,
453 pkt->pkt_address.a_target, pkt->pkt_address.a_lun,
454 lblkno, nblks, sp->cmd_addr);
455 if (emul64debug) {
456 cmn_err(CE_CONT, "%s: bsd_scsi_io: "
457 "write g0 blk=%lld (0x%llx) nblks=%d\n",
458 emul64_name, lblkno, lblkno, nblks);
459 }
460 break;
461 case SCMD_READ_G1:
462 lblkno = (uint32_t)GETG1ADDR(cdb);
463 nblks = GETG1COUNT(cdb);
464 pkt->pkt_resid = bsd_readblks(sp->cmd_emul64,
465 pkt->pkt_address.a_target, pkt->pkt_address.a_lun,
466 lblkno, nblks, sp->cmd_addr);
467 if (emul64debug) {
468 cmn_err(CE_CONT, "%s: bsd_scsi_io: "
469 "read g1 blk=%lld (0x%llx) nblks=%d\n",
470 emul64_name, lblkno, lblkno, nblks);
471 }
472 break;
473 case SCMD_WRITE_G1:
474 lblkno = (uint32_t)GETG1ADDR(cdb);
475 nblks = GETG1COUNT(cdb);
476 pkt->pkt_resid = bsd_writeblks(sp->cmd_emul64,
477 pkt->pkt_address.a_target, pkt->pkt_address.a_lun,
478 lblkno, nblks, sp->cmd_addr);
479 if (emul64debug) {
480 cmn_err(CE_CONT, "%s: bsd_scsi_io: "
481 "write g1 blk=%lld (0x%llx) nblks=%d\n",
482 emul64_name, lblkno, lblkno, nblks);
483 }
484 break;
485 case SCMD_READ_G4:
486 lblkno = GETG4ADDR(cdb);
487 lblkno <<= 32;
488 lblkno |= (uint32_t)GETG4ADDRTL(cdb);
489 nblks = GETG4COUNT(cdb);
490 pkt->pkt_resid = bsd_readblks(sp->cmd_emul64,
491 pkt->pkt_address.a_target, pkt->pkt_address.a_lun,
492 lblkno, nblks, sp->cmd_addr);
493 if (emul64debug) {
494 cmn_err(CE_CONT, "%s: bsd_scsi_io: "
495 "read g4 blk=%lld (0x%llx) nblks=%d\n",
496 emul64_name, lblkno, lblkno, nblks);
497 }
498 break;
499 case SCMD_WRITE_G4:
500 lblkno = GETG4ADDR(cdb);
501 lblkno <<= 32;
502 lblkno |= (uint32_t)GETG4ADDRTL(cdb);
503 nblks = GETG4COUNT(cdb);
504 pkt->pkt_resid = bsd_writeblks(sp->cmd_emul64,
505 pkt->pkt_address.a_target, pkt->pkt_address.a_lun,
506 lblkno, nblks, sp->cmd_addr);
507 if (emul64debug) {
508 cmn_err(CE_CONT, "%s: bsd_scsi_io: "
509 "write g4 blk=%lld (0x%llx) nblks=%d\n",
510 emul64_name, lblkno, lblkno, nblks);
511 }
512 break;
513 default:
514 cmn_err(CE_WARN, "%s: bsd_scsi_io: unhandled I/O: 0x%x",
515 emul64_name, cdb->scc_cmd);
516 break;
517 }
518
519 if (pkt->pkt_resid != 0)
520 cmn_err(CE_WARN, "%s: bsd_scsi_io: "
521 "pkt_resid: 0x%lx, lblkno %lld, nblks %d",
522 emul64_name, pkt->pkt_resid, lblkno, nblks);
523
524 return (0);
525 }
526
527 int
528 bsd_scsi_log_sense(struct scsi_pkt *pkt)
529 {
530 union scsi_cdb *cdb = (union scsi_cdb *)pkt->pkt_cdbp;
531 struct emul64_cmd *sp = PKT2CMD(pkt);
532 int page_code;
533
534 if (sp->cmd_count < 9) {
535 cmn_err(CE_CONT, "%s: bsd_scsi_log_sense size %d required\n",
536 emul64_name, 9);
537 return (EIO);
538 }
539
540 page_code = cdb->cdb_opaque[2] & 0x3f;
541 if (page_code) {
542 cmn_err(CE_CONT, "%s: bsd_scsi_log_sense: "
543 "page 0x%x not supported\n", emul64_name, page_code);
544 emul64_check_cond(pkt, 0x5, 0x24, 0x0); /* inv. fld in cdb */
545 return (0);
546 }
547
548 sp->cmd_addr[0] = 0; /* page code */
549 sp->cmd_addr[1] = 0; /* reserved */
550 sp->cmd_addr[2] = 0; /* MSB of page length */
551 sp->cmd_addr[3] = 8 - 3; /* LSB of page length */
552
553 sp->cmd_addr[4] = 0; /* MSB of parameter code */
554 sp->cmd_addr[5] = 0; /* LSB of parameter code */
555 sp->cmd_addr[6] = 0; /* parameter control byte */
556 sp->cmd_addr[7] = 4 - 3; /* parameter length */
557 sp->cmd_addr[8] = 0x0; /* parameter value */
558
559 pkt->pkt_resid = sp->cmd_count - 9;
560 return (0);
561 }
562
563 int
564 bsd_scsi_mode_sense(struct scsi_pkt *pkt)
565 {
566 union scsi_cdb *cdb = (union scsi_cdb *)pkt->pkt_cdbp;
567 int page_control;
568 int page_code;
569 int rval = 0;
570
571 switch (cdb->scc_cmd) {
572 case SCMD_MODE_SENSE:
573 page_code = cdb->cdb_opaque[2] & 0x3f;
574 page_control = (cdb->cdb_opaque[2] >> 6) & 0x03;
575 if (emul64debug) {
576 cmn_err(CE_CONT, "%s: bsd_scsi_mode_sense: "
577 "page=0x%x control=0x%x nbytes=%d\n",
578 emul64_name, page_code, page_control,
579 GETG0COUNT(cdb));
580 }
581 break;
582 case SCMD_MODE_SENSE_G1:
583 page_code = cdb->cdb_opaque[2] & 0x3f;
584 page_control = (cdb->cdb_opaque[2] >> 6) & 0x03;
585 if (emul64debug) {
586 cmn_err(CE_CONT, "%s: bsd_scsi_mode_sense: "
587 "page=0x%x control=0x%x nbytes=%d\n",
588 emul64_name, page_code, page_control,
589 GETG1COUNT(cdb));
590 }
591 break;
592 default:
593 cmn_err(CE_CONT, "%s: bsd_scsi_mode_sense: "
594 "cmd 0x%x not supported\n", emul64_name, cdb->scc_cmd);
595 return (EIO);
596 }
597
598 switch (page_code) {
599 case DAD_MODE_GEOMETRY:
600 rval = bsd_mode_sense_dad_mode_geometry(pkt);
601 break;
602 case DAD_MODE_ERR_RECOV:
603 rval = bsd_mode_sense_dad_mode_err_recov(pkt);
604 break;
605 case MODEPAGE_DISCO_RECO:
606 rval = bsd_mode_sense_modepage_disco_reco(pkt);
607 break;
608 case DAD_MODE_FORMAT:
609 rval = bsd_mode_sense_dad_mode_format(pkt);
610 break;
611 case DAD_MODE_CACHE:
612 rval = bsd_mode_sense_dad_mode_cache(pkt);
613 break;
614 default:
615 cmn_err(CE_CONT, "%s: bsd_scsi_mode_sense: "
616 "page 0x%x not supported\n", emul64_name, page_code);
617 rval = EIO;
618 break;
619 }
620
621 return (rval);
622 }
623
624
625 static int
626 bsd_mode_sense_dad_mode_geometry(struct scsi_pkt *pkt)
627 {
628 struct emul64_cmd *sp = PKT2CMD(pkt);
629 union scsi_cdb *cdb = (union scsi_cdb *)pkt->pkt_cdbp;
630 uchar_t *addr = (uchar_t *)sp->cmd_addr;
631 emul64_tgt_t *tgt;
632 int page_control;
633 struct mode_header header;
634 struct mode_geometry page4;
635 int ncyl;
636 int rval = 0;
637
638 page_control = (cdb->cdb_opaque[2] >> 6) & 0x03;
639
640 if (emul64debug) {
641 cmn_err(CE_CONT, "%s: bsd_mode_sense_dad_mode_geometry: "
642 "pc=%d n=%d\n", emul64_name, page_control, sp->cmd_count);
643 }
644
645 if (sp->cmd_count < (sizeof (header) + sizeof (page4))) {
646 cmn_err(CE_CONT, "%s: bsd_mode_sense_dad_mode_geometry: "
647 "size %d required\n",
648 emul64_name, (int)(sizeof (header) + sizeof (page4)));
649 return (EIO);
650 }
651
652 (void) bzero(&header, sizeof (header));
653 (void) bzero(&page4, sizeof (page4));
654
655 header.length = sizeof (header) + sizeof (page4) - 1;
656 header.bdesc_length = 0;
657
658 page4.mode_page.code = DAD_MODE_GEOMETRY;
659 page4.mode_page.ps = 1;
660 page4.mode_page.length = sizeof (page4) - sizeof (struct mode_page);
661
662 switch (page_control) {
663 case MODE_SENSE_PC_CURRENT:
664 case MODE_SENSE_PC_DEFAULT:
665 case MODE_SENSE_PC_SAVED:
666 EMUL64_MUTEX_ENTER(sp->cmd_emul64);
667 tgt = find_tgt(sp->cmd_emul64,
668 pkt->pkt_address.a_target, pkt->pkt_address.a_lun);
669 EMUL64_MUTEX_EXIT(sp->cmd_emul64);
670 ncyl = tgt->emul64_tgt_ncyls;
671 page4.cyl_ub = uint_to_byte2(ncyl);
672 page4.cyl_mb = uint_to_byte1(ncyl);
673 page4.cyl_lb = uint_to_byte0(ncyl);
674 page4.heads = uint_to_byte0(tgt->emul64_tgt_nheads);
675 page4.rpm = ushort_to_scsi_ushort(dkg_rpm);
676 break;
677 case MODE_SENSE_PC_CHANGEABLE:
678 page4.cyl_ub = 0xff;
679 page4.cyl_mb = 0xff;
680 page4.cyl_lb = 0xff;
681 page4.heads = 0xff;
682 page4.rpm = 0xffff;
683 break;
684 }
685
686 (void) bcopy(&header, addr, sizeof (header));
687 (void) bcopy(&page4, addr + sizeof (header), sizeof (page4));
688
689 pkt->pkt_resid = sp->cmd_count - sizeof (page4) - sizeof (header);
690 rval = 0;
691
692 return (rval);
693 }
694
695 static int
696 bsd_mode_sense_dad_mode_err_recov(struct scsi_pkt *pkt)
697 {
698 struct emul64_cmd *sp = PKT2CMD(pkt);
699 union scsi_cdb *cdb = (union scsi_cdb *)pkt->pkt_cdbp;
700 uchar_t *addr = (uchar_t *)sp->cmd_addr;
701 int page_control;
702 struct mode_header header;
703 struct mode_err_recov page1;
704 int rval = 0;
705
706 page_control = (cdb->cdb_opaque[2] >> 6) & 0x03;
707
708 if (emul64debug) {
709 cmn_err(CE_CONT, "%s: bsd_mode_sense_dad_mode_err_recov: "
710 "pc=%d n=%d\n", emul64_name, page_control, sp->cmd_count);
711 }
712
713 if (sp->cmd_count < (sizeof (header) + sizeof (page1))) {
714 cmn_err(CE_CONT, "%s: bsd_mode_sense_dad_mode_err_recov: "
715 "size %d required\n",
716 emul64_name, (int)(sizeof (header) + sizeof (page1)));
717 return (EIO);
718 }
719
720 (void) bzero(&header, sizeof (header));
721 (void) bzero(&page1, sizeof (page1));
722
723 header.length = sizeof (header) + sizeof (page1) - 1;
724 header.bdesc_length = 0;
725
726 page1.mode_page.code = DAD_MODE_ERR_RECOV;
727 page1.mode_page.ps = 1;
728 page1.mode_page.length = sizeof (page1) - sizeof (struct mode_page);
729
730 switch (page_control) {
731 case MODE_SENSE_PC_CURRENT:
732 case MODE_SENSE_PC_DEFAULT:
733 case MODE_SENSE_PC_SAVED:
734 break;
735 case MODE_SENSE_PC_CHANGEABLE:
736 break;
737 }
738
739 (void) bcopy(&header, addr, sizeof (header));
740 (void) bcopy(&page1, addr + sizeof (header), sizeof (page1));
741
742 pkt->pkt_resid = sp->cmd_count - sizeof (page1) - sizeof (header);
743 rval = 0;
744
745 return (rval);
746 }
747
748 static int
749 bsd_mode_sense_modepage_disco_reco(struct scsi_pkt *pkt)
750 {
751 struct emul64_cmd *sp = PKT2CMD(pkt);
752 union scsi_cdb *cdb = (union scsi_cdb *)pkt->pkt_cdbp;
753 int rval = 0;
754 uchar_t *addr = (uchar_t *)sp->cmd_addr;
755 int page_control;
756 struct mode_header header;
757 struct mode_disco_reco page2;
758
759 page_control = (cdb->cdb_opaque[2] >> 6) & 0x03;
760
761 if (emul64debug) {
762 cmn_err(CE_CONT, "%s: bsd_mode_sense_modepage_disco_reco: "
763 "pc=%d n=%d\n", emul64_name, page_control, sp->cmd_count);
764 }
765
766 if (sp->cmd_count < (sizeof (header) + sizeof (page2))) {
767 cmn_err(CE_CONT, "%s: bsd_mode_sense_modepage_disco_reco: "
768 "size %d required\n",
769 emul64_name, (int)(sizeof (header) + sizeof (page2)));
770 return (EIO);
771 }
772
773 (void) bzero(&header, sizeof (header));
774 (void) bzero(&page2, sizeof (page2));
775
776 header.length = sizeof (header) + sizeof (page2) - 1;
777 header.bdesc_length = 0;
778
779 page2.mode_page.code = MODEPAGE_DISCO_RECO;
780 page2.mode_page.ps = 1;
781 page2.mode_page.length = sizeof (page2) - sizeof (struct mode_page);
782
783 switch (page_control) {
784 case MODE_SENSE_PC_CURRENT:
785 case MODE_SENSE_PC_DEFAULT:
786 case MODE_SENSE_PC_SAVED:
787 break;
788 case MODE_SENSE_PC_CHANGEABLE:
789 break;
790 }
791
792 (void) bcopy(&header, addr, sizeof (header));
793 (void) bcopy(&page2, addr + sizeof (header), sizeof (page2));
794
795 pkt->pkt_resid = sp->cmd_count - sizeof (page2) - sizeof (header);
796 rval = 0;
797
798 return (rval);
799 }
800
801 static int
802 bsd_mode_sense_dad_mode_format(struct scsi_pkt *pkt)
803 {
804 struct emul64_cmd *sp = PKT2CMD(pkt);
805 union scsi_cdb *cdb = (union scsi_cdb *)pkt->pkt_cdbp;
806 uchar_t *addr = (uchar_t *)sp->cmd_addr;
807 emul64_tgt_t *tgt;
808 int page_control;
809 struct mode_header header;
810 struct mode_format page3;
811 int rval = 0;
812
813 page_control = (cdb->cdb_opaque[2] >> 6) & 0x03;
814
815 if (emul64debug) {
816 cmn_err(CE_CONT, "%s: bsd_mode_sense_dad_mode_format: "
817 "pc=%d n=%d\n", emul64_name, page_control, sp->cmd_count);
818 }
819
820 if (sp->cmd_count < (sizeof (header) + sizeof (page3))) {
821 cmn_err(CE_CONT, "%s: bsd_mode_sense_dad_mode_format: "
822 "size %d required\n",
823 emul64_name, (int)(sizeof (header) + sizeof (page3)));
824 return (EIO);
825 }
826
827 (void) bzero(&header, sizeof (header));
828 (void) bzero(&page3, sizeof (page3));
829
830 header.length = sizeof (header) + sizeof (page3) - 1;
831 header.bdesc_length = 0;
832
833 page3.mode_page.code = DAD_MODE_FORMAT;
834 page3.mode_page.ps = 1;
835 page3.mode_page.length = sizeof (page3) - sizeof (struct mode_page);
836
837 switch (page_control) {
838 case MODE_SENSE_PC_CURRENT:
839 case MODE_SENSE_PC_DEFAULT:
840 case MODE_SENSE_PC_SAVED:
841 page3.data_bytes_sect = ushort_to_scsi_ushort(DEV_BSIZE);
842 page3.interleave = ushort_to_scsi_ushort(1);
843 EMUL64_MUTEX_ENTER(sp->cmd_emul64);
844 tgt = find_tgt(sp->cmd_emul64,
845 pkt->pkt_address.a_target, pkt->pkt_address.a_lun);
846 EMUL64_MUTEX_EXIT(sp->cmd_emul64);
847 page3.sect_track = ushort_to_scsi_ushort(tgt->emul64_tgt_nsect);
848 break;
849 case MODE_SENSE_PC_CHANGEABLE:
850 break;
851 }
852
853 (void) bcopy(&header, addr, sizeof (header));
854 (void) bcopy(&page3, addr + sizeof (header), sizeof (page3));
855
856 pkt->pkt_resid = sp->cmd_count - sizeof (page3) - sizeof (header);
857 rval = 0;
858
859 return (rval);
860 }
861
862 static int
863 bsd_mode_sense_dad_mode_cache(struct scsi_pkt *pkt)
864 {
865 struct emul64_cmd *sp = PKT2CMD(pkt);
866 union scsi_cdb *cdb = (union scsi_cdb *)pkt->pkt_cdbp;
867 uchar_t *addr = (uchar_t *)sp->cmd_addr;
868 int page_control;
869 struct mode_header header;
870 struct mode_cache page8;
871 int rval = 0;
872
873 page_control = (cdb->cdb_opaque[2] >> 6) & 0x03;
874
875 if (emul64debug) {
876 cmn_err(CE_CONT, "%s: bsd_mode_sense_dad_mode_cache: "
877 "pc=%d n=%d\n", emul64_name, page_control, sp->cmd_count);
878 }
879
880 if (sp->cmd_count < (sizeof (header) + sizeof (page8))) {
881 cmn_err(CE_CONT, "%s: bsd_mode_sense_dad_mode_cache: "
882 "size %d required\n",
883 emul64_name, (int)(sizeof (header) + sizeof (page8)));
884 return (EIO);
885 }
886
887 (void) bzero(&header, sizeof (header));
888 (void) bzero(&page8, sizeof (page8));
889
890 header.length = sizeof (header) + sizeof (page8) - 1;
891 header.bdesc_length = 0;
892
893 page8.mode_page.code = DAD_MODE_CACHE;
894 page8.mode_page.ps = 1;
895 page8.mode_page.length = sizeof (page8) - sizeof (struct mode_page);
896
897 switch (page_control) {
898 case MODE_SENSE_PC_CURRENT:
899 case MODE_SENSE_PC_DEFAULT:
900 case MODE_SENSE_PC_SAVED:
901 break;
902 case MODE_SENSE_PC_CHANGEABLE:
903 break;
904 }
905
906 (void) bcopy(&header, addr, sizeof (header));
907 (void) bcopy(&page8, addr + sizeof (header), sizeof (page8));
908
909 pkt->pkt_resid = sp->cmd_count - sizeof (page8) - sizeof (header);
910 rval = 0;
911
912 return (rval);
913 }
914
915 /* ARGSUSED 0 */
916 int
917 bsd_scsi_mode_select(struct scsi_pkt *pkt)
918 {
919 return (0);
920 }
921
922 int
923 bsd_scsi_read_capacity_8(struct scsi_pkt *pkt)
924 {
925 struct emul64_cmd *sp = PKT2CMD(pkt);
926 emul64_tgt_t *tgt;
927 struct scsi_capacity cap;
928 int rval = 0;
929
930 EMUL64_MUTEX_ENTER(sp->cmd_emul64);
931 tgt = find_tgt(sp->cmd_emul64,
932 pkt->pkt_address.a_target, pkt->pkt_address.a_lun);
933 EMUL64_MUTEX_EXIT(sp->cmd_emul64);
934 if (tgt->emul64_tgt_sectors > 0xffffffff)
935 cap.capacity = 0xffffffff;
936 else
937 cap.capacity =
938 uint32_to_scsi_uint32(tgt->emul64_tgt_sectors);
939 cap.lbasize = uint32_to_scsi_uint32((uint_t)DEV_BSIZE);
940
941 pkt->pkt_resid = sp->cmd_count - sizeof (struct scsi_capacity);
942
943 (void) bcopy(&cap, (caddr_t)sp->cmd_addr,
944 sizeof (struct scsi_capacity));
945 return (rval);
946 }
947
948 int
949 bsd_scsi_read_capacity_16(struct scsi_pkt *pkt)
950 {
951 struct emul64_cmd *sp = PKT2CMD(pkt);
952 emul64_tgt_t *tgt;
953 struct scsi_capacity_16 cap;
954 int rval = 0;
955
956 EMUL64_MUTEX_ENTER(sp->cmd_emul64);
957 tgt = find_tgt(sp->cmd_emul64,
958 pkt->pkt_address.a_target, pkt->pkt_address.a_lun);
959 EMUL64_MUTEX_EXIT(sp->cmd_emul64);
960
961 cap.sc_capacity = uint64_to_scsi_uint64(tgt->emul64_tgt_sectors);
962 cap.sc_lbasize = uint32_to_scsi_uint32((uint_t)DEV_BSIZE);
963 cap.sc_rto_en = 0;
964 cap.sc_prot_en = 0;
965 cap.sc_rsvd0 = 0;
966 bzero(&cap.sc_rsvd1[0], sizeof (cap.sc_rsvd1));
967
968 pkt->pkt_resid = sp->cmd_count - sizeof (struct scsi_capacity_16);
969
970 (void) bcopy(&cap, (caddr_t)sp->cmd_addr,
971 sizeof (struct scsi_capacity_16));
972 return (rval);
973 }
974 int
975 bsd_scsi_read_capacity(struct scsi_pkt *pkt)
976 {
977 return (bsd_scsi_read_capacity_8(pkt));
978 }
979
980
981 /* ARGSUSED 0 */
982 int
983 bsd_scsi_reserve(struct scsi_pkt *pkt)
984 {
985 return (0);
986 }
987
988 /* ARGSUSED 0 */
989 int
990 bsd_scsi_release(struct scsi_pkt *pkt)
991 {
992 return (0);
993 }
994
995
996 int
997 bsd_scsi_read_defect_list(struct scsi_pkt *pkt)
998 {
999 pkt->pkt_resid = 0;
1000 return (0);
1001 }
1002
1003
1004 /* ARGSUSED 0 */
1005 int
1006 bsd_scsi_reassign_block(struct scsi_pkt *pkt)
1007 {
1008 return (0);
1009 }
1010
1011
1012 static int
1013 bsd_readblks(struct emul64 *emul64, ushort_t target, ushort_t lun,
1014 diskaddr_t blkno, int nblks, unsigned char *bufaddr)
1015 {
1016 emul64_tgt_t *tgt;
1017 blklist_t *blk;
1018 emul64_rng_overlap_t overlap;
1019 int i = 0;
1020
1021 if (emul64debug) {
1022 cmn_err(CE_CONT, "%s: bsd_readblks: "
1023 "<%d,%d> blk %llu (0x%llx) nblks %d\n",
1024 emul64_name, target, lun, blkno, blkno, nblks);
1025 }
1026
1027 emul64_yield_check();
1028
1029 EMUL64_MUTEX_ENTER(emul64);
1030 tgt = find_tgt(emul64, target, lun);
1031 EMUL64_MUTEX_EXIT(emul64);
1032 if (tgt == NULL) {
1033 cmn_err(CE_WARN, "%s: bsd_readblks: no target for %d,%d\n",
1034 emul64_name, target, lun);
1035 goto unlocked_out;
1036 }
1037
1038 if (emul64_collect_stats) {
1039 mutex_enter(&emul64_stats_mutex);
1040 emul64_io_ops++;
1041 emul64_io_blocks += nblks;
1042 mutex_exit(&emul64_stats_mutex);
1043 }
1044 mutex_enter(&tgt->emul64_tgt_blk_lock);
1045
1046 /*
1047 * Keep the ioctls from changing the nowrite list for the duration
1048 * of this I/O by grabbing emul64_tgt_nw_lock. This will keep the
1049 * results from our call to bsd_tgt_overlap from changing while we
1050 * do the I/O.
1051 */
1052 rw_enter(&tgt->emul64_tgt_nw_lock, RW_READER);
1053
1054 overlap = bsd_tgt_overlap(tgt, blkno, nblks);
1055 switch (overlap) {
1056 case O_SAME:
1057 case O_SUBSET:
1058 case O_OVERLAP:
1059 cmn_err(CE_WARN, "%s: bsd_readblks: "
1060 "read to blocked area %lld,%d\n",
1061 emul64_name, blkno, nblks);
1062 rw_exit(&tgt->emul64_tgt_nw_lock);
1063 goto errout;
1064 case O_NONE:
1065 break;
1066 }
1067 for (i = 0; i < nblks; i++) {
1068 if (emul64_debug_blklist)
1069 cmn_err(CE_CONT, "%s: bsd_readblks: "
1070 "%d of %d: blkno %lld\n",
1071 emul64_name, i+1, nblks, blkno);
1072 if (blkno > tgt->emul64_tgt_sectors)
1073 break;
1074 blk = bsd_findblk(tgt, blkno, NULL);
1075 if (blk) {
1076 (void) bcopy(blk->bl_data, bufaddr, DEV_BSIZE);
1077 } else {
1078 (void) bzero(bufaddr, DEV_BSIZE);
1079 }
1080 blkno++;
1081 bufaddr += DEV_BSIZE;
1082 }
1083 rw_exit(&tgt->emul64_tgt_nw_lock);
1084
1085 errout:
1086 mutex_exit(&tgt->emul64_tgt_blk_lock);
1087
1088 unlocked_out:
1089 return ((nblks - i) * DEV_BSIZE);
1090 }
1091
1092
1093 static int
1094 bsd_writeblks(struct emul64 *emul64, ushort_t target, ushort_t lun,
1095 diskaddr_t blkno, int nblks, unsigned char *bufaddr)
1096 {
1097 emul64_tgt_t *tgt;
1098 blklist_t *blk;
1099 emul64_rng_overlap_t overlap;
1100 avl_index_t where;
1101 int i = 0;
1102
1103 if (emul64debug) {
1104 cmn_err(CE_CONT, "%s: bsd_writeblks: "
1105 "<%d,%d> blk %llu (0x%llx) nblks %d\n",
1106 emul64_name, target, lun, blkno, blkno, nblks);
1107 }
1108
1109 emul64_yield_check();
1110
1111 EMUL64_MUTEX_ENTER(emul64);
1112 tgt = find_tgt(emul64, target, lun);
1113 EMUL64_MUTEX_EXIT(emul64);
1114 if (tgt == NULL) {
1115 cmn_err(CE_WARN, "%s: bsd_writeblks: no target for %d,%d\n",
1116 emul64_name, target, lun);
1117 goto unlocked_out;
1118 }
1119
1120 if (emul64_collect_stats) {
1121 mutex_enter(&emul64_stats_mutex);
1122 emul64_io_ops++;
1123 emul64_io_blocks += nblks;
1124 mutex_exit(&emul64_stats_mutex);
1125 }
1126 mutex_enter(&tgt->emul64_tgt_blk_lock);
1127
1128 /*
1129 * Keep the ioctls from changing the nowrite list for the duration
1130 * of this I/O by grabbing emul64_tgt_nw_lock. This will keep the
1131 * results from our call to bsd_tgt_overlap from changing while we
1132 * do the I/O.
1133 */
1134 rw_enter(&tgt->emul64_tgt_nw_lock, RW_READER);
1135 overlap = bsd_tgt_overlap(tgt, blkno, nblks);
1136 switch (overlap) {
1137 case O_SAME:
1138 case O_SUBSET:
1139 if (emul64_collect_stats) {
1140 mutex_enter(&emul64_stats_mutex);
1141 emul64_skipped_io++;
1142 emul64_skipped_blk += nblks;
1143 mutex_exit(&emul64_stats_mutex);
1144 }
1145 rw_exit(&tgt->emul64_tgt_nw_lock);
1146 mutex_exit(&tgt->emul64_tgt_blk_lock);
1147 return (0);
1148 case O_OVERLAP:
1149 case O_NONE:
1150 break;
1151 }
1152 for (i = 0; i < nblks; i++) {
1153 if ((overlap == O_NONE) ||
1154 (bsd_tgt_overlap(tgt, blkno, 1) == O_NONE)) {
1155 /*
1156 * If there was no overlap for the entire I/O range
1157 * or if there is no overlap for this particular
1158 * block, then we need to do the write.
1159 */
1160 if (emul64_debug_blklist)
1161 cmn_err(CE_CONT, "%s: bsd_writeblks: "
1162 "%d of %d: blkno %lld\n",
1163 emul64_name, i+1, nblks, blkno);
1164 if (blkno > tgt->emul64_tgt_sectors) {
1165 cmn_err(CE_WARN, "%s: bsd_writeblks: "
1166 "blkno %lld, tgt_sectors %lld\n",
1167 emul64_name, blkno,
1168 tgt->emul64_tgt_sectors);
1169 break;
1170 }
1171
1172 blk = bsd_findblk(tgt, blkno, &where);
1173 if (bcmp(bufaddr, emul64_zeros, DEV_BSIZE) == 0) {
1174 if (blk) {
1175 bsd_freeblk(tgt, blk);
1176 }
1177 } else {
1178 if (blk) {
1179 (void) bcopy(bufaddr, blk->bl_data,
1180 DEV_BSIZE);
1181 } else {
1182 bsd_allocblk(tgt, blkno,
1183 (caddr_t)bufaddr, where);
1184 }
1185 }
1186 }
1187 blkno++;
1188 bufaddr += DEV_BSIZE;
1189 }
1190
1191 /*
1192 * Now that we're done with our I/O, allow the ioctls to change the
1193 * nowrite list.
1194 */
1195 rw_exit(&tgt->emul64_tgt_nw_lock);
1196
1197 errout:
1198 mutex_exit(&tgt->emul64_tgt_blk_lock);
1199
1200 unlocked_out:
1201 return ((nblks - i) * DEV_BSIZE);
1202 }
1203
1204 emul64_tgt_t *
1205 find_tgt(struct emul64 *emul64, ushort_t target, ushort_t lun)
1206 {
1207 emul64_tgt_t *tgt;
1208
1209 tgt = emul64->emul64_tgt;
1210 while (tgt) {
1211 if (tgt->emul64_tgt_saddr.a_target == target &&
1212 tgt->emul64_tgt_saddr.a_lun == lun) {
1213 break;
1214 }
1215 tgt = tgt->emul64_tgt_next;
1216 }
1217 return (tgt);
1218
1219 }
1220
1221 /*
1222 * Free all blocks that are part of the specified range.
1223 */
1224 int
1225 bsd_freeblkrange(emul64_tgt_t *tgt, emul64_range_t *range)
1226 {
1227 blklist_t *blk;
1228 blklist_t *nextblk;
1229
1230 ASSERT(mutex_owned(&tgt->emul64_tgt_blk_lock));
1231 for (blk = (blklist_t *)avl_first(&tgt->emul64_tgt_data);
1232 blk != NULL;
1233 blk = nextblk) {
1234 /*
1235 * We need to get the next block pointer now, because blk
1236 * will be freed inside the if statement.
1237 */
1238 nextblk = AVL_NEXT(&tgt->emul64_tgt_data, blk);
1239
1240 if (emul64_overlap(range, blk->bl_blkno, (size_t)1) != O_NONE) {
1241 bsd_freeblk(tgt, blk);
1242 }
1243 }
1244 return (0);
1245 }
1246
1247 static blklist_t *
1248 bsd_findblk(emul64_tgt_t *tgt, diskaddr_t blkno, avl_index_t *where)
1249 {
1250 blklist_t *blk;
1251 blklist_t search;
1252
1253 ASSERT(mutex_owned(&tgt->emul64_tgt_blk_lock));
1254
1255 search.bl_blkno = blkno;
1256 blk = (blklist_t *)avl_find(&tgt->emul64_tgt_data, &search, where);
1257 return (blk);
1258 }
1259
1260
1261 static void
1262 bsd_allocblk(emul64_tgt_t *tgt,
1263 diskaddr_t blkno,
1264 caddr_t data,
1265 avl_index_t where)
1266 {
1267 blklist_t *blk;
1268
1269 if (emul64_debug_blklist)
1270 cmn_err(CE_CONT, "%s: bsd_allocblk: %llu\n",
1271 emul64_name, blkno);
1272
1273 ASSERT(mutex_owned(&tgt->emul64_tgt_blk_lock));
1274
1275 blk = (blklist_t *)kmem_zalloc(sizeof (blklist_t), KM_SLEEP);
1276 blk->bl_data = (uchar_t *)kmem_zalloc(DEV_BSIZE, KM_SLEEP);
1277 blk->bl_blkno = blkno;
1278 (void) bcopy(data, blk->bl_data, DEV_BSIZE);
1279 avl_insert(&tgt->emul64_tgt_data, (void *) blk, where);
1280
1281 if (emul64_collect_stats) {
1282 mutex_enter(&emul64_stats_mutex);
1283 emul64_nonzero++;
1284 tgt->emul64_list_length++;
1285 if (tgt->emul64_list_length > emul64_max_list_length) {
1286 emul64_max_list_length = tgt->emul64_list_length;
1287 }
1288 mutex_exit(&emul64_stats_mutex);
1289 }
1290 }
1291
1292 static void
1293 bsd_freeblk(emul64_tgt_t *tgt, blklist_t *blk)
1294 {
1295 if (emul64_debug_blklist)
1296 cmn_err(CE_CONT, "%s: bsd_freeblk: <%d,%d> blk=%lld\n",
1297 emul64_name, tgt->emul64_tgt_saddr.a_target,
1298 tgt->emul64_tgt_saddr.a_lun, blk->bl_blkno);
1299
1300 ASSERT(mutex_owned(&tgt->emul64_tgt_blk_lock));
1301
1302 avl_remove(&tgt->emul64_tgt_data, (void *) blk);
1303 if (emul64_collect_stats) {
1304 mutex_enter(&emul64_stats_mutex);
1305 emul64_nonzero--;
1306 tgt->emul64_list_length--;
1307 mutex_exit(&emul64_stats_mutex);
1308 }
1309 kmem_free(blk->bl_data, DEV_BSIZE);
1310 kmem_free(blk, sizeof (blklist_t));
1311 }
1312
1313 /*
1314 * Look for overlap between a nowrite range and a block range.
1315 *
1316 * NOTE: Callers of this function must hold the tgt->emul64_tgt_nw_lock
1317 * lock. For the purposes of this function, a reader lock is
1318 * sufficient.
1319 */
1320 static emul64_rng_overlap_t
1321 bsd_tgt_overlap(emul64_tgt_t *tgt, diskaddr_t blkno, int count)
1322 {
1323 emul64_nowrite_t *nw;
1324 emul64_rng_overlap_t rv = O_NONE;
1325
1326 for (nw = tgt->emul64_tgt_nowrite;
1327 (nw != NULL) && (rv == O_NONE);
1328 nw = nw->emul64_nwnext) {
1329 rv = emul64_overlap(&nw->emul64_blocked, blkno, (size_t)count);
1330 }
1331 return (rv);
1332 }
1333
1334 /*
1335 * Operations that do a lot of I/O, such as RAID 5 initializations, result
1336 * in a CPU bound kernel when the device is an emul64 device. This makes
1337 * the machine look hung. To avoid this problem, give up the CPU from time
1338 * to time.
1339 */
1340
1341 static void
1342 emul64_yield_check()
1343 {
1344 static uint_t emul64_io_count = 0; /* # I/Os since last wait */
1345 static uint_t emul64_waiting = FALSE; /* TRUE -> a thread is in */
1346 /* cv_timed wait. */
1347 clock_t ticks;
1348
1349 if (emul64_yield_enable == 0)
1350 return;
1351
1352 mutex_enter(&emul64_yield_mutex);
1353
1354 if (emul64_waiting == TRUE) {
1355 /*
1356 * Another thread has already started the timer. We'll
1357 * just wait here until their time expires, and they
1358 * broadcast to us. When they do that, we'll return and
1359 * let our caller do more I/O.
1360 */
1361 cv_wait(&emul64_yield_cv, &emul64_yield_mutex);
1362 } else if (emul64_io_count++ > emul64_yield_period) {
1363 /*
1364 * Set emul64_waiting to let other threads know that we
1365 * have started the timer.
1366 */
1367 emul64_waiting = TRUE;
1368 emul64_num_delay_called++;
1369 ticks = drv_usectohz(emul64_yield_length);
1370 if (ticks == 0)
1371 ticks = 1;
1372 (void) cv_reltimedwait(&emul64_yield_cv, &emul64_yield_mutex,
1373 ticks, TR_CLOCK_TICK);
1374 emul64_io_count = 0;
1375 emul64_waiting = FALSE;
1376
1377 /* Broadcast in case others are waiting. */
1378 cv_broadcast(&emul64_yield_cv);
1379 }
1380
1381 mutex_exit(&emul64_yield_mutex);
1382 }