1 /* 2 * Implementation of the Common Access Method Transport (XPT) layer. 3 * 4 * Copyright (c) 1997, 1998, 1999 Justin T. Gibbs. 5 * Copyright (c) 1997, 1998, 1999 Kenneth D. Merry. 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions, and the following disclaimer, 13 * without modification, immediately at the beginning of the file. 14 * 2. The name of the author may not be used to endorse or promote products 15 * derived from this software without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR 21 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 * 29 * $FreeBSD: src/sys/cam/cam_xpt.c,v 1.80.2.18 2002/12/09 17:31:55 gibbs Exp $ 30 */ 31 #include <sys/param.h> 32 #include <sys/systm.h> 33 #include <sys/types.h> 34 #include <sys/malloc.h> 35 #include <sys/kernel.h> 36 #include <sys/time.h> 37 #include <sys/conf.h> 38 #include <sys/device.h> 39 #include <sys/fcntl.h> 40 #include <sys/md5.h> 41 #include <sys/devicestat.h> 42 #include <sys/interrupt.h> 43 #include <sys/sbuf.h> 44 #include <sys/taskqueue.h> 45 #include <sys/bus.h> 46 #include <sys/thread.h> 47 #include <sys/lock.h> 48 #include <sys/spinlock.h> 49 50 #include <sys/spinlock2.h> 51 52 #include <machine/clock.h> 53 #include <machine/stdarg.h> 54 55 #include "cam.h" 56 #include "cam_ccb.h" 57 #include "cam_periph.h" 58 #include "cam_sim.h" 59 #include "cam_xpt.h" 60 #include "cam_xpt_sim.h" 61 #include "cam_xpt_periph.h" 62 #include "cam_debug.h" 63 64 #include "scsi/scsi_all.h" 65 #include "scsi/scsi_message.h" 66 #include "scsi/scsi_pass.h" 67 #include <sys/kthread.h> 68 #include "opt_cam.h" 69 70 /* Datastructures internal to the xpt layer */ 71 MALLOC_DEFINE(M_CAMXPT, "CAM XPT", "CAM XPT buffers"); 72 73 /* Object for defering XPT actions to a taskqueue */ 74 struct xpt_task { 75 struct task task; 76 void *data1; 77 uintptr_t data2; 78 }; 79 80 /* 81 * Definition of an async handler callback block. These are used to add 82 * SIMs and peripherals to the async callback lists. 83 */ 84 struct async_node { 85 SLIST_ENTRY(async_node) links; 86 u_int32_t event_enable; /* Async Event enables */ 87 void (*callback)(void *arg, u_int32_t code, 88 struct cam_path *path, void *args); 89 void *callback_arg; 90 }; 91 92 SLIST_HEAD(async_list, async_node); 93 SLIST_HEAD(periph_list, cam_periph); 94 95 /* 96 * This is the maximum number of high powered commands (e.g. start unit) 97 * that can be outstanding at a particular time. 98 */ 99 #ifndef CAM_MAX_HIGHPOWER 100 #define CAM_MAX_HIGHPOWER 4 101 #endif 102 103 /* 104 * Structure for queueing a device in a run queue. 105 * There is one run queue for allocating new ccbs, 106 * and another for sending ccbs to the controller. 107 */ 108 struct cam_ed_qinfo { 109 cam_pinfo pinfo; 110 struct cam_ed *device; 111 }; 112 113 /* 114 * The CAM EDT (Existing Device Table) contains the device information for 115 * all devices for all busses in the system. The table contains a 116 * cam_ed structure for each device on the bus. 117 */ 118 struct cam_ed { 119 TAILQ_ENTRY(cam_ed) links; 120 struct cam_ed_qinfo alloc_ccb_entry; 121 struct cam_ed_qinfo send_ccb_entry; 122 struct cam_et *target; 123 struct cam_sim *sim; 124 lun_id_t lun_id; 125 struct camq drvq; /* 126 * Queue of type drivers wanting to do 127 * work on this device. 128 */ 129 struct cam_ccbq ccbq; /* Queue of pending ccbs */ 130 struct async_list asyncs; /* Async callback info for this B/T/L */ 131 struct periph_list periphs; /* All attached devices */ 132 u_int generation; /* Generation number */ 133 struct cam_periph *owner; /* Peripheral driver's ownership tag */ 134 struct xpt_quirk_entry *quirk; /* Oddities about this device */ 135 /* Storage for the inquiry data */ 136 cam_proto protocol; 137 u_int protocol_version; 138 cam_xport transport; 139 u_int transport_version; 140 struct scsi_inquiry_data inq_data; 141 u_int8_t inq_flags; /* 142 * Current settings for inquiry flags. 143 * This allows us to override settings 144 * like disconnection and tagged 145 * queuing for a device. 146 */ 147 u_int8_t queue_flags; /* Queue flags from the control page */ 148 u_int8_t serial_num_len; 149 u_int8_t *serial_num; 150 u_int32_t qfrozen_cnt; 151 u_int32_t flags; 152 #define CAM_DEV_UNCONFIGURED 0x01 153 #define CAM_DEV_REL_TIMEOUT_PENDING 0x02 154 #define CAM_DEV_REL_ON_COMPLETE 0x04 155 #define CAM_DEV_REL_ON_QUEUE_EMPTY 0x08 156 #define CAM_DEV_RESIZE_QUEUE_NEEDED 0x10 157 #define CAM_DEV_TAG_AFTER_COUNT 0x20 158 #define CAM_DEV_INQUIRY_DATA_VALID 0x40 159 #define CAM_DEV_IN_DV 0x80 160 #define CAM_DEV_DV_HIT_BOTTOM 0x100 161 u_int32_t tag_delay_count; 162 #define CAM_TAG_DELAY_COUNT 5 163 u_int32_t tag_saved_openings; 164 u_int32_t refcount; 165 struct callout callout; 166 }; 167 168 /* 169 * Each target is represented by an ET (Existing Target). These 170 * entries are created when a target is successfully probed with an 171 * identify, and removed when a device fails to respond after a number 172 * of retries, or a bus rescan finds the device missing. 173 */ 174 struct cam_et { 175 TAILQ_HEAD(, cam_ed) ed_entries; 176 TAILQ_ENTRY(cam_et) links; 177 struct cam_eb *bus; 178 target_id_t target_id; 179 u_int32_t refcount; 180 u_int generation; 181 struct timeval last_reset; /* uptime of last reset */ 182 }; 183 184 /* 185 * Each bus is represented by an EB (Existing Bus). These entries 186 * are created by calls to xpt_bus_register and deleted by calls to 187 * xpt_bus_deregister. 188 */ 189 struct cam_eb { 190 TAILQ_HEAD(, cam_et) et_entries; 191 TAILQ_ENTRY(cam_eb) links; 192 path_id_t path_id; 193 struct cam_sim *sim; 194 struct timeval last_reset; /* uptime of last reset */ 195 u_int32_t flags; 196 #define CAM_EB_RUNQ_SCHEDULED 0x01 197 u_int32_t refcount; 198 u_int generation; 199 int counted_to_config; /* busses_to_config */ 200 }; 201 202 struct cam_path { 203 struct cam_periph *periph; 204 struct cam_eb *bus; 205 struct cam_et *target; 206 struct cam_ed *device; 207 }; 208 209 struct xpt_quirk_entry { 210 struct scsi_inquiry_pattern inq_pat; 211 u_int8_t quirks; 212 #define CAM_QUIRK_NOLUNS 0x01 213 #define CAM_QUIRK_NOSERIAL 0x02 214 #define CAM_QUIRK_HILUNS 0x04 215 #define CAM_QUIRK_NOHILUNS 0x08 216 u_int mintags; 217 u_int maxtags; 218 }; 219 220 static int cam_srch_hi = 0; 221 TUNABLE_INT("kern.cam.cam_srch_hi", &cam_srch_hi); 222 static int sysctl_cam_search_luns(SYSCTL_HANDLER_ARGS); 223 SYSCTL_PROC(_kern_cam, OID_AUTO, cam_srch_hi, CTLTYPE_INT|CTLFLAG_RW, 0, 0, 224 sysctl_cam_search_luns, "I", 225 "allow search above LUN 7 for SCSI3 and greater devices"); 226 227 #define CAM_SCSI2_MAXLUN 8 228 /* 229 * If we're not quirked to search <= the first 8 luns 230 * and we are either quirked to search above lun 8, 231 * or we're > SCSI-2 and we've enabled hilun searching, 232 * or we're > SCSI-2 and the last lun was a success, 233 * we can look for luns above lun 8. 234 */ 235 #define CAN_SRCH_HI_SPARSE(dv) \ 236 (((dv->quirk->quirks & CAM_QUIRK_NOHILUNS) == 0) \ 237 && ((dv->quirk->quirks & CAM_QUIRK_HILUNS) \ 238 || (SID_ANSI_REV(&dv->inq_data) > SCSI_REV_2 && cam_srch_hi))) 239 240 #define CAN_SRCH_HI_DENSE(dv) \ 241 (((dv->quirk->quirks & CAM_QUIRK_NOHILUNS) == 0) \ 242 && ((dv->quirk->quirks & CAM_QUIRK_HILUNS) \ 243 || (SID_ANSI_REV(&dv->inq_data) > SCSI_REV_2))) 244 245 typedef enum { 246 XPT_FLAG_OPEN = 0x01 247 } xpt_flags; 248 249 struct xpt_softc { 250 xpt_flags flags; 251 u_int32_t xpt_generation; 252 253 /* number of high powered commands that can go through right now */ 254 STAILQ_HEAD(highpowerlist, ccb_hdr) highpowerq; 255 int num_highpower; 256 257 /* queue for handling async rescan requests. */ 258 TAILQ_HEAD(, ccb_hdr) ccb_scanq; 259 int ccb_scanq_running; 260 261 /* Registered busses */ 262 TAILQ_HEAD(,cam_eb) xpt_busses; 263 u_int bus_generation; 264 265 struct intr_config_hook *xpt_config_hook; 266 267 struct lock xpt_topo_lock; 268 struct lock xpt_lock; 269 }; 270 271 static const char quantum[] = "QUANTUM"; 272 static const char sony[] = "SONY"; 273 static const char west_digital[] = "WDIGTL"; 274 static const char samsung[] = "SAMSUNG"; 275 static const char seagate[] = "SEAGATE"; 276 static const char microp[] = "MICROP"; 277 278 static struct xpt_quirk_entry xpt_quirk_table[] = 279 { 280 { 281 /* Reports QUEUE FULL for temporary resource shortages */ 282 { T_DIRECT, SIP_MEDIA_FIXED, quantum, "XP39100*", "*" }, 283 /*quirks*/0, /*mintags*/24, /*maxtags*/32 284 }, 285 { 286 /* Reports QUEUE FULL for temporary resource shortages */ 287 { T_DIRECT, SIP_MEDIA_FIXED, quantum, "XP34550*", "*" }, 288 /*quirks*/0, /*mintags*/24, /*maxtags*/32 289 }, 290 { 291 /* Reports QUEUE FULL for temporary resource shortages */ 292 { T_DIRECT, SIP_MEDIA_FIXED, quantum, "XP32275*", "*" }, 293 /*quirks*/0, /*mintags*/24, /*maxtags*/32 294 }, 295 { 296 /* Broken tagged queuing drive */ 297 { T_DIRECT, SIP_MEDIA_FIXED, microp, "4421-07*", "*" }, 298 /*quirks*/0, /*mintags*/0, /*maxtags*/0 299 }, 300 { 301 /* Broken tagged queuing drive */ 302 { T_DIRECT, SIP_MEDIA_FIXED, "HP", "C372*", "*" }, 303 /*quirks*/0, /*mintags*/0, /*maxtags*/0 304 }, 305 { 306 /* Broken tagged queuing drive */ 307 { T_DIRECT, SIP_MEDIA_FIXED, microp, "3391*", "x43h" }, 308 /*quirks*/0, /*mintags*/0, /*maxtags*/0 309 }, 310 { 311 /* 312 * Unfortunately, the Quantum Atlas III has the same 313 * problem as the Atlas II drives above. 314 * Reported by: "Johan Granlund" <johan@granlund.nu> 315 * 316 * For future reference, the drive with the problem was: 317 * QUANTUM QM39100TD-SW N1B0 318 * 319 * It's possible that Quantum will fix the problem in later 320 * firmware revisions. If that happens, the quirk entry 321 * will need to be made specific to the firmware revisions 322 * with the problem. 323 * 324 */ 325 /* Reports QUEUE FULL for temporary resource shortages */ 326 { T_DIRECT, SIP_MEDIA_FIXED, quantum, "QM39100*", "*" }, 327 /*quirks*/0, /*mintags*/24, /*maxtags*/32 328 }, 329 { 330 /* 331 * 18 Gig Atlas III, same problem as the 9G version. 332 * Reported by: Andre Albsmeier 333 * <andre.albsmeier@mchp.siemens.de> 334 * 335 * For future reference, the drive with the problem was: 336 * QUANTUM QM318000TD-S N491 337 */ 338 /* Reports QUEUE FULL for temporary resource shortages */ 339 { T_DIRECT, SIP_MEDIA_FIXED, quantum, "QM318000*", "*" }, 340 /*quirks*/0, /*mintags*/24, /*maxtags*/32 341 }, 342 { 343 /* 344 * Broken tagged queuing drive 345 * Reported by: Bret Ford <bford@uop.cs.uop.edu> 346 * and: Martin Renters <martin@tdc.on.ca> 347 */ 348 { T_DIRECT, SIP_MEDIA_FIXED, seagate, "ST410800*", "71*" }, 349 /*quirks*/0, /*mintags*/0, /*maxtags*/0 350 }, 351 /* 352 * The Seagate Medalist Pro drives have very poor write 353 * performance with anything more than 2 tags. 354 * 355 * Reported by: Paul van der Zwan <paulz@trantor.xs4all.nl> 356 * Drive: <SEAGATE ST36530N 1444> 357 * 358 * Reported by: Jeremy Lea <reg@shale.csir.co.za> 359 * Drive: <SEAGATE ST34520W 1281> 360 * 361 * No one has actually reported that the 9G version 362 * (ST39140*) of the Medalist Pro has the same problem, but 363 * we're assuming that it does because the 4G and 6.5G 364 * versions of the drive are broken. 365 */ 366 { 367 { T_DIRECT, SIP_MEDIA_FIXED, seagate, "ST34520*", "*"}, 368 /*quirks*/0, /*mintags*/2, /*maxtags*/2 369 }, 370 { 371 { T_DIRECT, SIP_MEDIA_FIXED, seagate, "ST36530*", "*"}, 372 /*quirks*/0, /*mintags*/2, /*maxtags*/2 373 }, 374 { 375 { T_DIRECT, SIP_MEDIA_FIXED, seagate, "ST39140*", "*"}, 376 /*quirks*/0, /*mintags*/2, /*maxtags*/2 377 }, 378 { 379 /* 380 * Slow when tagged queueing is enabled. Write performance 381 * steadily drops off with more and more concurrent 382 * transactions. Best sequential write performance with 383 * tagged queueing turned off and write caching turned on. 384 * 385 * PR: kern/10398 386 * Submitted by: Hideaki Okada <hokada@isl.melco.co.jp> 387 * Drive: DCAS-34330 w/ "S65A" firmware. 388 * 389 * The drive with the problem had the "S65A" firmware 390 * revision, and has also been reported (by Stephen J. 391 * Roznowski <sjr@home.net>) for a drive with the "S61A" 392 * firmware revision. 393 * 394 * Although no one has reported problems with the 2 gig 395 * version of the DCAS drive, the assumption is that it 396 * has the same problems as the 4 gig version. Therefore 397 * this quirk entries disables tagged queueing for all 398 * DCAS drives. 399 */ 400 { T_DIRECT, SIP_MEDIA_FIXED, "IBM", "DCAS*", "*" }, 401 /*quirks*/0, /*mintags*/0, /*maxtags*/0 402 }, 403 { 404 /* Broken tagged queuing drive */ 405 { T_DIRECT, SIP_MEDIA_REMOVABLE, "iomega", "jaz*", "*" }, 406 /*quirks*/0, /*mintags*/0, /*maxtags*/0 407 }, 408 { 409 /* Broken tagged queuing drive */ 410 { T_DIRECT, SIP_MEDIA_FIXED, "CONNER", "CFP2107*", "*" }, 411 /*quirks*/0, /*mintags*/0, /*maxtags*/0 412 }, 413 { 414 /* This does not support other than LUN 0 */ 415 { T_DIRECT, SIP_MEDIA_FIXED, "VMware*", "*", "*" }, 416 CAM_QUIRK_NOLUNS, /*mintags*/2, /*maxtags*/255 417 }, 418 { 419 /* 420 * Broken tagged queuing drive. 421 * Submitted by: 422 * NAKAJI Hiroyuki <nakaji@zeisei.dpri.kyoto-u.ac.jp> 423 * in PR kern/9535 424 */ 425 { T_DIRECT, SIP_MEDIA_FIXED, samsung, "WN34324U*", "*" }, 426 /*quirks*/0, /*mintags*/0, /*maxtags*/0 427 }, 428 { 429 /* 430 * Slow when tagged queueing is enabled. (1.5MB/sec versus 431 * 8MB/sec.) 432 * Submitted by: Andrew Gallatin <gallatin@cs.duke.edu> 433 * Best performance with these drives is achieved with 434 * tagged queueing turned off, and write caching turned on. 435 */ 436 { T_DIRECT, SIP_MEDIA_FIXED, west_digital, "WDE*", "*" }, 437 /*quirks*/0, /*mintags*/0, /*maxtags*/0 438 }, 439 { 440 /* 441 * Slow when tagged queueing is enabled. (1.5MB/sec versus 442 * 8MB/sec.) 443 * Submitted by: Andrew Gallatin <gallatin@cs.duke.edu> 444 * Best performance with these drives is achieved with 445 * tagged queueing turned off, and write caching turned on. 446 */ 447 { T_DIRECT, SIP_MEDIA_FIXED, west_digital, "ENTERPRISE", "*" }, 448 /*quirks*/0, /*mintags*/0, /*maxtags*/0 449 }, 450 { 451 /* 452 * Doesn't handle queue full condition correctly, 453 * so we need to limit maxtags to what the device 454 * can handle instead of determining this automatically. 455 */ 456 { T_DIRECT, SIP_MEDIA_FIXED, samsung, "WN321010S*", "*" }, 457 /*quirks*/0, /*mintags*/2, /*maxtags*/32 458 }, 459 { 460 /* Really only one LUN */ 461 { T_ENCLOSURE, SIP_MEDIA_FIXED, "SUN", "SENA", "*" }, 462 CAM_QUIRK_NOLUNS, /*mintags*/0, /*maxtags*/0 463 }, 464 { 465 /* I can't believe we need a quirk for DPT volumes. */ 466 { T_ANY, SIP_MEDIA_FIXED|SIP_MEDIA_REMOVABLE, "DPT", "*", "*" }, 467 CAM_QUIRK_NOLUNS, 468 /*mintags*/0, /*maxtags*/255 469 }, 470 { 471 /* 472 * Many Sony CDROM drives don't like multi-LUN probing. 473 */ 474 { T_CDROM, SIP_MEDIA_REMOVABLE, sony, "CD-ROM CDU*", "*" }, 475 CAM_QUIRK_NOLUNS, /*mintags*/0, /*maxtags*/0 476 }, 477 { 478 /* 479 * This drive doesn't like multiple LUN probing. 480 * Submitted by: Parag Patel <parag@cgt.com> 481 */ 482 { T_WORM, SIP_MEDIA_REMOVABLE, sony, "CD-R CDU9*", "*" }, 483 CAM_QUIRK_NOLUNS, /*mintags*/0, /*maxtags*/0 484 }, 485 { 486 { T_WORM, SIP_MEDIA_REMOVABLE, "YAMAHA", "CDR100*", "*" }, 487 CAM_QUIRK_NOLUNS, /*mintags*/0, /*maxtags*/0 488 }, 489 { 490 /* 491 * The 8200 doesn't like multi-lun probing, and probably 492 * don't like serial number requests either. 493 */ 494 { 495 T_SEQUENTIAL, SIP_MEDIA_REMOVABLE, "EXABYTE", 496 "EXB-8200*", "*" 497 }, 498 CAM_QUIRK_NOLUNS, /*mintags*/0, /*maxtags*/0 499 }, 500 { 501 /* 502 * Let's try the same as above, but for a drive that says 503 * it's an IPL-6860 but is actually an EXB 8200. 504 */ 505 { 506 T_SEQUENTIAL, SIP_MEDIA_REMOVABLE, "EXABYTE", 507 "IPL-6860*", "*" 508 }, 509 CAM_QUIRK_NOLUNS, /*mintags*/0, /*maxtags*/0 510 }, 511 { 512 /* 513 * These Hitachi drives don't like multi-lun probing. 514 * The PR submitter has a DK319H, but says that the Linux 515 * kernel has a similar work-around for the DK312 and DK314, 516 * so all DK31* drives are quirked here. 517 * PR: misc/18793 518 * Submitted by: Paul Haddad <paul@pth.com> 519 */ 520 { T_DIRECT, SIP_MEDIA_FIXED, "HITACHI", "DK31*", "*" }, 521 CAM_QUIRK_NOLUNS, /*mintags*/2, /*maxtags*/255 522 }, 523 { 524 /* 525 * The Hitachi CJ series with J8A8 firmware apparantly has 526 * problems with tagged commands. 527 * PR: 23536 528 * Reported by: amagai@nue.org 529 */ 530 { T_DIRECT, SIP_MEDIA_FIXED, "HITACHI", "DK32CJ*", "J8A8" }, 531 CAM_QUIRK_NOLUNS, /*mintags*/0, /*maxtags*/0 532 }, 533 { 534 /* 535 * These are the large storage arrays. 536 * Submitted by: William Carrel <william.carrel@infospace.com> 537 */ 538 { T_DIRECT, SIP_MEDIA_FIXED, "HITACHI", "OPEN*", "*" }, 539 CAM_QUIRK_HILUNS, 2, 1024 540 }, 541 { 542 /* 543 * This old revision of the TDC3600 is also SCSI-1, and 544 * hangs upon serial number probing. 545 */ 546 { 547 T_SEQUENTIAL, SIP_MEDIA_REMOVABLE, "TANDBERG", 548 " TDC 3600", "U07:" 549 }, 550 CAM_QUIRK_NOSERIAL, /*mintags*/0, /*maxtags*/0 551 }, 552 { 553 /* 554 * Would repond to all LUNs if asked for. 555 */ 556 { 557 T_SEQUENTIAL, SIP_MEDIA_REMOVABLE, "CALIPER", 558 "CP150", "*" 559 }, 560 CAM_QUIRK_NOLUNS, /*mintags*/0, /*maxtags*/0 561 }, 562 { 563 /* 564 * Would repond to all LUNs if asked for. 565 */ 566 { 567 T_SEQUENTIAL, SIP_MEDIA_REMOVABLE, "KENNEDY", 568 "96X2*", "*" 569 }, 570 CAM_QUIRK_NOLUNS, /*mintags*/0, /*maxtags*/0 571 }, 572 { 573 /* Submitted by: Matthew Dodd <winter@jurai.net> */ 574 { T_PROCESSOR, SIP_MEDIA_FIXED, "Cabletrn", "EA41*", "*" }, 575 CAM_QUIRK_NOLUNS, /*mintags*/0, /*maxtags*/0 576 }, 577 { 578 /* Submitted by: Matthew Dodd <winter@jurai.net> */ 579 { T_PROCESSOR, SIP_MEDIA_FIXED, "CABLETRN", "EA41*", "*" }, 580 CAM_QUIRK_NOLUNS, /*mintags*/0, /*maxtags*/0 581 }, 582 { 583 /* TeraSolutions special settings for TRC-22 RAID */ 584 { T_DIRECT, SIP_MEDIA_FIXED, "TERASOLU", "TRC-22", "*" }, 585 /*quirks*/0, /*mintags*/55, /*maxtags*/255 586 }, 587 { 588 /* Veritas Storage Appliance */ 589 { T_DIRECT, SIP_MEDIA_FIXED, "VERITAS", "*", "*" }, 590 CAM_QUIRK_HILUNS, /*mintags*/2, /*maxtags*/1024 591 }, 592 { 593 /* 594 * Would respond to all LUNs. Device type and removable 595 * flag are jumper-selectable. 596 */ 597 { T_ANY, SIP_MEDIA_REMOVABLE|SIP_MEDIA_FIXED, "MaxOptix", 598 "Tahiti 1", "*" 599 }, 600 CAM_QUIRK_NOLUNS, /*mintags*/0, /*maxtags*/0 601 }, 602 { 603 /* EasyRAID E5A aka. areca ARC-6010 */ 604 { T_DIRECT, SIP_MEDIA_FIXED, "easyRAID", "*", "*" }, 605 CAM_QUIRK_NOHILUNS, /*mintags*/2, /*maxtags*/255 606 }, 607 { 608 { T_ENCLOSURE, SIP_MEDIA_FIXED, "DP", "BACKPLANE", "*" }, 609 CAM_QUIRK_NOLUNS, /*mintags*/0, /*maxtags*/0 610 }, 611 { 612 /* Default tagged queuing parameters for all devices */ 613 { 614 T_ANY, SIP_MEDIA_REMOVABLE|SIP_MEDIA_FIXED, 615 /*vendor*/"*", /*product*/"*", /*revision*/"*" 616 }, 617 /*quirks*/0, /*mintags*/2, /*maxtags*/255 618 }, 619 }; 620 621 static const int xpt_quirk_table_size = NELEM(xpt_quirk_table); 622 623 typedef enum { 624 DM_RET_COPY = 0x01, 625 DM_RET_FLAG_MASK = 0x0f, 626 DM_RET_NONE = 0x00, 627 DM_RET_STOP = 0x10, 628 DM_RET_DESCEND = 0x20, 629 DM_RET_ERROR = 0x30, 630 DM_RET_ACTION_MASK = 0xf0 631 } dev_match_ret; 632 633 typedef enum { 634 XPT_DEPTH_BUS, 635 XPT_DEPTH_TARGET, 636 XPT_DEPTH_DEVICE, 637 XPT_DEPTH_PERIPH 638 } xpt_traverse_depth; 639 640 struct xpt_traverse_config { 641 xpt_traverse_depth depth; 642 void *tr_func; 643 void *tr_arg; 644 }; 645 646 typedef int xpt_busfunc_t (struct cam_eb *bus, void *arg); 647 typedef int xpt_targetfunc_t (struct cam_et *target, void *arg); 648 typedef int xpt_devicefunc_t (struct cam_ed *device, void *arg); 649 typedef int xpt_periphfunc_t (struct cam_periph *periph, void *arg); 650 typedef int xpt_pdrvfunc_t (struct periph_driver **pdrv, void *arg); 651 652 /* Transport layer configuration information */ 653 static struct xpt_softc xsoftc; 654 655 /* Queues for our software interrupt handler */ 656 typedef TAILQ_HEAD(cam_isrq, ccb_hdr) cam_isrq_t; 657 typedef TAILQ_HEAD(cam_simq, cam_sim) cam_simq_t; 658 static cam_simq_t cam_simq; 659 static struct spinlock cam_simq_spin; 660 661 struct cam_periph *xpt_periph; 662 663 static periph_init_t xpt_periph_init; 664 665 static periph_init_t probe_periph_init; 666 667 static struct periph_driver xpt_driver = 668 { 669 xpt_periph_init, "xpt", 670 TAILQ_HEAD_INITIALIZER(xpt_driver.units) 671 }; 672 673 static struct periph_driver probe_driver = 674 { 675 probe_periph_init, "probe", 676 TAILQ_HEAD_INITIALIZER(probe_driver.units) 677 }; 678 679 PERIPHDRIVER_DECLARE(xpt, xpt_driver); 680 PERIPHDRIVER_DECLARE(probe, probe_driver); 681 682 static d_open_t xptopen; 683 static d_close_t xptclose; 684 static d_ioctl_t xptioctl; 685 686 static struct dev_ops xpt_ops = { 687 { "xpt", 0, D_MPSAFE }, 688 .d_open = xptopen, 689 .d_close = xptclose, 690 .d_ioctl = xptioctl 691 }; 692 693 static void dead_sim_action(struct cam_sim *sim, union ccb *ccb); 694 static void dead_sim_poll(struct cam_sim *sim); 695 696 /* Dummy SIM that is used when the real one has gone. */ 697 static struct cam_sim cam_dead_sim; 698 static struct lock cam_dead_lock; 699 700 /* Storage for debugging datastructures */ 701 #ifdef CAMDEBUG 702 struct cam_path *cam_dpath; 703 u_int32_t cam_dflags; 704 u_int32_t cam_debug_delay; 705 #endif 706 707 #if defined(CAM_DEBUG_FLAGS) && !defined(CAMDEBUG) 708 #error "You must have options CAMDEBUG to use options CAM_DEBUG_FLAGS" 709 #endif 710 711 /* 712 * In order to enable the CAM_DEBUG_* options, the user must have CAMDEBUG 713 * enabled. Also, the user must have either none, or all of CAM_DEBUG_BUS, 714 * CAM_DEBUG_TARGET, and CAM_DEBUG_LUN specified. 715 */ 716 #if defined(CAM_DEBUG_BUS) || defined(CAM_DEBUG_TARGET) \ 717 || defined(CAM_DEBUG_LUN) 718 #ifdef CAMDEBUG 719 #if !defined(CAM_DEBUG_BUS) || !defined(CAM_DEBUG_TARGET) \ 720 || !defined(CAM_DEBUG_LUN) 721 #error "You must define all or none of CAM_DEBUG_BUS, CAM_DEBUG_TARGET \ 722 and CAM_DEBUG_LUN" 723 #endif /* !CAM_DEBUG_BUS || !CAM_DEBUG_TARGET || !CAM_DEBUG_LUN */ 724 #else /* !CAMDEBUG */ 725 #error "You must use options CAMDEBUG if you use the CAM_DEBUG_* options" 726 #endif /* CAMDEBUG */ 727 #endif /* CAM_DEBUG_BUS || CAM_DEBUG_TARGET || CAM_DEBUG_LUN */ 728 729 /* Our boot-time initialization hook */ 730 static int cam_module_event_handler(module_t, int /*modeventtype_t*/, void *); 731 732 static moduledata_t cam_moduledata = { 733 "cam", 734 cam_module_event_handler, 735 NULL 736 }; 737 738 static int xpt_init(void *); 739 740 DECLARE_MODULE(cam, cam_moduledata, SI_SUB_CONFIGURE, SI_ORDER_SECOND); 741 MODULE_VERSION(cam, 1); 742 743 744 static cam_status xpt_compile_path(struct cam_path *new_path, 745 struct cam_periph *perph, 746 path_id_t path_id, 747 target_id_t target_id, 748 lun_id_t lun_id); 749 750 static void xpt_release_path(struct cam_path *path); 751 752 static void xpt_async_bcast(struct async_list *async_head, 753 u_int32_t async_code, 754 struct cam_path *path, 755 void *async_arg); 756 static void xpt_dev_async(u_int32_t async_code, 757 struct cam_eb *bus, 758 struct cam_et *target, 759 struct cam_ed *device, 760 void *async_arg); 761 static path_id_t xptnextfreepathid(void); 762 static path_id_t xptpathid(const char *sim_name, int sim_unit, int sim_bus); 763 static union ccb *xpt_get_ccb(struct cam_ed *device); 764 static int xpt_schedule_dev(struct camq *queue, cam_pinfo *dev_pinfo, 765 u_int32_t new_priority); 766 static void xpt_run_dev_allocq(struct cam_eb *bus); 767 static void xpt_run_dev_sendq(struct cam_eb *bus); 768 static timeout_t xpt_release_devq_timeout; 769 static void xpt_release_bus(struct cam_eb *bus); 770 static void xpt_release_devq_device(struct cam_ed *dev, u_int count, 771 int run_queue); 772 static struct cam_et* 773 xpt_alloc_target(struct cam_eb *bus, target_id_t target_id); 774 static void xpt_release_target(struct cam_eb *bus, struct cam_et *target); 775 static struct cam_ed* 776 xpt_alloc_device(struct cam_eb *bus, struct cam_et *target, 777 lun_id_t lun_id); 778 static void xpt_release_device(struct cam_eb *bus, struct cam_et *target, 779 struct cam_ed *device); 780 static u_int32_t xpt_dev_ccbq_resize(struct cam_path *path, int newopenings); 781 static struct cam_eb* 782 xpt_find_bus(path_id_t path_id); 783 static struct cam_et* 784 xpt_find_target(struct cam_eb *bus, target_id_t target_id); 785 static struct cam_ed* 786 xpt_find_device(struct cam_et *target, lun_id_t lun_id); 787 static void xpt_scan_bus(struct cam_periph *periph, union ccb *ccb); 788 static void xpt_scan_lun(struct cam_periph *periph, 789 struct cam_path *path, cam_flags flags, 790 union ccb *ccb); 791 static void xptscandone(struct cam_periph *periph, union ccb *done_ccb); 792 static xpt_busfunc_t xptconfigbuscountfunc; 793 static xpt_busfunc_t xptconfigfunc; 794 static void xpt_config(void *arg); 795 static xpt_devicefunc_t xptpassannouncefunc; 796 static void xpt_finishconfig(struct cam_periph *periph, union ccb *ccb); 797 static void xpt_uncount_bus (struct cam_eb *bus); 798 static void xptaction(struct cam_sim *sim, union ccb *work_ccb); 799 static void xptpoll(struct cam_sim *sim); 800 static inthand2_t swi_cambio; 801 static void camisr(void *); 802 static void camisr_runqueue(struct cam_sim *); 803 static dev_match_ret xptbusmatch(struct dev_match_pattern *patterns, 804 u_int num_patterns, struct cam_eb *bus); 805 static dev_match_ret xptdevicematch(struct dev_match_pattern *patterns, 806 u_int num_patterns, 807 struct cam_ed *device); 808 static dev_match_ret xptperiphmatch(struct dev_match_pattern *patterns, 809 u_int num_patterns, 810 struct cam_periph *periph); 811 static xpt_busfunc_t xptedtbusfunc; 812 static xpt_targetfunc_t xptedttargetfunc; 813 static xpt_devicefunc_t xptedtdevicefunc; 814 static xpt_periphfunc_t xptedtperiphfunc; 815 static xpt_pdrvfunc_t xptplistpdrvfunc; 816 static xpt_periphfunc_t xptplistperiphfunc; 817 static int xptedtmatch(struct ccb_dev_match *cdm); 818 static int xptperiphlistmatch(struct ccb_dev_match *cdm); 819 static int xptbustraverse(struct cam_eb *start_bus, 820 xpt_busfunc_t *tr_func, void *arg); 821 static int xpttargettraverse(struct cam_eb *bus, 822 struct cam_et *start_target, 823 xpt_targetfunc_t *tr_func, void *arg); 824 static int xptdevicetraverse(struct cam_et *target, 825 struct cam_ed *start_device, 826 xpt_devicefunc_t *tr_func, void *arg); 827 static int xptperiphtraverse(struct cam_ed *device, 828 struct cam_periph *start_periph, 829 xpt_periphfunc_t *tr_func, void *arg); 830 static int xptpdrvtraverse(struct periph_driver **start_pdrv, 831 xpt_pdrvfunc_t *tr_func, void *arg); 832 static int xptpdperiphtraverse(struct periph_driver **pdrv, 833 struct cam_periph *start_periph, 834 xpt_periphfunc_t *tr_func, 835 void *arg); 836 static xpt_busfunc_t xptdefbusfunc; 837 static xpt_targetfunc_t xptdeftargetfunc; 838 static xpt_devicefunc_t xptdefdevicefunc; 839 static xpt_periphfunc_t xptdefperiphfunc; 840 static int xpt_for_all_busses(xpt_busfunc_t *tr_func, void *arg); 841 static int xpt_for_all_devices(xpt_devicefunc_t *tr_func, 842 void *arg); 843 static xpt_devicefunc_t xptsetasyncfunc; 844 static xpt_busfunc_t xptsetasyncbusfunc; 845 static cam_status xptregister(struct cam_periph *periph, 846 void *arg); 847 static cam_status proberegister(struct cam_periph *periph, 848 void *arg); 849 static void probeschedule(struct cam_periph *probe_periph); 850 static void probestart(struct cam_periph *periph, union ccb *start_ccb); 851 static void proberequestdefaultnegotiation(struct cam_periph *periph); 852 static int proberequestbackoff(struct cam_periph *periph, 853 struct cam_ed *device); 854 static void probedone(struct cam_periph *periph, union ccb *done_ccb); 855 static void probecleanup(struct cam_periph *periph); 856 static void xpt_find_quirk(struct cam_ed *device); 857 static void xpt_devise_transport(struct cam_path *path); 858 static void xpt_set_transfer_settings(struct ccb_trans_settings *cts, 859 struct cam_ed *device, 860 int async_update); 861 static void xpt_toggle_tags(struct cam_path *path); 862 static void xpt_start_tags(struct cam_path *path); 863 static __inline int xpt_schedule_dev_allocq(struct cam_eb *bus, 864 struct cam_ed *dev); 865 static __inline int xpt_schedule_dev_sendq(struct cam_eb *bus, 866 struct cam_ed *dev); 867 static __inline int periph_is_queued(struct cam_periph *periph); 868 static __inline int device_is_alloc_queued(struct cam_ed *device); 869 static __inline int device_is_send_queued(struct cam_ed *device); 870 static __inline int dev_allocq_is_runnable(struct cam_devq *devq); 871 872 static __inline int 873 xpt_schedule_dev_allocq(struct cam_eb *bus, struct cam_ed *dev) 874 { 875 int retval; 876 877 if (bus->sim->devq && dev->ccbq.devq_openings > 0) { 878 if ((dev->flags & CAM_DEV_RESIZE_QUEUE_NEEDED) != 0) { 879 cam_ccbq_resize(&dev->ccbq, 880 dev->ccbq.dev_openings 881 + dev->ccbq.dev_active); 882 dev->flags &= ~CAM_DEV_RESIZE_QUEUE_NEEDED; 883 } 884 /* 885 * The priority of a device waiting for CCB resources 886 * is that of the the highest priority peripheral driver 887 * enqueued. 888 */ 889 retval = xpt_schedule_dev(&bus->sim->devq->alloc_queue, 890 &dev->alloc_ccb_entry.pinfo, 891 CAMQ_GET_HEAD(&dev->drvq)->priority); 892 } else { 893 retval = 0; 894 } 895 896 return (retval); 897 } 898 899 static __inline int 900 xpt_schedule_dev_sendq(struct cam_eb *bus, struct cam_ed *dev) 901 { 902 int retval; 903 904 if (bus->sim->devq && dev->ccbq.dev_openings > 0) { 905 /* 906 * The priority of a device waiting for controller 907 * resources is that of the the highest priority CCB 908 * enqueued. 909 */ 910 retval = 911 xpt_schedule_dev(&bus->sim->devq->send_queue, 912 &dev->send_ccb_entry.pinfo, 913 CAMQ_GET_HEAD(&dev->ccbq.queue)->priority); 914 } else { 915 retval = 0; 916 } 917 return (retval); 918 } 919 920 static __inline int 921 periph_is_queued(struct cam_periph *periph) 922 { 923 return (periph->pinfo.index != CAM_UNQUEUED_INDEX); 924 } 925 926 static __inline int 927 device_is_alloc_queued(struct cam_ed *device) 928 { 929 return (device->alloc_ccb_entry.pinfo.index != CAM_UNQUEUED_INDEX); 930 } 931 932 static __inline int 933 device_is_send_queued(struct cam_ed *device) 934 { 935 return (device->send_ccb_entry.pinfo.index != CAM_UNQUEUED_INDEX); 936 } 937 938 static __inline int 939 dev_allocq_is_runnable(struct cam_devq *devq) 940 { 941 /* 942 * Have work to do. 943 * Have space to do more work. 944 * Allowed to do work. 945 */ 946 return ((devq->alloc_queue.qfrozen_cnt == 0) 947 && (devq->alloc_queue.entries > 0) 948 && (devq->alloc_openings > 0)); 949 } 950 951 static void 952 xpt_periph_init(void) 953 { 954 make_dev(&xpt_ops, 0, UID_ROOT, GID_OPERATOR, 0600, "xpt0"); 955 } 956 957 static void 958 probe_periph_init(void) 959 { 960 } 961 962 963 static void 964 xptdone(struct cam_periph *periph, union ccb *done_ccb) 965 { 966 /* Caller will release the CCB */ 967 wakeup(&done_ccb->ccb_h.cbfcnp); 968 } 969 970 static int 971 xptopen(struct dev_open_args *ap) 972 { 973 cdev_t dev = ap->a_head.a_dev; 974 975 /* 976 * Only allow read-write access. 977 */ 978 if (((ap->a_oflags & FWRITE) == 0) || ((ap->a_oflags & FREAD) == 0)) 979 return(EPERM); 980 981 /* 982 * We don't allow nonblocking access. 983 */ 984 if ((ap->a_oflags & O_NONBLOCK) != 0) { 985 kprintf("%s: can't do nonblocking access\n", devtoname(dev)); 986 return(ENODEV); 987 } 988 989 /* Mark ourselves open */ 990 lockmgr(&xsoftc.xpt_lock, LK_EXCLUSIVE); 991 xsoftc.flags |= XPT_FLAG_OPEN; 992 lockmgr(&xsoftc.xpt_lock, LK_RELEASE); 993 994 return(0); 995 } 996 997 static int 998 xptclose(struct dev_close_args *ap) 999 { 1000 1001 /* Mark ourselves closed */ 1002 lockmgr(&xsoftc.xpt_lock, LK_EXCLUSIVE); 1003 xsoftc.flags &= ~XPT_FLAG_OPEN; 1004 lockmgr(&xsoftc.xpt_lock, LK_RELEASE); 1005 1006 return(0); 1007 } 1008 1009 /* 1010 * Don't automatically grab the xpt softc lock here even though this is going 1011 * through the xpt device. The xpt device is really just a back door for 1012 * accessing other devices and SIMs, so the right thing to do is to grab 1013 * the appropriate SIM lock once the bus/SIM is located. 1014 */ 1015 static int 1016 xptioctl(struct dev_ioctl_args *ap) 1017 { 1018 int error; 1019 1020 error = 0; 1021 1022 switch(ap->a_cmd) { 1023 /* 1024 * For the transport layer CAMIOCOMMAND ioctl, we really only want 1025 * to accept CCB types that don't quite make sense to send through a 1026 * passthrough driver. 1027 */ 1028 case CAMIOCOMMAND: { 1029 union ccb *ccb; 1030 union ccb *inccb; 1031 struct cam_eb *bus; 1032 1033 inccb = (union ccb *)ap->a_data; 1034 1035 bus = xpt_find_bus(inccb->ccb_h.path_id); 1036 if (bus == NULL) { 1037 error = EINVAL; 1038 break; 1039 } 1040 1041 switch(inccb->ccb_h.func_code) { 1042 case XPT_SCAN_BUS: 1043 case XPT_RESET_BUS: 1044 if ((inccb->ccb_h.target_id != CAM_TARGET_WILDCARD) 1045 || (inccb->ccb_h.target_lun != CAM_LUN_WILDCARD)) { 1046 error = EINVAL; 1047 break; 1048 } 1049 /* FALLTHROUGH */ 1050 case XPT_PATH_INQ: 1051 case XPT_ENG_INQ: 1052 case XPT_SCAN_LUN: 1053 1054 ccb = xpt_alloc_ccb(); 1055 1056 CAM_SIM_LOCK(bus->sim); 1057 1058 /* 1059 * Create a path using the bus, target, and lun the 1060 * user passed in. 1061 */ 1062 if (xpt_create_path(&ccb->ccb_h.path, xpt_periph, 1063 inccb->ccb_h.path_id, 1064 inccb->ccb_h.target_id, 1065 inccb->ccb_h.target_lun) != 1066 CAM_REQ_CMP){ 1067 error = EINVAL; 1068 CAM_SIM_UNLOCK(bus->sim); 1069 xpt_free_ccb(&ccb->ccb_h); 1070 break; 1071 } 1072 /* Ensure all of our fields are correct */ 1073 xpt_setup_ccb(&ccb->ccb_h, ccb->ccb_h.path, 1074 inccb->ccb_h.pinfo.priority); 1075 xpt_merge_ccb(ccb, inccb); 1076 ccb->ccb_h.cbfcnp = xptdone; 1077 cam_periph_runccb(ccb, NULL, 0, 0, NULL); 1078 bcopy(ccb, inccb, sizeof(union ccb)); 1079 xpt_free_path(ccb->ccb_h.path); 1080 xpt_free_ccb(&ccb->ccb_h); 1081 CAM_SIM_UNLOCK(bus->sim); 1082 break; 1083 1084 case XPT_DEBUG: { 1085 union ccb *ccb; 1086 1087 ccb = xpt_alloc_ccb(); 1088 1089 /* 1090 * This is an immediate CCB, so it's okay to 1091 * allocate it on the stack. 1092 */ 1093 1094 CAM_SIM_LOCK(bus->sim); 1095 1096 /* 1097 * Create a path using the bus, target, and lun the 1098 * user passed in. 1099 */ 1100 if (xpt_create_path(&ccb->ccb_h.path, xpt_periph, 1101 inccb->ccb_h.path_id, 1102 inccb->ccb_h.target_id, 1103 inccb->ccb_h.target_lun) != 1104 CAM_REQ_CMP){ 1105 error = EINVAL; 1106 CAM_SIM_UNLOCK(bus->sim); 1107 xpt_free_ccb(&ccb->ccb_h); 1108 break; 1109 } 1110 /* Ensure all of our fields are correct */ 1111 xpt_setup_ccb(&ccb->ccb_h, ccb->ccb_h.path, 1112 inccb->ccb_h.pinfo.priority); 1113 xpt_merge_ccb(ccb, inccb); 1114 ccb->ccb_h.cbfcnp = xptdone; 1115 xpt_action(ccb); 1116 CAM_SIM_UNLOCK(bus->sim); 1117 bcopy(ccb, inccb, sizeof(union ccb)); 1118 inccb->ccb_h.timeout_ch = NULL; /* SAFETY */ 1119 xpt_free_path(ccb->ccb_h.path); 1120 xpt_free_ccb(&ccb->ccb_h); 1121 1122 break; 1123 1124 } 1125 case XPT_DEV_MATCH: { 1126 struct cam_periph_map_info mapinfo; 1127 struct cam_path *old_path; 1128 1129 /* 1130 * We can't deal with physical addresses for this 1131 * type of transaction. 1132 */ 1133 if (inccb->ccb_h.flags & CAM_DATA_PHYS) { 1134 error = EINVAL; 1135 break; 1136 } 1137 1138 /* 1139 * Save this in case the caller had it set to 1140 * something in particular. 1141 */ 1142 old_path = inccb->ccb_h.path; 1143 1144 /* 1145 * We really don't need a path for the matching 1146 * code. The path is needed because of the 1147 * debugging statements in xpt_action(). They 1148 * assume that the CCB has a valid path. 1149 */ 1150 inccb->ccb_h.path = xpt_periph->path; 1151 1152 bzero(&mapinfo, sizeof(mapinfo)); 1153 1154 /* 1155 * Map the pattern and match buffers into kernel 1156 * virtual address space. 1157 */ 1158 error = cam_periph_mapmem(inccb, &mapinfo); 1159 1160 if (error) { 1161 inccb->ccb_h.path = old_path; 1162 break; 1163 } 1164 1165 /* 1166 * This is an immediate CCB, we can send it on directly. 1167 */ 1168 xpt_action(inccb); 1169 1170 /* 1171 * Map the buffers back into user space. 1172 */ 1173 cam_periph_unmapmem(inccb, &mapinfo); 1174 1175 inccb->ccb_h.path = old_path; 1176 1177 error = 0; 1178 break; 1179 } 1180 default: 1181 error = ENOTSUP; 1182 break; 1183 } 1184 xpt_release_bus(bus); 1185 break; 1186 } 1187 /* 1188 * This is the getpassthru ioctl. It takes a XPT_GDEVLIST ccb as input, 1189 * with the periphal driver name and unit name filled in. The other 1190 * fields don't really matter as input. The passthrough driver name 1191 * ("pass"), and unit number are passed back in the ccb. The current 1192 * device generation number, and the index into the device peripheral 1193 * driver list, and the status are also passed back. Note that 1194 * since we do everything in one pass, unlike the XPT_GDEVLIST ccb, 1195 * we never return a status of CAM_GDEVLIST_LIST_CHANGED. It is 1196 * (or rather should be) impossible for the device peripheral driver 1197 * list to change since we look at the whole thing in one pass, and 1198 * we do it with lock protection. 1199 * 1200 */ 1201 case CAMGETPASSTHRU: { 1202 union ccb *ccb; 1203 struct cam_periph *periph; 1204 struct periph_driver **p_drv; 1205 char *name; 1206 u_int unit; 1207 u_int cur_generation; 1208 int base_periph_found; 1209 int splbreaknum; 1210 1211 ccb = (union ccb *)ap->a_data; 1212 unit = ccb->cgdl.unit_number; 1213 name = ccb->cgdl.periph_name; 1214 /* 1215 * Every 100 devices, we want to drop our lock protection to 1216 * give the software interrupt handler a chance to run. 1217 * Most systems won't run into this check, but this should 1218 * avoid starvation in the software interrupt handler in 1219 * large systems. 1220 */ 1221 splbreaknum = 100; 1222 1223 ccb = (union ccb *)ap->a_data; 1224 1225 base_periph_found = 0; 1226 1227 /* 1228 * Sanity check -- make sure we don't get a null peripheral 1229 * driver name. 1230 */ 1231 if (*ccb->cgdl.periph_name == '\0') { 1232 error = EINVAL; 1233 break; 1234 } 1235 1236 /* Keep the list from changing while we traverse it */ 1237 lockmgr(&xsoftc.xpt_topo_lock, LK_EXCLUSIVE); 1238 ptstartover: 1239 cur_generation = xsoftc.xpt_generation; 1240 1241 /* first find our driver in the list of drivers */ 1242 for (p_drv = periph_drivers; *p_drv != NULL; p_drv++) { 1243 if (strcmp((*p_drv)->driver_name, name) == 0) 1244 break; 1245 } 1246 1247 if (*p_drv == NULL) { 1248 lockmgr(&xsoftc.xpt_topo_lock, LK_RELEASE); 1249 ccb->ccb_h.status = CAM_REQ_CMP_ERR; 1250 ccb->cgdl.status = CAM_GDEVLIST_ERROR; 1251 *ccb->cgdl.periph_name = '\0'; 1252 ccb->cgdl.unit_number = 0; 1253 error = ENOENT; 1254 break; 1255 } 1256 1257 /* 1258 * Run through every peripheral instance of this driver 1259 * and check to see whether it matches the unit passed 1260 * in by the user. If it does, get out of the loops and 1261 * find the passthrough driver associated with that 1262 * peripheral driver. 1263 */ 1264 TAILQ_FOREACH(periph, &(*p_drv)->units, unit_links) { 1265 1266 if (periph->unit_number == unit) { 1267 break; 1268 } else if (--splbreaknum == 0) { 1269 lockmgr(&xsoftc.xpt_topo_lock, LK_RELEASE); 1270 lockmgr(&xsoftc.xpt_topo_lock, LK_EXCLUSIVE); 1271 splbreaknum = 100; 1272 if (cur_generation != xsoftc.xpt_generation) 1273 goto ptstartover; 1274 } 1275 } 1276 /* 1277 * If we found the peripheral driver that the user passed 1278 * in, go through all of the peripheral drivers for that 1279 * particular device and look for a passthrough driver. 1280 */ 1281 if (periph != NULL) { 1282 struct cam_ed *device; 1283 int i; 1284 1285 base_periph_found = 1; 1286 device = periph->path->device; 1287 for (i = 0, periph = SLIST_FIRST(&device->periphs); 1288 periph != NULL; 1289 periph = SLIST_NEXT(periph, periph_links), i++) { 1290 /* 1291 * Check to see whether we have a 1292 * passthrough device or not. 1293 */ 1294 if (strcmp(periph->periph_name, "pass") == 0) { 1295 /* 1296 * Fill in the getdevlist fields. 1297 */ 1298 strcpy(ccb->cgdl.periph_name, 1299 periph->periph_name); 1300 ccb->cgdl.unit_number = 1301 periph->unit_number; 1302 if (SLIST_NEXT(periph, periph_links)) 1303 ccb->cgdl.status = 1304 CAM_GDEVLIST_MORE_DEVS; 1305 else 1306 ccb->cgdl.status = 1307 CAM_GDEVLIST_LAST_DEVICE; 1308 ccb->cgdl.generation = 1309 device->generation; 1310 ccb->cgdl.index = i; 1311 /* 1312 * Fill in some CCB header fields 1313 * that the user may want. 1314 */ 1315 ccb->ccb_h.path_id = 1316 periph->path->bus->path_id; 1317 ccb->ccb_h.target_id = 1318 periph->path->target->target_id; 1319 ccb->ccb_h.target_lun = 1320 periph->path->device->lun_id; 1321 ccb->ccb_h.status = CAM_REQ_CMP; 1322 break; 1323 } 1324 } 1325 } 1326 1327 /* 1328 * If the periph is null here, one of two things has 1329 * happened. The first possibility is that we couldn't 1330 * find the unit number of the particular peripheral driver 1331 * that the user is asking about. e.g. the user asks for 1332 * the passthrough driver for "da11". We find the list of 1333 * "da" peripherals all right, but there is no unit 11. 1334 * The other possibility is that we went through the list 1335 * of peripheral drivers attached to the device structure, 1336 * but didn't find one with the name "pass". Either way, 1337 * we return ENOENT, since we couldn't find something. 1338 */ 1339 if (periph == NULL) { 1340 ccb->ccb_h.status = CAM_REQ_CMP_ERR; 1341 ccb->cgdl.status = CAM_GDEVLIST_ERROR; 1342 *ccb->cgdl.periph_name = '\0'; 1343 ccb->cgdl.unit_number = 0; 1344 error = ENOENT; 1345 /* 1346 * It is unfortunate that this is even necessary, 1347 * but there are many, many clueless users out there. 1348 * If this is true, the user is looking for the 1349 * passthrough driver, but doesn't have one in his 1350 * kernel. 1351 */ 1352 if (base_periph_found == 1) { 1353 kprintf("xptioctl: pass driver is not in the " 1354 "kernel\n"); 1355 kprintf("xptioctl: put \"device pass\" in " 1356 "your kernel config file\n"); 1357 } 1358 } 1359 lockmgr(&xsoftc.xpt_topo_lock, LK_RELEASE); 1360 break; 1361 } 1362 default: 1363 error = ENOTTY; 1364 break; 1365 } 1366 1367 return(error); 1368 } 1369 1370 static int 1371 cam_module_event_handler(module_t mod, int what, void *arg) 1372 { 1373 int error; 1374 1375 switch (what) { 1376 case MOD_LOAD: 1377 if ((error = xpt_init(NULL)) != 0) 1378 return (error); 1379 break; 1380 case MOD_UNLOAD: 1381 return EBUSY; 1382 default: 1383 return EOPNOTSUPP; 1384 } 1385 1386 return 0; 1387 } 1388 1389 /* 1390 * Thread to handle asynchronous main-context requests. 1391 * 1392 * This function is typically used by drivers to perform complex actions 1393 * such as bus scans and engineering requests in a main context instead 1394 * of an interrupt context. 1395 */ 1396 static void 1397 xpt_scanner_thread(void *dummy) 1398 { 1399 union ccb *ccb; 1400 struct cam_sim *sim; 1401 1402 for (;;) { 1403 xpt_lock_buses(); 1404 xsoftc.ccb_scanq_running = 1; 1405 while ((ccb = (void *)TAILQ_FIRST(&xsoftc.ccb_scanq)) != NULL) { 1406 TAILQ_REMOVE(&xsoftc.ccb_scanq, &ccb->ccb_h, 1407 sim_links.tqe); 1408 xpt_unlock_buses(); 1409 1410 sim = ccb->ccb_h.path->bus->sim; 1411 CAM_SIM_LOCK(sim); 1412 xpt_action(ccb); 1413 CAM_SIM_UNLOCK(sim); 1414 1415 xpt_lock_buses(); 1416 } 1417 xsoftc.ccb_scanq_running = 0; 1418 tsleep_interlock(&xsoftc.ccb_scanq, 0); 1419 xpt_unlock_buses(); 1420 tsleep(&xsoftc.ccb_scanq, PINTERLOCKED, "ccb_scanq", 0); 1421 } 1422 } 1423 1424 /* 1425 * Issue an asynchronous asction 1426 */ 1427 void 1428 xpt_action_async(union ccb *ccb) 1429 { 1430 xpt_lock_buses(); 1431 TAILQ_INSERT_TAIL(&xsoftc.ccb_scanq, &ccb->ccb_h, sim_links.tqe); 1432 if (xsoftc.ccb_scanq_running == 0) { 1433 xsoftc.ccb_scanq_running = 1; 1434 wakeup(&xsoftc.ccb_scanq); 1435 } 1436 xpt_unlock_buses(); 1437 } 1438 1439 1440 /* Functions accessed by the peripheral drivers */ 1441 static int 1442 xpt_init(void *dummy) 1443 { 1444 struct cam_sim *xpt_sim; 1445 struct cam_path *path; 1446 struct cam_devq *devq; 1447 cam_status status; 1448 1449 TAILQ_INIT(&xsoftc.xpt_busses); 1450 TAILQ_INIT(&cam_simq); 1451 TAILQ_INIT(&xsoftc.ccb_scanq); 1452 STAILQ_INIT(&xsoftc.highpowerq); 1453 xsoftc.num_highpower = CAM_MAX_HIGHPOWER; 1454 1455 spin_init(&cam_simq_spin, "cam_simq_spin"); 1456 lockinit(&xsoftc.xpt_lock, "XPT lock", 0, LK_CANRECURSE); 1457 lockinit(&xsoftc.xpt_topo_lock, "XPT topology lock", 0, LK_CANRECURSE); 1458 1459 SLIST_INIT(&cam_dead_sim.ccb_freeq); 1460 TAILQ_INIT(&cam_dead_sim.sim_doneq); 1461 spin_init(&cam_dead_sim.sim_spin, "cam_dead_sim"); 1462 cam_dead_sim.sim_action = dead_sim_action; 1463 cam_dead_sim.sim_poll = dead_sim_poll; 1464 cam_dead_sim.sim_name = "dead_sim"; 1465 cam_dead_sim.lock = &cam_dead_lock; 1466 lockinit(&cam_dead_lock, "XPT dead_sim lock", 0, LK_CANRECURSE); 1467 cam_dead_sim.flags |= CAM_SIM_DEREGISTERED; 1468 1469 /* 1470 * The xpt layer is, itself, the equivelent of a SIM. 1471 * Allow 16 ccbs in the ccb pool for it. This should 1472 * give decent parallelism when we probe busses and 1473 * perform other XPT functions. 1474 */ 1475 devq = cam_simq_alloc(16); 1476 xpt_sim = cam_sim_alloc(xptaction, 1477 xptpoll, 1478 "xpt", 1479 /*softc*/NULL, 1480 /*unit*/0, 1481 /*lock*/&xsoftc.xpt_lock, 1482 /*max_dev_transactions*/0, 1483 /*max_tagged_dev_transactions*/0, 1484 devq); 1485 cam_simq_release(devq); 1486 if (xpt_sim == NULL) 1487 return (ENOMEM); 1488 1489 xpt_sim->max_ccbs = 16; 1490 1491 lockmgr(&xsoftc.xpt_lock, LK_EXCLUSIVE); 1492 if ((status = xpt_bus_register(xpt_sim, /*bus #*/0)) != CAM_SUCCESS) { 1493 lockmgr(&xsoftc.xpt_lock, LK_RELEASE); 1494 kprintf("xpt_init: xpt_bus_register failed with status %#x," 1495 " failing attach\n", status); 1496 return (EINVAL); 1497 } 1498 1499 /* 1500 * Looking at the XPT from the SIM layer, the XPT is 1501 * the equivelent of a peripheral driver. Allocate 1502 * a peripheral driver entry for us. 1503 */ 1504 if ((status = xpt_create_path(&path, NULL, CAM_XPT_PATH_ID, 1505 CAM_TARGET_WILDCARD, 1506 CAM_LUN_WILDCARD)) != CAM_REQ_CMP) { 1507 lockmgr(&xsoftc.xpt_lock, LK_RELEASE); 1508 kprintf("xpt_init: xpt_create_path failed with status %#x," 1509 " failing attach\n", status); 1510 return (EINVAL); 1511 } 1512 1513 cam_periph_alloc(xptregister, NULL, NULL, NULL, "xpt", CAM_PERIPH_BIO, 1514 path, NULL, 0, xpt_sim); 1515 xpt_free_path(path); 1516 1517 lockmgr(&xsoftc.xpt_lock, LK_RELEASE); 1518 1519 /* 1520 * Register a callback for when interrupts are enabled. 1521 */ 1522 xsoftc.xpt_config_hook = kmalloc(sizeof(struct intr_config_hook), 1523 M_CAMXPT, M_INTWAIT | M_ZERO); 1524 xsoftc.xpt_config_hook->ich_func = xpt_config; 1525 xsoftc.xpt_config_hook->ich_desc = "xpt"; 1526 xsoftc.xpt_config_hook->ich_order = 1000; 1527 if (config_intrhook_establish(xsoftc.xpt_config_hook) != 0) { 1528 kfree (xsoftc.xpt_config_hook, M_CAMXPT); 1529 kprintf("xpt_init: config_intrhook_establish failed " 1530 "- failing attach\n"); 1531 } 1532 1533 /* fire up rescan thread */ 1534 if (kthread_create(xpt_scanner_thread, NULL, NULL, "xpt_thrd")) { 1535 kprintf("xpt_init: failed to create rescan thread\n"); 1536 } 1537 /* Install our software interrupt handlers */ 1538 register_swi_mp(SWI_CAMBIO, swi_cambio, NULL, "swi_cambio", NULL, -1); 1539 1540 return (0); 1541 } 1542 1543 static cam_status 1544 xptregister(struct cam_periph *periph, void *arg) 1545 { 1546 struct cam_sim *xpt_sim; 1547 1548 if (periph == NULL) { 1549 kprintf("xptregister: periph was NULL!!\n"); 1550 return(CAM_REQ_CMP_ERR); 1551 } 1552 1553 xpt_sim = (struct cam_sim *)arg; 1554 xpt_sim->softc = periph; 1555 xpt_periph = periph; 1556 periph->softc = NULL; 1557 1558 return(CAM_REQ_CMP); 1559 } 1560 1561 int32_t 1562 xpt_add_periph(struct cam_periph *periph) 1563 { 1564 struct cam_ed *device; 1565 int32_t status; 1566 struct periph_list *periph_head; 1567 1568 sim_lock_assert_owned(periph->sim->lock); 1569 1570 device = periph->path->device; 1571 1572 periph_head = &device->periphs; 1573 1574 status = CAM_REQ_CMP; 1575 1576 if (device != NULL) { 1577 /* 1578 * Make room for this peripheral 1579 * so it will fit in the queue 1580 * when it's scheduled to run 1581 */ 1582 status = camq_resize(&device->drvq, 1583 device->drvq.array_size + 1); 1584 1585 device->generation++; 1586 1587 SLIST_INSERT_HEAD(periph_head, periph, periph_links); 1588 } 1589 1590 lockmgr(&xsoftc.xpt_topo_lock, LK_EXCLUSIVE); 1591 xsoftc.xpt_generation++; 1592 lockmgr(&xsoftc.xpt_topo_lock, LK_RELEASE); 1593 1594 return (status); 1595 } 1596 1597 void 1598 xpt_remove_periph(struct cam_periph *periph) 1599 { 1600 struct cam_ed *device; 1601 1602 sim_lock_assert_owned(periph->sim->lock); 1603 1604 device = periph->path->device; 1605 1606 if (device != NULL) { 1607 struct periph_list *periph_head; 1608 1609 periph_head = &device->periphs; 1610 1611 /* Release the slot for this peripheral */ 1612 camq_resize(&device->drvq, device->drvq.array_size - 1); 1613 1614 device->generation++; 1615 1616 SLIST_REMOVE(periph_head, periph, cam_periph, periph_links); 1617 } 1618 1619 lockmgr(&xsoftc.xpt_topo_lock, LK_EXCLUSIVE); 1620 xsoftc.xpt_generation++; 1621 lockmgr(&xsoftc.xpt_topo_lock, LK_RELEASE); 1622 } 1623 1624 void 1625 xpt_announce_periph(struct cam_periph *periph, char *announce_string) 1626 { 1627 struct ccb_pathinq *cpi; 1628 struct ccb_trans_settings *cts; 1629 struct cam_path *path; 1630 u_int speed; 1631 u_int freq; 1632 u_int mb; 1633 1634 sim_lock_assert_owned(periph->sim->lock); 1635 1636 path = periph->path; 1637 1638 /* Report basic attachment and inquiry data */ 1639 kprintf("%s%d at %s%d bus %d target %d lun %d\n", 1640 periph->periph_name, periph->unit_number, 1641 path->bus->sim->sim_name, 1642 path->bus->sim->unit_number, 1643 path->bus->sim->bus_id, 1644 path->target->target_id, 1645 path->device->lun_id); 1646 kprintf("%s%d: ", periph->periph_name, periph->unit_number); 1647 scsi_print_inquiry(&path->device->inq_data); 1648 1649 /* Report serial number */ 1650 if (path->device->serial_num_len > 0) { 1651 /* Don't wrap the screen - print only the first 60 chars */ 1652 kprintf("%s%d: Serial Number %.60s\n", periph->periph_name, 1653 periph->unit_number, path->device->serial_num); 1654 } 1655 1656 /* Acquire and report transfer speed */ 1657 cts = &xpt_alloc_ccb()->cts; 1658 xpt_setup_ccb(&cts->ccb_h, path, /*priority*/1); 1659 cts->ccb_h.func_code = XPT_GET_TRAN_SETTINGS; 1660 cts->type = CTS_TYPE_CURRENT_SETTINGS; 1661 xpt_action((union ccb*)cts); 1662 if ((cts->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 1663 xpt_free_ccb(&cts->ccb_h); 1664 return; 1665 } 1666 1667 /* Ask the SIM for its base transfer speed */ 1668 cpi = &xpt_alloc_ccb()->cpi; 1669 xpt_setup_ccb(&cpi->ccb_h, path, /*priority*/1); 1670 cpi->ccb_h.func_code = XPT_PATH_INQ; 1671 xpt_action((union ccb *)cpi); 1672 1673 speed = cpi->base_transfer_speed; 1674 freq = 0; 1675 if (cts->ccb_h.status == CAM_REQ_CMP && cts->transport == XPORT_SPI) { 1676 struct ccb_trans_settings_spi *spi; 1677 1678 spi = &cts->xport_specific.spi; 1679 if ((spi->valid & CTS_SPI_VALID_SYNC_OFFSET) != 0 1680 && spi->sync_offset != 0) { 1681 freq = scsi_calc_syncsrate(spi->sync_period); 1682 speed = freq; 1683 } 1684 1685 if ((spi->valid & CTS_SPI_VALID_BUS_WIDTH) != 0) 1686 speed *= (0x01 << spi->bus_width); 1687 } 1688 if (cts->ccb_h.status == CAM_REQ_CMP && cts->transport == XPORT_FC) { 1689 struct ccb_trans_settings_fc *fc = &cts->xport_specific.fc; 1690 if (fc->valid & CTS_FC_VALID_SPEED) { 1691 speed = fc->bitrate; 1692 } 1693 } 1694 1695 if (cts->ccb_h.status == CAM_REQ_CMP && cts->transport == XPORT_SAS) { 1696 struct ccb_trans_settings_sas *sas = &cts->xport_specific.sas; 1697 if (sas->valid & CTS_SAS_VALID_SPEED) { 1698 speed = sas->bitrate; 1699 } 1700 } 1701 1702 mb = speed / 1000; 1703 if (mb > 0) 1704 kprintf("%s%d: %d.%03dMB/s transfers", 1705 periph->periph_name, periph->unit_number, 1706 mb, speed % 1000); 1707 else 1708 kprintf("%s%d: %dKB/s transfers", periph->periph_name, 1709 periph->unit_number, speed); 1710 1711 /* Report additional information about SPI connections */ 1712 if (cts->ccb_h.status == CAM_REQ_CMP && cts->transport == XPORT_SPI) { 1713 struct ccb_trans_settings_spi *spi; 1714 1715 spi = &cts->xport_specific.spi; 1716 if (freq != 0) { 1717 kprintf(" (%d.%03dMHz%s, offset %d", freq / 1000, 1718 freq % 1000, 1719 (spi->ppr_options & MSG_EXT_PPR_DT_REQ) != 0 1720 ? " DT" : "", 1721 spi->sync_offset); 1722 } 1723 if ((spi->valid & CTS_SPI_VALID_BUS_WIDTH) != 0 1724 && spi->bus_width > 0) { 1725 if (freq != 0) { 1726 kprintf(", "); 1727 } else { 1728 kprintf(" ("); 1729 } 1730 kprintf("%dbit)", 8 * (0x01 << spi->bus_width)); 1731 } else if (freq != 0) { 1732 kprintf(")"); 1733 } 1734 } 1735 if (cts->ccb_h.status == CAM_REQ_CMP && cts->transport == XPORT_FC) { 1736 struct ccb_trans_settings_fc *fc; 1737 1738 fc = &cts->xport_specific.fc; 1739 if (fc->valid & CTS_FC_VALID_WWNN) 1740 kprintf(" WWNN 0x%llx", (long long) fc->wwnn); 1741 if (fc->valid & CTS_FC_VALID_WWPN) 1742 kprintf(" WWPN 0x%llx", (long long) fc->wwpn); 1743 if (fc->valid & CTS_FC_VALID_PORT) 1744 kprintf(" PortID 0x%x", fc->port); 1745 } 1746 1747 if (path->device->inq_flags & SID_CmdQue || 1748 path->device->flags & CAM_DEV_TAG_AFTER_COUNT) { 1749 kprintf("\n%s%d: Command Queueing Enabled", 1750 periph->periph_name, periph->unit_number); 1751 } 1752 kprintf("\n"); 1753 1754 xpt_free_ccb(&cpi->ccb_h); 1755 xpt_free_ccb(&cts->ccb_h); 1756 1757 /* 1758 * We only want to print the caller's announce string if they've 1759 * passed one in.. 1760 */ 1761 if (announce_string != NULL) 1762 kprintf("%s%d: %s\n", periph->periph_name, 1763 periph->unit_number, announce_string); 1764 } 1765 1766 static dev_match_ret 1767 xptbusmatch(struct dev_match_pattern *patterns, u_int num_patterns, 1768 struct cam_eb *bus) 1769 { 1770 dev_match_ret retval; 1771 int i; 1772 1773 retval = DM_RET_NONE; 1774 1775 /* 1776 * If we aren't given something to match against, that's an error. 1777 */ 1778 if (bus == NULL) 1779 return(DM_RET_ERROR); 1780 1781 /* 1782 * If there are no match entries, then this bus matches no 1783 * matter what. 1784 */ 1785 if ((patterns == NULL) || (num_patterns == 0)) 1786 return(DM_RET_DESCEND | DM_RET_COPY); 1787 1788 for (i = 0; i < num_patterns; i++) { 1789 struct bus_match_pattern *cur_pattern; 1790 1791 /* 1792 * If the pattern in question isn't for a bus node, we 1793 * aren't interested. However, we do indicate to the 1794 * calling routine that we should continue descending the 1795 * tree, since the user wants to match against lower-level 1796 * EDT elements. 1797 */ 1798 if (patterns[i].type != DEV_MATCH_BUS) { 1799 if ((retval & DM_RET_ACTION_MASK) == DM_RET_NONE) 1800 retval |= DM_RET_DESCEND; 1801 continue; 1802 } 1803 1804 cur_pattern = &patterns[i].pattern.bus_pattern; 1805 1806 /* 1807 * If they want to match any bus node, we give them any 1808 * device node. 1809 */ 1810 if (cur_pattern->flags == BUS_MATCH_ANY) { 1811 /* set the copy flag */ 1812 retval |= DM_RET_COPY; 1813 1814 /* 1815 * If we've already decided on an action, go ahead 1816 * and return. 1817 */ 1818 if ((retval & DM_RET_ACTION_MASK) != DM_RET_NONE) 1819 return(retval); 1820 } 1821 1822 /* 1823 * Not sure why someone would do this... 1824 */ 1825 if (cur_pattern->flags == BUS_MATCH_NONE) 1826 continue; 1827 1828 if (((cur_pattern->flags & BUS_MATCH_PATH) != 0) 1829 && (cur_pattern->path_id != bus->path_id)) 1830 continue; 1831 1832 if (((cur_pattern->flags & BUS_MATCH_BUS_ID) != 0) 1833 && (cur_pattern->bus_id != bus->sim->bus_id)) 1834 continue; 1835 1836 if (((cur_pattern->flags & BUS_MATCH_UNIT) != 0) 1837 && (cur_pattern->unit_number != bus->sim->unit_number)) 1838 continue; 1839 1840 if (((cur_pattern->flags & BUS_MATCH_NAME) != 0) 1841 && (strncmp(cur_pattern->dev_name, bus->sim->sim_name, 1842 DEV_IDLEN) != 0)) 1843 continue; 1844 1845 /* 1846 * If we get to this point, the user definitely wants 1847 * information on this bus. So tell the caller to copy the 1848 * data out. 1849 */ 1850 retval |= DM_RET_COPY; 1851 1852 /* 1853 * If the return action has been set to descend, then we 1854 * know that we've already seen a non-bus matching 1855 * expression, therefore we need to further descend the tree. 1856 * This won't change by continuing around the loop, so we 1857 * go ahead and return. If we haven't seen a non-bus 1858 * matching expression, we keep going around the loop until 1859 * we exhaust the matching expressions. We'll set the stop 1860 * flag once we fall out of the loop. 1861 */ 1862 if ((retval & DM_RET_ACTION_MASK) == DM_RET_DESCEND) 1863 return(retval); 1864 } 1865 1866 /* 1867 * If the return action hasn't been set to descend yet, that means 1868 * we haven't seen anything other than bus matching patterns. So 1869 * tell the caller to stop descending the tree -- the user doesn't 1870 * want to match against lower level tree elements. 1871 */ 1872 if ((retval & DM_RET_ACTION_MASK) == DM_RET_NONE) 1873 retval |= DM_RET_STOP; 1874 1875 return(retval); 1876 } 1877 1878 static dev_match_ret 1879 xptdevicematch(struct dev_match_pattern *patterns, u_int num_patterns, 1880 struct cam_ed *device) 1881 { 1882 dev_match_ret retval; 1883 int i; 1884 1885 retval = DM_RET_NONE; 1886 1887 /* 1888 * If we aren't given something to match against, that's an error. 1889 */ 1890 if (device == NULL) 1891 return(DM_RET_ERROR); 1892 1893 /* 1894 * If there are no match entries, then this device matches no 1895 * matter what. 1896 */ 1897 if ((patterns == NULL) || (num_patterns == 0)) 1898 return(DM_RET_DESCEND | DM_RET_COPY); 1899 1900 for (i = 0; i < num_patterns; i++) { 1901 struct device_match_pattern *cur_pattern; 1902 1903 /* 1904 * If the pattern in question isn't for a device node, we 1905 * aren't interested. 1906 */ 1907 if (patterns[i].type != DEV_MATCH_DEVICE) { 1908 if ((patterns[i].type == DEV_MATCH_PERIPH) 1909 && ((retval & DM_RET_ACTION_MASK) == DM_RET_NONE)) 1910 retval |= DM_RET_DESCEND; 1911 continue; 1912 } 1913 1914 cur_pattern = &patterns[i].pattern.device_pattern; 1915 1916 /* 1917 * If they want to match any device node, we give them any 1918 * device node. 1919 */ 1920 if (cur_pattern->flags == DEV_MATCH_ANY) { 1921 /* set the copy flag */ 1922 retval |= DM_RET_COPY; 1923 1924 1925 /* 1926 * If we've already decided on an action, go ahead 1927 * and return. 1928 */ 1929 if ((retval & DM_RET_ACTION_MASK) != DM_RET_NONE) 1930 return(retval); 1931 } 1932 1933 /* 1934 * Not sure why someone would do this... 1935 */ 1936 if (cur_pattern->flags == DEV_MATCH_NONE) 1937 continue; 1938 1939 if (((cur_pattern->flags & DEV_MATCH_PATH) != 0) 1940 && (cur_pattern->path_id != device->target->bus->path_id)) 1941 continue; 1942 1943 if (((cur_pattern->flags & DEV_MATCH_TARGET) != 0) 1944 && (cur_pattern->target_id != device->target->target_id)) 1945 continue; 1946 1947 if (((cur_pattern->flags & DEV_MATCH_LUN) != 0) 1948 && (cur_pattern->target_lun != device->lun_id)) 1949 continue; 1950 1951 if (((cur_pattern->flags & DEV_MATCH_INQUIRY) != 0) 1952 && (cam_quirkmatch((caddr_t)&device->inq_data, 1953 (caddr_t)&cur_pattern->inq_pat, 1954 1, sizeof(cur_pattern->inq_pat), 1955 scsi_static_inquiry_match) == NULL)) 1956 continue; 1957 1958 /* 1959 * If we get to this point, the user definitely wants 1960 * information on this device. So tell the caller to copy 1961 * the data out. 1962 */ 1963 retval |= DM_RET_COPY; 1964 1965 /* 1966 * If the return action has been set to descend, then we 1967 * know that we've already seen a peripheral matching 1968 * expression, therefore we need to further descend the tree. 1969 * This won't change by continuing around the loop, so we 1970 * go ahead and return. If we haven't seen a peripheral 1971 * matching expression, we keep going around the loop until 1972 * we exhaust the matching expressions. We'll set the stop 1973 * flag once we fall out of the loop. 1974 */ 1975 if ((retval & DM_RET_ACTION_MASK) == DM_RET_DESCEND) 1976 return(retval); 1977 } 1978 1979 /* 1980 * If the return action hasn't been set to descend yet, that means 1981 * we haven't seen any peripheral matching patterns. So tell the 1982 * caller to stop descending the tree -- the user doesn't want to 1983 * match against lower level tree elements. 1984 */ 1985 if ((retval & DM_RET_ACTION_MASK) == DM_RET_NONE) 1986 retval |= DM_RET_STOP; 1987 1988 return(retval); 1989 } 1990 1991 /* 1992 * Match a single peripheral against any number of match patterns. 1993 */ 1994 static dev_match_ret 1995 xptperiphmatch(struct dev_match_pattern *patterns, u_int num_patterns, 1996 struct cam_periph *periph) 1997 { 1998 dev_match_ret retval; 1999 int i; 2000 2001 /* 2002 * If we aren't given something to match against, that's an error. 2003 */ 2004 if (periph == NULL) 2005 return(DM_RET_ERROR); 2006 2007 /* 2008 * If there are no match entries, then this peripheral matches no 2009 * matter what. 2010 */ 2011 if ((patterns == NULL) || (num_patterns == 0)) 2012 return(DM_RET_STOP | DM_RET_COPY); 2013 2014 /* 2015 * There aren't any nodes below a peripheral node, so there's no 2016 * reason to descend the tree any further. 2017 */ 2018 retval = DM_RET_STOP; 2019 2020 for (i = 0; i < num_patterns; i++) { 2021 struct periph_match_pattern *cur_pattern; 2022 2023 /* 2024 * If the pattern in question isn't for a peripheral, we 2025 * aren't interested. 2026 */ 2027 if (patterns[i].type != DEV_MATCH_PERIPH) 2028 continue; 2029 2030 cur_pattern = &patterns[i].pattern.periph_pattern; 2031 2032 /* 2033 * If they want to match on anything, then we will do so. 2034 */ 2035 if (cur_pattern->flags == PERIPH_MATCH_ANY) { 2036 /* set the copy flag */ 2037 retval |= DM_RET_COPY; 2038 2039 /* 2040 * We've already set the return action to stop, 2041 * since there are no nodes below peripherals in 2042 * the tree. 2043 */ 2044 return(retval); 2045 } 2046 2047 /* 2048 * Not sure why someone would do this... 2049 */ 2050 if (cur_pattern->flags == PERIPH_MATCH_NONE) 2051 continue; 2052 2053 if (((cur_pattern->flags & PERIPH_MATCH_PATH) != 0) 2054 && (cur_pattern->path_id != periph->path->bus->path_id)) 2055 continue; 2056 2057 /* 2058 * For the target and lun id's, we have to make sure the 2059 * target and lun pointers aren't NULL. The xpt peripheral 2060 * has a wildcard target and device. 2061 */ 2062 if (((cur_pattern->flags & PERIPH_MATCH_TARGET) != 0) 2063 && ((periph->path->target == NULL) 2064 ||(cur_pattern->target_id != periph->path->target->target_id))) 2065 continue; 2066 2067 if (((cur_pattern->flags & PERIPH_MATCH_LUN) != 0) 2068 && ((periph->path->device == NULL) 2069 || (cur_pattern->target_lun != periph->path->device->lun_id))) 2070 continue; 2071 2072 if (((cur_pattern->flags & PERIPH_MATCH_UNIT) != 0) 2073 && (cur_pattern->unit_number != periph->unit_number)) 2074 continue; 2075 2076 if (((cur_pattern->flags & PERIPH_MATCH_NAME) != 0) 2077 && (strncmp(cur_pattern->periph_name, periph->periph_name, 2078 DEV_IDLEN) != 0)) 2079 continue; 2080 2081 /* 2082 * If we get to this point, the user definitely wants 2083 * information on this peripheral. So tell the caller to 2084 * copy the data out. 2085 */ 2086 retval |= DM_RET_COPY; 2087 2088 /* 2089 * The return action has already been set to stop, since 2090 * peripherals don't have any nodes below them in the EDT. 2091 */ 2092 return(retval); 2093 } 2094 2095 /* 2096 * If we get to this point, the peripheral that was passed in 2097 * doesn't match any of the patterns. 2098 */ 2099 return(retval); 2100 } 2101 2102 static int 2103 xptedtbusfunc(struct cam_eb *bus, void *arg) 2104 { 2105 struct ccb_dev_match *cdm; 2106 dev_match_ret retval; 2107 2108 cdm = (struct ccb_dev_match *)arg; 2109 2110 /* 2111 * If our position is for something deeper in the tree, that means 2112 * that we've already seen this node. So, we keep going down. 2113 */ 2114 if ((cdm->pos.position_type & CAM_DEV_POS_BUS) 2115 && (cdm->pos.cookie.bus == bus) 2116 && (cdm->pos.position_type & CAM_DEV_POS_TARGET) 2117 && (cdm->pos.cookie.target != NULL)) 2118 retval = DM_RET_DESCEND; 2119 else 2120 retval = xptbusmatch(cdm->patterns, cdm->num_patterns, bus); 2121 2122 /* 2123 * If we got an error, bail out of the search. 2124 */ 2125 if ((retval & DM_RET_ACTION_MASK) == DM_RET_ERROR) { 2126 cdm->status = CAM_DEV_MATCH_ERROR; 2127 return(0); 2128 } 2129 2130 /* 2131 * If the copy flag is set, copy this bus out. 2132 */ 2133 if (retval & DM_RET_COPY) { 2134 int spaceleft, j; 2135 2136 spaceleft = cdm->match_buf_len - (cdm->num_matches * 2137 sizeof(struct dev_match_result)); 2138 2139 /* 2140 * If we don't have enough space to put in another 2141 * match result, save our position and tell the 2142 * user there are more devices to check. 2143 */ 2144 if (spaceleft < sizeof(struct dev_match_result)) { 2145 bzero(&cdm->pos, sizeof(cdm->pos)); 2146 cdm->pos.position_type = 2147 CAM_DEV_POS_EDT | CAM_DEV_POS_BUS; 2148 2149 cdm->pos.cookie.bus = bus; 2150 cdm->pos.generations[CAM_BUS_GENERATION]= 2151 xsoftc.bus_generation; 2152 cdm->status = CAM_DEV_MATCH_MORE; 2153 return(0); 2154 } 2155 j = cdm->num_matches; 2156 cdm->num_matches++; 2157 cdm->matches[j].type = DEV_MATCH_BUS; 2158 cdm->matches[j].result.bus_result.path_id = bus->path_id; 2159 cdm->matches[j].result.bus_result.bus_id = bus->sim->bus_id; 2160 cdm->matches[j].result.bus_result.unit_number = 2161 bus->sim->unit_number; 2162 strncpy(cdm->matches[j].result.bus_result.dev_name, 2163 bus->sim->sim_name, DEV_IDLEN); 2164 } 2165 2166 /* 2167 * If the user is only interested in busses, there's no 2168 * reason to descend to the next level in the tree. 2169 */ 2170 if ((retval & DM_RET_ACTION_MASK) == DM_RET_STOP) 2171 return(1); 2172 2173 /* 2174 * If there is a target generation recorded, check it to 2175 * make sure the target list hasn't changed. 2176 */ 2177 if ((cdm->pos.position_type & CAM_DEV_POS_BUS) 2178 && (bus == cdm->pos.cookie.bus) 2179 && (cdm->pos.position_type & CAM_DEV_POS_TARGET) 2180 && (cdm->pos.generations[CAM_TARGET_GENERATION] != 0) 2181 && (cdm->pos.generations[CAM_TARGET_GENERATION] != 2182 bus->generation)) { 2183 cdm->status = CAM_DEV_MATCH_LIST_CHANGED; 2184 return(0); 2185 } 2186 2187 if ((cdm->pos.position_type & CAM_DEV_POS_BUS) 2188 && (cdm->pos.cookie.bus == bus) 2189 && (cdm->pos.position_type & CAM_DEV_POS_TARGET) 2190 && (cdm->pos.cookie.target != NULL)) 2191 return(xpttargettraverse(bus, 2192 (struct cam_et *)cdm->pos.cookie.target, 2193 xptedttargetfunc, arg)); 2194 else 2195 return(xpttargettraverse(bus, NULL, xptedttargetfunc, arg)); 2196 } 2197 2198 static int 2199 xptedttargetfunc(struct cam_et *target, void *arg) 2200 { 2201 struct ccb_dev_match *cdm; 2202 2203 cdm = (struct ccb_dev_match *)arg; 2204 2205 /* 2206 * If there is a device list generation recorded, check it to 2207 * make sure the device list hasn't changed. 2208 */ 2209 if ((cdm->pos.position_type & CAM_DEV_POS_BUS) 2210 && (cdm->pos.cookie.bus == target->bus) 2211 && (cdm->pos.position_type & CAM_DEV_POS_TARGET) 2212 && (cdm->pos.cookie.target == target) 2213 && (cdm->pos.position_type & CAM_DEV_POS_DEVICE) 2214 && (cdm->pos.generations[CAM_DEV_GENERATION] != 0) 2215 && (cdm->pos.generations[CAM_DEV_GENERATION] != 2216 target->generation)) { 2217 cdm->status = CAM_DEV_MATCH_LIST_CHANGED; 2218 return(0); 2219 } 2220 2221 if ((cdm->pos.position_type & CAM_DEV_POS_BUS) 2222 && (cdm->pos.cookie.bus == target->bus) 2223 && (cdm->pos.position_type & CAM_DEV_POS_TARGET) 2224 && (cdm->pos.cookie.target == target) 2225 && (cdm->pos.position_type & CAM_DEV_POS_DEVICE) 2226 && (cdm->pos.cookie.device != NULL)) 2227 return(xptdevicetraverse(target, 2228 (struct cam_ed *)cdm->pos.cookie.device, 2229 xptedtdevicefunc, arg)); 2230 else 2231 return(xptdevicetraverse(target, NULL, xptedtdevicefunc, arg)); 2232 } 2233 2234 static int 2235 xptedtdevicefunc(struct cam_ed *device, void *arg) 2236 { 2237 2238 struct ccb_dev_match *cdm; 2239 dev_match_ret retval; 2240 2241 cdm = (struct ccb_dev_match *)arg; 2242 2243 /* 2244 * If our position is for something deeper in the tree, that means 2245 * that we've already seen this node. So, we keep going down. 2246 */ 2247 if ((cdm->pos.position_type & CAM_DEV_POS_DEVICE) 2248 && (cdm->pos.cookie.device == device) 2249 && (cdm->pos.position_type & CAM_DEV_POS_PERIPH) 2250 && (cdm->pos.cookie.periph != NULL)) 2251 retval = DM_RET_DESCEND; 2252 else 2253 retval = xptdevicematch(cdm->patterns, cdm->num_patterns, 2254 device); 2255 2256 if ((retval & DM_RET_ACTION_MASK) == DM_RET_ERROR) { 2257 cdm->status = CAM_DEV_MATCH_ERROR; 2258 return(0); 2259 } 2260 2261 /* 2262 * If the copy flag is set, copy this device out. 2263 */ 2264 if (retval & DM_RET_COPY) { 2265 int spaceleft, j; 2266 2267 spaceleft = cdm->match_buf_len - (cdm->num_matches * 2268 sizeof(struct dev_match_result)); 2269 2270 /* 2271 * If we don't have enough space to put in another 2272 * match result, save our position and tell the 2273 * user there are more devices to check. 2274 */ 2275 if (spaceleft < sizeof(struct dev_match_result)) { 2276 bzero(&cdm->pos, sizeof(cdm->pos)); 2277 cdm->pos.position_type = 2278 CAM_DEV_POS_EDT | CAM_DEV_POS_BUS | 2279 CAM_DEV_POS_TARGET | CAM_DEV_POS_DEVICE; 2280 2281 cdm->pos.cookie.bus = device->target->bus; 2282 cdm->pos.generations[CAM_BUS_GENERATION]= 2283 xsoftc.bus_generation; 2284 cdm->pos.cookie.target = device->target; 2285 cdm->pos.generations[CAM_TARGET_GENERATION] = 2286 device->target->bus->generation; 2287 cdm->pos.cookie.device = device; 2288 cdm->pos.generations[CAM_DEV_GENERATION] = 2289 device->target->generation; 2290 cdm->status = CAM_DEV_MATCH_MORE; 2291 return(0); 2292 } 2293 j = cdm->num_matches; 2294 cdm->num_matches++; 2295 cdm->matches[j].type = DEV_MATCH_DEVICE; 2296 cdm->matches[j].result.device_result.path_id = 2297 device->target->bus->path_id; 2298 cdm->matches[j].result.device_result.target_id = 2299 device->target->target_id; 2300 cdm->matches[j].result.device_result.target_lun = 2301 device->lun_id; 2302 bcopy(&device->inq_data, 2303 &cdm->matches[j].result.device_result.inq_data, 2304 sizeof(struct scsi_inquiry_data)); 2305 2306 /* Let the user know whether this device is unconfigured */ 2307 if (device->flags & CAM_DEV_UNCONFIGURED) 2308 cdm->matches[j].result.device_result.flags = 2309 DEV_RESULT_UNCONFIGURED; 2310 else 2311 cdm->matches[j].result.device_result.flags = 2312 DEV_RESULT_NOFLAG; 2313 } 2314 2315 /* 2316 * If the user isn't interested in peripherals, don't descend 2317 * the tree any further. 2318 */ 2319 if ((retval & DM_RET_ACTION_MASK) == DM_RET_STOP) 2320 return(1); 2321 2322 /* 2323 * If there is a peripheral list generation recorded, make sure 2324 * it hasn't changed. 2325 */ 2326 if ((cdm->pos.position_type & CAM_DEV_POS_BUS) 2327 && (device->target->bus == cdm->pos.cookie.bus) 2328 && (cdm->pos.position_type & CAM_DEV_POS_TARGET) 2329 && (device->target == cdm->pos.cookie.target) 2330 && (cdm->pos.position_type & CAM_DEV_POS_DEVICE) 2331 && (device == cdm->pos.cookie.device) 2332 && (cdm->pos.position_type & CAM_DEV_POS_PERIPH) 2333 && (cdm->pos.generations[CAM_PERIPH_GENERATION] != 0) 2334 && (cdm->pos.generations[CAM_PERIPH_GENERATION] != 2335 device->generation)){ 2336 cdm->status = CAM_DEV_MATCH_LIST_CHANGED; 2337 return(0); 2338 } 2339 2340 if ((cdm->pos.position_type & CAM_DEV_POS_BUS) 2341 && (cdm->pos.cookie.bus == device->target->bus) 2342 && (cdm->pos.position_type & CAM_DEV_POS_TARGET) 2343 && (cdm->pos.cookie.target == device->target) 2344 && (cdm->pos.position_type & CAM_DEV_POS_DEVICE) 2345 && (cdm->pos.cookie.device == device) 2346 && (cdm->pos.position_type & CAM_DEV_POS_PERIPH) 2347 && (cdm->pos.cookie.periph != NULL)) 2348 return(xptperiphtraverse(device, 2349 (struct cam_periph *)cdm->pos.cookie.periph, 2350 xptedtperiphfunc, arg)); 2351 else 2352 return(xptperiphtraverse(device, NULL, xptedtperiphfunc, arg)); 2353 } 2354 2355 static int 2356 xptedtperiphfunc(struct cam_periph *periph, void *arg) 2357 { 2358 struct ccb_dev_match *cdm; 2359 dev_match_ret retval; 2360 2361 cdm = (struct ccb_dev_match *)arg; 2362 2363 retval = xptperiphmatch(cdm->patterns, cdm->num_patterns, periph); 2364 2365 if ((retval & DM_RET_ACTION_MASK) == DM_RET_ERROR) { 2366 cdm->status = CAM_DEV_MATCH_ERROR; 2367 return(0); 2368 } 2369 2370 /* 2371 * If the copy flag is set, copy this peripheral out. 2372 */ 2373 if (retval & DM_RET_COPY) { 2374 int spaceleft, j; 2375 2376 spaceleft = cdm->match_buf_len - (cdm->num_matches * 2377 sizeof(struct dev_match_result)); 2378 2379 /* 2380 * If we don't have enough space to put in another 2381 * match result, save our position and tell the 2382 * user there are more devices to check. 2383 */ 2384 if (spaceleft < sizeof(struct dev_match_result)) { 2385 bzero(&cdm->pos, sizeof(cdm->pos)); 2386 cdm->pos.position_type = 2387 CAM_DEV_POS_EDT | CAM_DEV_POS_BUS | 2388 CAM_DEV_POS_TARGET | CAM_DEV_POS_DEVICE | 2389 CAM_DEV_POS_PERIPH; 2390 2391 cdm->pos.cookie.bus = periph->path->bus; 2392 cdm->pos.generations[CAM_BUS_GENERATION]= 2393 xsoftc.bus_generation; 2394 cdm->pos.cookie.target = periph->path->target; 2395 cdm->pos.generations[CAM_TARGET_GENERATION] = 2396 periph->path->bus->generation; 2397 cdm->pos.cookie.device = periph->path->device; 2398 cdm->pos.generations[CAM_DEV_GENERATION] = 2399 periph->path->target->generation; 2400 cdm->pos.cookie.periph = periph; 2401 cdm->pos.generations[CAM_PERIPH_GENERATION] = 2402 periph->path->device->generation; 2403 cdm->status = CAM_DEV_MATCH_MORE; 2404 return(0); 2405 } 2406 2407 j = cdm->num_matches; 2408 cdm->num_matches++; 2409 cdm->matches[j].type = DEV_MATCH_PERIPH; 2410 cdm->matches[j].result.periph_result.path_id = 2411 periph->path->bus->path_id; 2412 cdm->matches[j].result.periph_result.target_id = 2413 periph->path->target->target_id; 2414 cdm->matches[j].result.periph_result.target_lun = 2415 periph->path->device->lun_id; 2416 cdm->matches[j].result.periph_result.unit_number = 2417 periph->unit_number; 2418 strncpy(cdm->matches[j].result.periph_result.periph_name, 2419 periph->periph_name, DEV_IDLEN); 2420 } 2421 2422 return(1); 2423 } 2424 2425 static int 2426 xptedtmatch(struct ccb_dev_match *cdm) 2427 { 2428 int ret; 2429 2430 cdm->num_matches = 0; 2431 2432 /* 2433 * Check the bus list generation. If it has changed, the user 2434 * needs to reset everything and start over. 2435 */ 2436 if ((cdm->pos.position_type & CAM_DEV_POS_BUS) 2437 && (cdm->pos.generations[CAM_BUS_GENERATION] != 0) 2438 && (cdm->pos.generations[CAM_BUS_GENERATION] != xsoftc.bus_generation)) { 2439 cdm->status = CAM_DEV_MATCH_LIST_CHANGED; 2440 return(0); 2441 } 2442 2443 if ((cdm->pos.position_type & CAM_DEV_POS_BUS) 2444 && (cdm->pos.cookie.bus != NULL)) 2445 ret = xptbustraverse((struct cam_eb *)cdm->pos.cookie.bus, 2446 xptedtbusfunc, cdm); 2447 else 2448 ret = xptbustraverse(NULL, xptedtbusfunc, cdm); 2449 2450 /* 2451 * If we get back 0, that means that we had to stop before fully 2452 * traversing the EDT. It also means that one of the subroutines 2453 * has set the status field to the proper value. If we get back 1, 2454 * we've fully traversed the EDT and copied out any matching entries. 2455 */ 2456 if (ret == 1) 2457 cdm->status = CAM_DEV_MATCH_LAST; 2458 2459 return(ret); 2460 } 2461 2462 static int 2463 xptplistpdrvfunc(struct periph_driver **pdrv, void *arg) 2464 { 2465 struct ccb_dev_match *cdm; 2466 2467 cdm = (struct ccb_dev_match *)arg; 2468 2469 if ((cdm->pos.position_type & CAM_DEV_POS_PDPTR) 2470 && (cdm->pos.cookie.pdrv == pdrv) 2471 && (cdm->pos.position_type & CAM_DEV_POS_PERIPH) 2472 && (cdm->pos.generations[CAM_PERIPH_GENERATION] != 0) 2473 && (cdm->pos.generations[CAM_PERIPH_GENERATION] != 2474 (*pdrv)->generation)) { 2475 cdm->status = CAM_DEV_MATCH_LIST_CHANGED; 2476 return(0); 2477 } 2478 2479 if ((cdm->pos.position_type & CAM_DEV_POS_PDPTR) 2480 && (cdm->pos.cookie.pdrv == pdrv) 2481 && (cdm->pos.position_type & CAM_DEV_POS_PERIPH) 2482 && (cdm->pos.cookie.periph != NULL)) 2483 return(xptpdperiphtraverse(pdrv, 2484 (struct cam_periph *)cdm->pos.cookie.periph, 2485 xptplistperiphfunc, arg)); 2486 else 2487 return(xptpdperiphtraverse(pdrv, NULL,xptplistperiphfunc, arg)); 2488 } 2489 2490 static int 2491 xptplistperiphfunc(struct cam_periph *periph, void *arg) 2492 { 2493 struct ccb_dev_match *cdm; 2494 dev_match_ret retval; 2495 2496 cdm = (struct ccb_dev_match *)arg; 2497 2498 retval = xptperiphmatch(cdm->patterns, cdm->num_patterns, periph); 2499 2500 if ((retval & DM_RET_ACTION_MASK) == DM_RET_ERROR) { 2501 cdm->status = CAM_DEV_MATCH_ERROR; 2502 return(0); 2503 } 2504 2505 /* 2506 * If the copy flag is set, copy this peripheral out. 2507 */ 2508 if (retval & DM_RET_COPY) { 2509 int spaceleft, j; 2510 2511 spaceleft = cdm->match_buf_len - (cdm->num_matches * 2512 sizeof(struct dev_match_result)); 2513 2514 /* 2515 * If we don't have enough space to put in another 2516 * match result, save our position and tell the 2517 * user there are more devices to check. 2518 */ 2519 if (spaceleft < sizeof(struct dev_match_result)) { 2520 struct periph_driver **pdrv; 2521 2522 pdrv = NULL; 2523 bzero(&cdm->pos, sizeof(cdm->pos)); 2524 cdm->pos.position_type = 2525 CAM_DEV_POS_PDRV | CAM_DEV_POS_PDPTR | 2526 CAM_DEV_POS_PERIPH; 2527 2528 /* 2529 * This may look a bit non-sensical, but it is 2530 * actually quite logical. There are very few 2531 * peripheral drivers, and bloating every peripheral 2532 * structure with a pointer back to its parent 2533 * peripheral driver linker set entry would cost 2534 * more in the long run than doing this quick lookup. 2535 */ 2536 for (pdrv = periph_drivers; *pdrv != NULL; pdrv++) { 2537 if (strcmp((*pdrv)->driver_name, 2538 periph->periph_name) == 0) 2539 break; 2540 } 2541 2542 if (*pdrv == NULL) { 2543 cdm->status = CAM_DEV_MATCH_ERROR; 2544 return(0); 2545 } 2546 2547 cdm->pos.cookie.pdrv = pdrv; 2548 /* 2549 * The periph generation slot does double duty, as 2550 * does the periph pointer slot. They are used for 2551 * both edt and pdrv lookups and positioning. 2552 */ 2553 cdm->pos.cookie.periph = periph; 2554 cdm->pos.generations[CAM_PERIPH_GENERATION] = 2555 (*pdrv)->generation; 2556 cdm->status = CAM_DEV_MATCH_MORE; 2557 return(0); 2558 } 2559 2560 j = cdm->num_matches; 2561 cdm->num_matches++; 2562 cdm->matches[j].type = DEV_MATCH_PERIPH; 2563 cdm->matches[j].result.periph_result.path_id = 2564 periph->path->bus->path_id; 2565 2566 /* 2567 * The transport layer peripheral doesn't have a target or 2568 * lun. 2569 */ 2570 if (periph->path->target) 2571 cdm->matches[j].result.periph_result.target_id = 2572 periph->path->target->target_id; 2573 else 2574 cdm->matches[j].result.periph_result.target_id = -1; 2575 2576 if (periph->path->device) 2577 cdm->matches[j].result.periph_result.target_lun = 2578 periph->path->device->lun_id; 2579 else 2580 cdm->matches[j].result.periph_result.target_lun = -1; 2581 2582 cdm->matches[j].result.periph_result.unit_number = 2583 periph->unit_number; 2584 strncpy(cdm->matches[j].result.periph_result.periph_name, 2585 periph->periph_name, DEV_IDLEN); 2586 } 2587 2588 return(1); 2589 } 2590 2591 static int 2592 xptperiphlistmatch(struct ccb_dev_match *cdm) 2593 { 2594 int ret; 2595 2596 cdm->num_matches = 0; 2597 2598 /* 2599 * At this point in the edt traversal function, we check the bus 2600 * list generation to make sure that no busses have been added or 2601 * removed since the user last sent a XPT_DEV_MATCH ccb through. 2602 * For the peripheral driver list traversal function, however, we 2603 * don't have to worry about new peripheral driver types coming or 2604 * going; they're in a linker set, and therefore can't change 2605 * without a recompile. 2606 */ 2607 2608 if ((cdm->pos.position_type & CAM_DEV_POS_PDPTR) 2609 && (cdm->pos.cookie.pdrv != NULL)) 2610 ret = xptpdrvtraverse( 2611 (struct periph_driver **)cdm->pos.cookie.pdrv, 2612 xptplistpdrvfunc, cdm); 2613 else 2614 ret = xptpdrvtraverse(NULL, xptplistpdrvfunc, cdm); 2615 2616 /* 2617 * If we get back 0, that means that we had to stop before fully 2618 * traversing the peripheral driver tree. It also means that one of 2619 * the subroutines has set the status field to the proper value. If 2620 * we get back 1, we've fully traversed the EDT and copied out any 2621 * matching entries. 2622 */ 2623 if (ret == 1) 2624 cdm->status = CAM_DEV_MATCH_LAST; 2625 2626 return(ret); 2627 } 2628 2629 static int 2630 xptbustraverse(struct cam_eb *start_bus, xpt_busfunc_t *tr_func, void *arg) 2631 { 2632 struct cam_eb *bus, *next_bus; 2633 int retval; 2634 2635 retval = 1; 2636 2637 lockmgr(&xsoftc.xpt_topo_lock, LK_EXCLUSIVE); 2638 for (bus = (start_bus ? start_bus : TAILQ_FIRST(&xsoftc.xpt_busses)); 2639 bus != NULL; 2640 bus = next_bus) { 2641 next_bus = TAILQ_NEXT(bus, links); 2642 2643 lockmgr(&xsoftc.xpt_topo_lock, LK_RELEASE); 2644 CAM_SIM_LOCK(bus->sim); 2645 retval = tr_func(bus, arg); 2646 CAM_SIM_UNLOCK(bus->sim); 2647 if (retval == 0) 2648 return(retval); 2649 lockmgr(&xsoftc.xpt_topo_lock, LK_EXCLUSIVE); 2650 } 2651 lockmgr(&xsoftc.xpt_topo_lock, LK_RELEASE); 2652 2653 return(retval); 2654 } 2655 2656 static int 2657 xpttargettraverse(struct cam_eb *bus, struct cam_et *start_target, 2658 xpt_targetfunc_t *tr_func, void *arg) 2659 { 2660 struct cam_et *target, *next_target; 2661 int retval; 2662 2663 retval = 1; 2664 for (target = (start_target ? start_target : 2665 TAILQ_FIRST(&bus->et_entries)); 2666 target != NULL; target = next_target) { 2667 2668 next_target = TAILQ_NEXT(target, links); 2669 2670 retval = tr_func(target, arg); 2671 2672 if (retval == 0) 2673 return(retval); 2674 } 2675 2676 return(retval); 2677 } 2678 2679 static int 2680 xptdevicetraverse(struct cam_et *target, struct cam_ed *start_device, 2681 xpt_devicefunc_t *tr_func, void *arg) 2682 { 2683 struct cam_ed *device, *next_device; 2684 int retval; 2685 2686 retval = 1; 2687 for (device = (start_device ? start_device : 2688 TAILQ_FIRST(&target->ed_entries)); 2689 device != NULL; 2690 device = next_device) { 2691 2692 next_device = TAILQ_NEXT(device, links); 2693 2694 retval = tr_func(device, arg); 2695 2696 if (retval == 0) 2697 return(retval); 2698 } 2699 2700 return(retval); 2701 } 2702 2703 static int 2704 xptperiphtraverse(struct cam_ed *device, struct cam_periph *start_periph, 2705 xpt_periphfunc_t *tr_func, void *arg) 2706 { 2707 struct cam_periph *periph, *next_periph; 2708 int retval; 2709 2710 retval = 1; 2711 2712 for (periph = (start_periph ? start_periph : 2713 SLIST_FIRST(&device->periphs)); 2714 periph != NULL; 2715 periph = next_periph) { 2716 2717 next_periph = SLIST_NEXT(periph, periph_links); 2718 2719 retval = tr_func(periph, arg); 2720 if (retval == 0) 2721 return(retval); 2722 } 2723 2724 return(retval); 2725 } 2726 2727 static int 2728 xptpdrvtraverse(struct periph_driver **start_pdrv, 2729 xpt_pdrvfunc_t *tr_func, void *arg) 2730 { 2731 struct periph_driver **pdrv; 2732 int retval; 2733 2734 retval = 1; 2735 2736 /* 2737 * We don't traverse the peripheral driver list like we do the 2738 * other lists, because it is a linker set, and therefore cannot be 2739 * changed during runtime. If the peripheral driver list is ever 2740 * re-done to be something other than a linker set (i.e. it can 2741 * change while the system is running), the list traversal should 2742 * be modified to work like the other traversal functions. 2743 */ 2744 for (pdrv = (start_pdrv ? start_pdrv : periph_drivers); 2745 *pdrv != NULL; pdrv++) { 2746 retval = tr_func(pdrv, arg); 2747 2748 if (retval == 0) 2749 return(retval); 2750 } 2751 2752 return(retval); 2753 } 2754 2755 static int 2756 xptpdperiphtraverse(struct periph_driver **pdrv, 2757 struct cam_periph *start_periph, 2758 xpt_periphfunc_t *tr_func, void *arg) 2759 { 2760 struct cam_periph *periph, *next_periph; 2761 int retval; 2762 2763 retval = 1; 2764 2765 for (periph = (start_periph ? start_periph : 2766 TAILQ_FIRST(&(*pdrv)->units)); periph != NULL; 2767 periph = next_periph) { 2768 2769 next_periph = TAILQ_NEXT(periph, unit_links); 2770 2771 retval = tr_func(periph, arg); 2772 if (retval == 0) 2773 return(retval); 2774 } 2775 return(retval); 2776 } 2777 2778 static int 2779 xptdefbusfunc(struct cam_eb *bus, void *arg) 2780 { 2781 struct xpt_traverse_config *tr_config; 2782 2783 tr_config = (struct xpt_traverse_config *)arg; 2784 2785 if (tr_config->depth == XPT_DEPTH_BUS) { 2786 xpt_busfunc_t *tr_func; 2787 2788 tr_func = (xpt_busfunc_t *)tr_config->tr_func; 2789 2790 return(tr_func(bus, tr_config->tr_arg)); 2791 } else 2792 return(xpttargettraverse(bus, NULL, xptdeftargetfunc, arg)); 2793 } 2794 2795 static int 2796 xptdeftargetfunc(struct cam_et *target, void *arg) 2797 { 2798 struct xpt_traverse_config *tr_config; 2799 2800 tr_config = (struct xpt_traverse_config *)arg; 2801 2802 if (tr_config->depth == XPT_DEPTH_TARGET) { 2803 xpt_targetfunc_t *tr_func; 2804 2805 tr_func = (xpt_targetfunc_t *)tr_config->tr_func; 2806 2807 return(tr_func(target, tr_config->tr_arg)); 2808 } else 2809 return(xptdevicetraverse(target, NULL, xptdefdevicefunc, arg)); 2810 } 2811 2812 static int 2813 xptdefdevicefunc(struct cam_ed *device, void *arg) 2814 { 2815 struct xpt_traverse_config *tr_config; 2816 2817 tr_config = (struct xpt_traverse_config *)arg; 2818 2819 if (tr_config->depth == XPT_DEPTH_DEVICE) { 2820 xpt_devicefunc_t *tr_func; 2821 2822 tr_func = (xpt_devicefunc_t *)tr_config->tr_func; 2823 2824 return(tr_func(device, tr_config->tr_arg)); 2825 } else 2826 return(xptperiphtraverse(device, NULL, xptdefperiphfunc, arg)); 2827 } 2828 2829 static int 2830 xptdefperiphfunc(struct cam_periph *periph, void *arg) 2831 { 2832 struct xpt_traverse_config *tr_config; 2833 xpt_periphfunc_t *tr_func; 2834 2835 tr_config = (struct xpt_traverse_config *)arg; 2836 2837 tr_func = (xpt_periphfunc_t *)tr_config->tr_func; 2838 2839 /* 2840 * Unlike the other default functions, we don't check for depth 2841 * here. The peripheral driver level is the last level in the EDT, 2842 * so if we're here, we should execute the function in question. 2843 */ 2844 return(tr_func(periph, tr_config->tr_arg)); 2845 } 2846 2847 /* 2848 * Execute the given function for every bus in the EDT. 2849 */ 2850 static int 2851 xpt_for_all_busses(xpt_busfunc_t *tr_func, void *arg) 2852 { 2853 struct xpt_traverse_config tr_config; 2854 2855 tr_config.depth = XPT_DEPTH_BUS; 2856 tr_config.tr_func = tr_func; 2857 tr_config.tr_arg = arg; 2858 2859 return(xptbustraverse(NULL, xptdefbusfunc, &tr_config)); 2860 } 2861 2862 /* 2863 * Execute the given function for every device in the EDT. 2864 */ 2865 static int 2866 xpt_for_all_devices(xpt_devicefunc_t *tr_func, void *arg) 2867 { 2868 struct xpt_traverse_config tr_config; 2869 2870 tr_config.depth = XPT_DEPTH_DEVICE; 2871 tr_config.tr_func = tr_func; 2872 tr_config.tr_arg = arg; 2873 2874 return(xptbustraverse(NULL, xptdefbusfunc, &tr_config)); 2875 } 2876 2877 static int 2878 xptsetasyncfunc(struct cam_ed *device, void *arg) 2879 { 2880 struct cam_path path; 2881 struct ccb_getdev *cgd; 2882 struct async_node *cur_entry; 2883 2884 cur_entry = (struct async_node *)arg; 2885 2886 /* 2887 * Don't report unconfigured devices (Wildcard devs, 2888 * devices only for target mode, device instances 2889 * that have been invalidated but are waiting for 2890 * their last reference count to be released). 2891 */ 2892 if ((device->flags & CAM_DEV_UNCONFIGURED) != 0) 2893 return (1); 2894 2895 xpt_compile_path(&path, 2896 NULL, 2897 device->target->bus->path_id, 2898 device->target->target_id, 2899 device->lun_id); 2900 2901 cgd = &xpt_alloc_ccb()->cgd; 2902 xpt_setup_ccb(&cgd->ccb_h, &path, /*priority*/1); 2903 cgd->ccb_h.func_code = XPT_GDEV_TYPE; 2904 xpt_action((union ccb *)cgd); 2905 cur_entry->callback(cur_entry->callback_arg, 2906 AC_FOUND_DEVICE, 2907 &path, cgd); 2908 xpt_release_path(&path); 2909 xpt_free_ccb(&cgd->ccb_h); 2910 2911 return(1); 2912 } 2913 2914 static int 2915 xptsetasyncbusfunc(struct cam_eb *bus, void *arg) 2916 { 2917 struct cam_path path; 2918 struct ccb_pathinq *cpi; 2919 struct async_node *cur_entry; 2920 2921 cur_entry = (struct async_node *)arg; 2922 2923 xpt_compile_path(&path, /*periph*/NULL, 2924 bus->sim->path_id, 2925 CAM_TARGET_WILDCARD, 2926 CAM_LUN_WILDCARD); 2927 cpi = &xpt_alloc_ccb()->cpi; 2928 xpt_setup_ccb(&cpi->ccb_h, &path, /*priority*/1); 2929 cpi->ccb_h.func_code = XPT_PATH_INQ; 2930 xpt_action((union ccb *)cpi); 2931 cur_entry->callback(cur_entry->callback_arg, 2932 AC_PATH_REGISTERED, 2933 &path, cpi); 2934 xpt_release_path(&path); 2935 xpt_free_ccb(&cpi->ccb_h); 2936 2937 return(1); 2938 } 2939 2940 static void 2941 xpt_action_sasync_cb(void *context, int pending) 2942 { 2943 struct async_node *cur_entry; 2944 struct xpt_task *task; 2945 uint32_t added; 2946 2947 task = (struct xpt_task *)context; 2948 cur_entry = (struct async_node *)task->data1; 2949 added = task->data2; 2950 2951 if ((added & AC_FOUND_DEVICE) != 0) { 2952 /* 2953 * Get this peripheral up to date with all 2954 * the currently existing devices. 2955 */ 2956 xpt_for_all_devices(xptsetasyncfunc, cur_entry); 2957 } 2958 if ((added & AC_PATH_REGISTERED) != 0) { 2959 /* 2960 * Get this peripheral up to date with all 2961 * the currently existing busses. 2962 */ 2963 xpt_for_all_busses(xptsetasyncbusfunc, cur_entry); 2964 } 2965 kfree(task, M_CAMXPT); 2966 } 2967 2968 void 2969 xpt_action(union ccb *start_ccb) 2970 { 2971 CAM_DEBUG(start_ccb->ccb_h.path, CAM_DEBUG_TRACE, ("xpt_action\n")); 2972 2973 start_ccb->ccb_h.status = CAM_REQ_INPROG; 2974 2975 switch (start_ccb->ccb_h.func_code) { 2976 case XPT_SCSI_IO: 2977 case XPT_TRIM: 2978 { 2979 struct cam_ed *device; 2980 #ifdef CAMDEBUG 2981 char cdb_str[(SCSI_MAX_CDBLEN * 3) + 1]; 2982 struct cam_path *path; 2983 2984 path = start_ccb->ccb_h.path; 2985 #endif 2986 2987 /* 2988 * For the sake of compatibility with SCSI-1 2989 * devices that may not understand the identify 2990 * message, we include lun information in the 2991 * second byte of all commands. SCSI-1 specifies 2992 * that luns are a 3 bit value and reserves only 3 2993 * bits for lun information in the CDB. Later 2994 * revisions of the SCSI spec allow for more than 8 2995 * luns, but have deprecated lun information in the 2996 * CDB. So, if the lun won't fit, we must omit. 2997 * 2998 * Also be aware that during initial probing for devices, 2999 * the inquiry information is unknown but initialized to 0. 3000 * This means that this code will be exercised while probing 3001 * devices with an ANSI revision greater than 2. 3002 */ 3003 device = start_ccb->ccb_h.path->device; 3004 if (device->protocol_version <= SCSI_REV_2 3005 && start_ccb->ccb_h.target_lun < 8 3006 && (start_ccb->ccb_h.flags & CAM_CDB_POINTER) == 0) { 3007 3008 start_ccb->csio.cdb_io.cdb_bytes[1] |= 3009 start_ccb->ccb_h.target_lun << 5; 3010 } 3011 start_ccb->csio.scsi_status = SCSI_STATUS_OK; 3012 CAM_DEBUG(path, CAM_DEBUG_CDB,("%s. CDB: %s\n", 3013 scsi_op_desc(start_ccb->csio.cdb_io.cdb_bytes[0], 3014 &path->device->inq_data), 3015 scsi_cdb_string(start_ccb->csio.cdb_io.cdb_bytes, 3016 cdb_str, sizeof(cdb_str)))); 3017 /* FALLTHROUGH */ 3018 } 3019 case XPT_TARGET_IO: 3020 case XPT_CONT_TARGET_IO: 3021 start_ccb->csio.sense_resid = 0; 3022 start_ccb->csio.resid = 0; 3023 /* FALLTHROUGH */ 3024 case XPT_RESET_DEV: 3025 case XPT_ENG_EXEC: 3026 { 3027 struct cam_path *path; 3028 struct cam_sim *sim; 3029 int runq; 3030 3031 path = start_ccb->ccb_h.path; 3032 3033 sim = path->bus->sim; 3034 if (sim == &cam_dead_sim) { 3035 /* The SIM has gone; just execute the CCB directly. */ 3036 cam_ccbq_send_ccb(&path->device->ccbq, start_ccb); 3037 (*(sim->sim_action))(sim, start_ccb); 3038 break; 3039 } 3040 3041 cam_ccbq_insert_ccb(&path->device->ccbq, start_ccb); 3042 if (path->device->qfrozen_cnt == 0) 3043 runq = xpt_schedule_dev_sendq(path->bus, path->device); 3044 else 3045 runq = 0; 3046 if (runq != 0) 3047 xpt_run_dev_sendq(path->bus); 3048 break; 3049 } 3050 case XPT_SET_TRAN_SETTINGS: 3051 { 3052 xpt_set_transfer_settings(&start_ccb->cts, 3053 start_ccb->ccb_h.path->device, 3054 /*async_update*/FALSE); 3055 break; 3056 } 3057 case XPT_CALC_GEOMETRY: 3058 { 3059 struct cam_sim *sim; 3060 3061 /* Filter out garbage */ 3062 if (start_ccb->ccg.block_size == 0 3063 || start_ccb->ccg.volume_size == 0) { 3064 start_ccb->ccg.cylinders = 0; 3065 start_ccb->ccg.heads = 0; 3066 start_ccb->ccg.secs_per_track = 0; 3067 start_ccb->ccb_h.status = CAM_REQ_CMP; 3068 break; 3069 } 3070 sim = start_ccb->ccb_h.path->bus->sim; 3071 (*(sim->sim_action))(sim, start_ccb); 3072 break; 3073 } 3074 case XPT_ABORT: 3075 { 3076 union ccb* abort_ccb; 3077 3078 abort_ccb = start_ccb->cab.abort_ccb; 3079 if (XPT_FC_IS_DEV_QUEUED(abort_ccb)) { 3080 3081 if (abort_ccb->ccb_h.pinfo.index >= 0) { 3082 struct cam_ccbq *ccbq; 3083 3084 ccbq = &abort_ccb->ccb_h.path->device->ccbq; 3085 cam_ccbq_remove_ccb(ccbq, abort_ccb); 3086 abort_ccb->ccb_h.status = 3087 CAM_REQ_ABORTED|CAM_DEV_QFRZN; 3088 xpt_freeze_devq(abort_ccb->ccb_h.path, 1); 3089 xpt_done(abort_ccb); 3090 start_ccb->ccb_h.status = CAM_REQ_CMP; 3091 break; 3092 } 3093 if (abort_ccb->ccb_h.pinfo.index == CAM_UNQUEUED_INDEX 3094 && (abort_ccb->ccb_h.status & CAM_SIM_QUEUED) == 0) { 3095 /* 3096 * We've caught this ccb en route to 3097 * the SIM. Flag it for abort and the 3098 * SIM will do so just before starting 3099 * real work on the CCB. 3100 */ 3101 abort_ccb->ccb_h.status = 3102 CAM_REQ_ABORTED|CAM_DEV_QFRZN; 3103 xpt_freeze_devq(abort_ccb->ccb_h.path, 1); 3104 start_ccb->ccb_h.status = CAM_REQ_CMP; 3105 break; 3106 } 3107 } 3108 if (XPT_FC_IS_QUEUED(abort_ccb) 3109 && (abort_ccb->ccb_h.pinfo.index == CAM_DONEQ_INDEX)) { 3110 /* 3111 * It's already completed but waiting 3112 * for our SWI to get to it. 3113 */ 3114 start_ccb->ccb_h.status = CAM_UA_ABORT; 3115 break; 3116 } 3117 /* 3118 * If we weren't able to take care of the abort request 3119 * in the XPT, pass the request down to the SIM for processing. 3120 */ 3121 /* FALLTHROUGH */ 3122 } 3123 case XPT_ACCEPT_TARGET_IO: 3124 case XPT_EN_LUN: 3125 case XPT_IMMED_NOTIFY: 3126 case XPT_NOTIFY_ACK: 3127 case XPT_GET_TRAN_SETTINGS: 3128 case XPT_RESET_BUS: 3129 { 3130 struct cam_sim *sim; 3131 3132 sim = start_ccb->ccb_h.path->bus->sim; 3133 (*(sim->sim_action))(sim, start_ccb); 3134 break; 3135 } 3136 case XPT_PATH_INQ: 3137 { 3138 struct cam_sim *sim; 3139 3140 sim = start_ccb->ccb_h.path->bus->sim; 3141 (*(sim->sim_action))(sim, start_ccb); 3142 break; 3143 } 3144 case XPT_PATH_STATS: 3145 start_ccb->cpis.last_reset = 3146 start_ccb->ccb_h.path->bus->last_reset; 3147 start_ccb->ccb_h.status = CAM_REQ_CMP; 3148 break; 3149 case XPT_GDEV_TYPE: 3150 { 3151 struct cam_ed *dev; 3152 3153 dev = start_ccb->ccb_h.path->device; 3154 if ((dev->flags & CAM_DEV_UNCONFIGURED) != 0) { 3155 start_ccb->ccb_h.status = CAM_DEV_NOT_THERE; 3156 } else { 3157 struct ccb_getdev *cgd; 3158 3159 cgd = &start_ccb->cgd; 3160 cgd->inq_data = dev->inq_data; 3161 cgd->ccb_h.status = CAM_REQ_CMP; 3162 cgd->serial_num_len = dev->serial_num_len; 3163 if ((dev->serial_num_len > 0) 3164 && (dev->serial_num != NULL)) 3165 bcopy(dev->serial_num, cgd->serial_num, 3166 dev->serial_num_len); 3167 } 3168 break; 3169 } 3170 case XPT_GDEV_STATS: 3171 { 3172 struct cam_ed *dev; 3173 3174 dev = start_ccb->ccb_h.path->device; 3175 if ((dev->flags & CAM_DEV_UNCONFIGURED) != 0) { 3176 start_ccb->ccb_h.status = CAM_DEV_NOT_THERE; 3177 } else { 3178 struct ccb_getdevstats *cgds; 3179 struct cam_eb *bus; 3180 struct cam_et *tar; 3181 3182 cgds = &start_ccb->cgds; 3183 bus = cgds->ccb_h.path->bus; 3184 tar = cgds->ccb_h.path->target; 3185 cgds->dev_openings = dev->ccbq.dev_openings; 3186 cgds->dev_active = dev->ccbq.dev_active; 3187 cgds->devq_openings = dev->ccbq.devq_openings; 3188 cgds->devq_queued = dev->ccbq.queue.entries; 3189 cgds->held = dev->ccbq.held; 3190 cgds->last_reset = tar->last_reset; 3191 cgds->maxtags = dev->quirk->maxtags; 3192 cgds->mintags = dev->quirk->mintags; 3193 if (timevalcmp(&tar->last_reset, &bus->last_reset, <)) 3194 cgds->last_reset = bus->last_reset; 3195 cgds->ccb_h.status = CAM_REQ_CMP; 3196 } 3197 break; 3198 } 3199 case XPT_GDEVLIST: 3200 { 3201 struct cam_periph *nperiph; 3202 struct periph_list *periph_head; 3203 struct ccb_getdevlist *cgdl; 3204 u_int i; 3205 struct cam_ed *device; 3206 int found; 3207 3208 3209 found = 0; 3210 3211 /* 3212 * Don't want anyone mucking with our data. 3213 */ 3214 device = start_ccb->ccb_h.path->device; 3215 periph_head = &device->periphs; 3216 cgdl = &start_ccb->cgdl; 3217 3218 /* 3219 * Check and see if the list has changed since the user 3220 * last requested a list member. If so, tell them that the 3221 * list has changed, and therefore they need to start over 3222 * from the beginning. 3223 */ 3224 if ((cgdl->index != 0) && 3225 (cgdl->generation != device->generation)) { 3226 cgdl->status = CAM_GDEVLIST_LIST_CHANGED; 3227 break; 3228 } 3229 3230 /* 3231 * Traverse the list of peripherals and attempt to find 3232 * the requested peripheral. 3233 */ 3234 for (nperiph = SLIST_FIRST(periph_head), i = 0; 3235 (nperiph != NULL) && (i <= cgdl->index); 3236 nperiph = SLIST_NEXT(nperiph, periph_links), i++) { 3237 if (i == cgdl->index) { 3238 strncpy(cgdl->periph_name, 3239 nperiph->periph_name, 3240 DEV_IDLEN); 3241 cgdl->unit_number = nperiph->unit_number; 3242 found = 1; 3243 } 3244 } 3245 if (found == 0) { 3246 cgdl->status = CAM_GDEVLIST_ERROR; 3247 break; 3248 } 3249 3250 if (nperiph == NULL) 3251 cgdl->status = CAM_GDEVLIST_LAST_DEVICE; 3252 else 3253 cgdl->status = CAM_GDEVLIST_MORE_DEVS; 3254 3255 cgdl->index++; 3256 cgdl->generation = device->generation; 3257 3258 cgdl->ccb_h.status = CAM_REQ_CMP; 3259 break; 3260 } 3261 case XPT_DEV_MATCH: 3262 { 3263 dev_pos_type position_type; 3264 struct ccb_dev_match *cdm; 3265 int ret; 3266 3267 cdm = &start_ccb->cdm; 3268 3269 /* 3270 * There are two ways of getting at information in the EDT. 3271 * The first way is via the primary EDT tree. It starts 3272 * with a list of busses, then a list of targets on a bus, 3273 * then devices/luns on a target, and then peripherals on a 3274 * device/lun. The "other" way is by the peripheral driver 3275 * lists. The peripheral driver lists are organized by 3276 * peripheral driver. (obviously) So it makes sense to 3277 * use the peripheral driver list if the user is looking 3278 * for something like "da1", or all "da" devices. If the 3279 * user is looking for something on a particular bus/target 3280 * or lun, it's generally better to go through the EDT tree. 3281 */ 3282 3283 if (cdm->pos.position_type != CAM_DEV_POS_NONE) 3284 position_type = cdm->pos.position_type; 3285 else { 3286 u_int i; 3287 3288 position_type = CAM_DEV_POS_NONE; 3289 3290 for (i = 0; i < cdm->num_patterns; i++) { 3291 if ((cdm->patterns[i].type == DEV_MATCH_BUS) 3292 ||(cdm->patterns[i].type == DEV_MATCH_DEVICE)){ 3293 position_type = CAM_DEV_POS_EDT; 3294 break; 3295 } 3296 } 3297 3298 if (cdm->num_patterns == 0) 3299 position_type = CAM_DEV_POS_EDT; 3300 else if (position_type == CAM_DEV_POS_NONE) 3301 position_type = CAM_DEV_POS_PDRV; 3302 } 3303 3304 switch(position_type & CAM_DEV_POS_TYPEMASK) { 3305 case CAM_DEV_POS_EDT: 3306 ret = xptedtmatch(cdm); 3307 break; 3308 case CAM_DEV_POS_PDRV: 3309 ret = xptperiphlistmatch(cdm); 3310 break; 3311 default: 3312 cdm->status = CAM_DEV_MATCH_ERROR; 3313 break; 3314 } 3315 3316 if (cdm->status == CAM_DEV_MATCH_ERROR) 3317 start_ccb->ccb_h.status = CAM_REQ_CMP_ERR; 3318 else 3319 start_ccb->ccb_h.status = CAM_REQ_CMP; 3320 3321 break; 3322 } 3323 case XPT_SASYNC_CB: 3324 { 3325 struct ccb_setasync *csa; 3326 struct async_node *cur_entry; 3327 struct async_list *async_head; 3328 u_int32_t added; 3329 3330 csa = &start_ccb->csa; 3331 added = csa->event_enable; 3332 async_head = &csa->ccb_h.path->device->asyncs; 3333 3334 /* 3335 * If there is already an entry for us, simply 3336 * update it. 3337 */ 3338 cur_entry = SLIST_FIRST(async_head); 3339 while (cur_entry != NULL) { 3340 if ((cur_entry->callback_arg == csa->callback_arg) 3341 && (cur_entry->callback == csa->callback)) 3342 break; 3343 cur_entry = SLIST_NEXT(cur_entry, links); 3344 } 3345 3346 if (cur_entry != NULL) { 3347 /* 3348 * If the request has no flags set, 3349 * remove the entry. 3350 */ 3351 added &= ~cur_entry->event_enable; 3352 if (csa->event_enable == 0) { 3353 SLIST_REMOVE(async_head, cur_entry, 3354 async_node, links); 3355 atomic_add_int( 3356 &csa->ccb_h.path->device->refcount, -1); 3357 kfree(cur_entry, M_CAMXPT); 3358 } else { 3359 cur_entry->event_enable = csa->event_enable; 3360 } 3361 } else { 3362 cur_entry = kmalloc(sizeof(*cur_entry), M_CAMXPT, 3363 M_INTWAIT); 3364 cur_entry->event_enable = csa->event_enable; 3365 cur_entry->callback_arg = csa->callback_arg; 3366 cur_entry->callback = csa->callback; 3367 SLIST_INSERT_HEAD(async_head, cur_entry, links); 3368 atomic_add_int(&csa->ccb_h.path->device->refcount, 1); 3369 } 3370 3371 /* 3372 * Need to decouple this operation via a taskqueue so that 3373 * the locking doesn't become a mess. 3374 */ 3375 if ((added & (AC_FOUND_DEVICE | AC_PATH_REGISTERED)) != 0) { 3376 struct xpt_task *task; 3377 3378 task = kmalloc(sizeof(struct xpt_task), M_CAMXPT, 3379 M_INTWAIT); 3380 3381 TASK_INIT(&task->task, 0, xpt_action_sasync_cb, task); 3382 task->data1 = cur_entry; 3383 task->data2 = added; 3384 taskqueue_enqueue(taskqueue_thread[mycpuid], 3385 &task->task); 3386 } 3387 3388 start_ccb->ccb_h.status = CAM_REQ_CMP; 3389 break; 3390 } 3391 case XPT_REL_SIMQ: 3392 { 3393 struct ccb_relsim *crs; 3394 struct cam_ed *dev; 3395 3396 crs = &start_ccb->crs; 3397 dev = crs->ccb_h.path->device; 3398 if (dev == NULL) { 3399 3400 crs->ccb_h.status = CAM_DEV_NOT_THERE; 3401 break; 3402 } 3403 3404 if ((crs->release_flags & RELSIM_ADJUST_OPENINGS) != 0) { 3405 3406 if (INQ_DATA_TQ_ENABLED(&dev->inq_data)) { 3407 /* Don't ever go below one opening */ 3408 if (crs->openings > 0) { 3409 xpt_dev_ccbq_resize(crs->ccb_h.path, 3410 crs->openings); 3411 3412 if (bootverbose) { 3413 xpt_print(crs->ccb_h.path, 3414 "tagged openings now %d\n", 3415 crs->openings); 3416 } 3417 } 3418 } 3419 } 3420 3421 if ((crs->release_flags & RELSIM_RELEASE_AFTER_TIMEOUT) != 0) { 3422 3423 if ((dev->flags & CAM_DEV_REL_TIMEOUT_PENDING) != 0) { 3424 3425 /* 3426 * Just extend the old timeout and decrement 3427 * the freeze count so that a single timeout 3428 * is sufficient for releasing the queue. 3429 */ 3430 start_ccb->ccb_h.flags &= ~CAM_DEV_QFREEZE; 3431 callout_stop(&dev->callout); 3432 } else { 3433 3434 start_ccb->ccb_h.flags |= CAM_DEV_QFREEZE; 3435 } 3436 3437 callout_reset(&dev->callout, 3438 (crs->release_timeout * hz) / 1000, 3439 xpt_release_devq_timeout, dev); 3440 3441 dev->flags |= CAM_DEV_REL_TIMEOUT_PENDING; 3442 3443 } 3444 3445 if ((crs->release_flags & RELSIM_RELEASE_AFTER_CMDCMPLT) != 0) { 3446 3447 if ((dev->flags & CAM_DEV_REL_ON_COMPLETE) != 0) { 3448 /* 3449 * Decrement the freeze count so that a single 3450 * completion is still sufficient to unfreeze 3451 * the queue. 3452 */ 3453 start_ccb->ccb_h.flags &= ~CAM_DEV_QFREEZE; 3454 } else { 3455 3456 dev->flags |= CAM_DEV_REL_ON_COMPLETE; 3457 start_ccb->ccb_h.flags |= CAM_DEV_QFREEZE; 3458 } 3459 } 3460 3461 if ((crs->release_flags & RELSIM_RELEASE_AFTER_QEMPTY) != 0) { 3462 3463 if ((dev->flags & CAM_DEV_REL_ON_QUEUE_EMPTY) != 0 3464 || (dev->ccbq.dev_active == 0)) { 3465 3466 start_ccb->ccb_h.flags &= ~CAM_DEV_QFREEZE; 3467 } else { 3468 3469 dev->flags |= CAM_DEV_REL_ON_QUEUE_EMPTY; 3470 start_ccb->ccb_h.flags |= CAM_DEV_QFREEZE; 3471 } 3472 } 3473 3474 if ((start_ccb->ccb_h.flags & CAM_DEV_QFREEZE) == 0) { 3475 3476 xpt_release_devq(crs->ccb_h.path, /*count*/1, 3477 /*run_queue*/TRUE); 3478 } 3479 start_ccb->crs.qfrozen_cnt = dev->qfrozen_cnt; 3480 start_ccb->ccb_h.status = CAM_REQ_CMP; 3481 break; 3482 } 3483 case XPT_SCAN_BUS: 3484 xpt_scan_bus(start_ccb->ccb_h.path->periph, start_ccb); 3485 break; 3486 case XPT_SCAN_LUN: 3487 xpt_scan_lun(start_ccb->ccb_h.path->periph, 3488 start_ccb->ccb_h.path, start_ccb->crcn.flags, 3489 start_ccb); 3490 break; 3491 case XPT_DEBUG: { 3492 #ifdef CAMDEBUG 3493 #ifdef CAM_DEBUG_DELAY 3494 cam_debug_delay = CAM_DEBUG_DELAY; 3495 #endif 3496 cam_dflags = start_ccb->cdbg.flags; 3497 if (cam_dpath != NULL) { 3498 xpt_free_path(cam_dpath); 3499 cam_dpath = NULL; 3500 } 3501 3502 if (cam_dflags != CAM_DEBUG_NONE) { 3503 if (xpt_create_path(&cam_dpath, xpt_periph, 3504 start_ccb->ccb_h.path_id, 3505 start_ccb->ccb_h.target_id, 3506 start_ccb->ccb_h.target_lun) != 3507 CAM_REQ_CMP) { 3508 start_ccb->ccb_h.status = CAM_RESRC_UNAVAIL; 3509 cam_dflags = CAM_DEBUG_NONE; 3510 } else { 3511 start_ccb->ccb_h.status = CAM_REQ_CMP; 3512 xpt_print(cam_dpath, "debugging flags now %x\n", 3513 cam_dflags); 3514 } 3515 } else { 3516 cam_dpath = NULL; 3517 start_ccb->ccb_h.status = CAM_REQ_CMP; 3518 } 3519 #else /* !CAMDEBUG */ 3520 start_ccb->ccb_h.status = CAM_FUNC_NOTAVAIL; 3521 #endif /* CAMDEBUG */ 3522 break; 3523 } 3524 case XPT_NOOP: 3525 if ((start_ccb->ccb_h.flags & CAM_DEV_QFREEZE) != 0) 3526 xpt_freeze_devq(start_ccb->ccb_h.path, 1); 3527 start_ccb->ccb_h.status = CAM_REQ_CMP; 3528 break; 3529 default: 3530 case XPT_SDEV_TYPE: 3531 case XPT_TERM_IO: 3532 case XPT_ENG_INQ: 3533 /* XXX Implement */ 3534 start_ccb->ccb_h.status = CAM_PROVIDE_FAIL; 3535 break; 3536 } 3537 } 3538 3539 void 3540 xpt_polled_action(union ccb *start_ccb) 3541 { 3542 u_int32_t timeout; 3543 struct cam_sim *sim; 3544 struct cam_devq *devq; 3545 struct cam_ed *dev; 3546 3547 timeout = start_ccb->ccb_h.timeout; 3548 sim = start_ccb->ccb_h.path->bus->sim; 3549 devq = sim->devq; 3550 dev = start_ccb->ccb_h.path->device; 3551 3552 sim_lock_assert_owned(sim->lock); 3553 3554 /* 3555 * Steal an opening so that no other queued requests 3556 * can get it before us while we simulate interrupts. 3557 */ 3558 dev->ccbq.devq_openings--; 3559 dev->ccbq.dev_openings--; 3560 3561 while(((devq && devq->send_openings <= 0) || dev->ccbq.dev_openings < 0) 3562 && (--timeout > 0)) { 3563 DELAY(1000); 3564 (*(sim->sim_poll))(sim); 3565 camisr_runqueue(sim); 3566 } 3567 3568 dev->ccbq.devq_openings++; 3569 dev->ccbq.dev_openings++; 3570 3571 if (timeout != 0) { 3572 xpt_action(start_ccb); 3573 while(--timeout > 0) { 3574 (*(sim->sim_poll))(sim); 3575 camisr_runqueue(sim); 3576 if ((start_ccb->ccb_h.status & CAM_STATUS_MASK) 3577 != CAM_REQ_INPROG) 3578 break; 3579 DELAY(1000); 3580 } 3581 if (timeout == 0) { 3582 /* 3583 * XXX Is it worth adding a sim_timeout entry 3584 * point so we can attempt recovery? If 3585 * this is only used for dumps, I don't think 3586 * it is. 3587 */ 3588 start_ccb->ccb_h.status = CAM_CMD_TIMEOUT; 3589 } 3590 } else { 3591 start_ccb->ccb_h.status = CAM_RESRC_UNAVAIL; 3592 } 3593 } 3594 3595 /* 3596 * Schedule a peripheral driver to receive a ccb when it's 3597 * target device has space for more transactions. 3598 */ 3599 void 3600 xpt_schedule(struct cam_periph *perph, u_int32_t new_priority) 3601 { 3602 struct cam_ed *device; 3603 union ccb *work_ccb; 3604 int runq; 3605 3606 sim_lock_assert_owned(perph->sim->lock); 3607 3608 CAM_DEBUG(perph->path, CAM_DEBUG_TRACE, ("xpt_schedule\n")); 3609 device = perph->path->device; 3610 if (periph_is_queued(perph)) { 3611 /* Simply reorder based on new priority */ 3612 CAM_DEBUG(perph->path, CAM_DEBUG_SUBTRACE, 3613 (" change priority to %d\n", new_priority)); 3614 if (new_priority < perph->pinfo.priority) { 3615 camq_change_priority(&device->drvq, 3616 perph->pinfo.index, 3617 new_priority); 3618 } 3619 runq = 0; 3620 } else if (perph->path->bus->sim == &cam_dead_sim) { 3621 /* The SIM is gone so just call periph_start directly. */ 3622 work_ccb = xpt_get_ccb(perph->path->device); 3623 if (work_ccb == NULL) 3624 return; /* XXX */ 3625 xpt_setup_ccb(&work_ccb->ccb_h, perph->path, new_priority); 3626 perph->pinfo.priority = new_priority; 3627 perph->periph_start(perph, work_ccb); 3628 return; 3629 } else { 3630 /* New entry on the queue */ 3631 CAM_DEBUG(perph->path, CAM_DEBUG_SUBTRACE, 3632 (" added periph to queue\n")); 3633 perph->pinfo.priority = new_priority; 3634 perph->pinfo.generation = ++device->drvq.generation; 3635 camq_insert(&device->drvq, &perph->pinfo); 3636 runq = xpt_schedule_dev_allocq(perph->path->bus, device); 3637 } 3638 if (runq != 0) { 3639 CAM_DEBUG(perph->path, CAM_DEBUG_SUBTRACE, 3640 (" calling xpt_run_devq\n")); 3641 xpt_run_dev_allocq(perph->path->bus); 3642 } 3643 } 3644 3645 3646 /* 3647 * Schedule a device to run on a given queue. 3648 * If the device was inserted as a new entry on the queue, 3649 * return 1 meaning the device queue should be run. If we 3650 * were already queued, implying someone else has already 3651 * started the queue, return 0 so the caller doesn't attempt 3652 * to run the queue. 3653 */ 3654 static int 3655 xpt_schedule_dev(struct camq *queue, cam_pinfo *pinfo, 3656 u_int32_t new_priority) 3657 { 3658 int retval; 3659 u_int32_t old_priority; 3660 3661 CAM_DEBUG_PRINT(CAM_DEBUG_XPT, ("xpt_schedule_dev\n")); 3662 3663 old_priority = pinfo->priority; 3664 3665 /* 3666 * Are we already queued? 3667 */ 3668 if (pinfo->index != CAM_UNQUEUED_INDEX) { 3669 /* Simply reorder based on new priority */ 3670 if (new_priority < old_priority) { 3671 camq_change_priority(queue, pinfo->index, 3672 new_priority); 3673 CAM_DEBUG_PRINT(CAM_DEBUG_XPT, 3674 ("changed priority to %d\n", 3675 new_priority)); 3676 } 3677 retval = 0; 3678 } else { 3679 /* New entry on the queue */ 3680 if (new_priority < old_priority) 3681 pinfo->priority = new_priority; 3682 3683 CAM_DEBUG_PRINT(CAM_DEBUG_XPT, 3684 ("Inserting onto queue\n")); 3685 pinfo->generation = ++queue->generation; 3686 camq_insert(queue, pinfo); 3687 retval = 1; 3688 } 3689 return (retval); 3690 } 3691 3692 static void 3693 xpt_run_dev_allocq(struct cam_eb *bus) 3694 { 3695 struct cam_devq *devq; 3696 3697 if ((devq = bus->sim->devq) == NULL) { 3698 CAM_DEBUG_PRINT(CAM_DEBUG_XPT, ("xpt_run_dev_allocq: NULL devq\n")); 3699 return; 3700 } 3701 CAM_DEBUG_PRINT(CAM_DEBUG_XPT, ("xpt_run_dev_allocq\n")); 3702 3703 CAM_DEBUG_PRINT(CAM_DEBUG_XPT, 3704 (" qfrozen_cnt == 0x%x, entries == %d, " 3705 "openings == %d, active == %d\n", 3706 devq->alloc_queue.qfrozen_cnt, 3707 devq->alloc_queue.entries, 3708 devq->alloc_openings, 3709 devq->alloc_active)); 3710 3711 devq->alloc_queue.qfrozen_cnt++; 3712 while ((devq->alloc_queue.entries > 0) 3713 && (devq->alloc_openings > 0) 3714 && (devq->alloc_queue.qfrozen_cnt <= 1)) { 3715 struct cam_ed_qinfo *qinfo; 3716 struct cam_ed *device; 3717 union ccb *work_ccb; 3718 struct cam_periph *drv; 3719 struct camq *drvq; 3720 3721 qinfo = (struct cam_ed_qinfo *)camq_remove(&devq->alloc_queue, 3722 CAMQ_HEAD); 3723 device = qinfo->device; 3724 3725 CAM_DEBUG_PRINT(CAM_DEBUG_XPT, 3726 ("running device %p\n", device)); 3727 3728 drvq = &device->drvq; 3729 3730 #ifdef CAMDEBUG 3731 if (drvq->entries <= 0) { 3732 panic("xpt_run_dev_allocq: " 3733 "Device on queue without any work to do"); 3734 } 3735 #endif 3736 if ((work_ccb = xpt_get_ccb(device)) != NULL) { 3737 devq->alloc_openings--; 3738 devq->alloc_active++; 3739 drv = (struct cam_periph*)camq_remove(drvq, CAMQ_HEAD); 3740 xpt_setup_ccb(&work_ccb->ccb_h, drv->path, 3741 drv->pinfo.priority); 3742 CAM_DEBUG_PRINT(CAM_DEBUG_XPT, 3743 ("calling periph start\n")); 3744 drv->periph_start(drv, work_ccb); 3745 } else { 3746 /* 3747 * Malloc failure in alloc_ccb 3748 */ 3749 /* 3750 * XXX add us to a list to be run from free_ccb 3751 * if we don't have any ccbs active on this 3752 * device queue otherwise we may never get run 3753 * again. 3754 */ 3755 break; 3756 } 3757 3758 if (drvq->entries > 0) { 3759 /* We have more work. Attempt to reschedule */ 3760 xpt_schedule_dev_allocq(bus, device); 3761 } 3762 } 3763 devq->alloc_queue.qfrozen_cnt--; 3764 } 3765 3766 static void 3767 xpt_run_dev_sendq(struct cam_eb *bus) 3768 { 3769 struct cam_devq *devq; 3770 3771 if ((devq = bus->sim->devq) == NULL) { 3772 CAM_DEBUG_PRINT(CAM_DEBUG_XPT, ("xpt_run_dev_sendq: NULL devq\n")); 3773 return; 3774 } 3775 CAM_DEBUG_PRINT(CAM_DEBUG_XPT, ("xpt_run_dev_sendq\n")); 3776 3777 devq->send_queue.qfrozen_cnt++; 3778 while ((devq->send_queue.entries > 0) 3779 && (devq->send_openings > 0)) { 3780 struct cam_ed_qinfo *qinfo; 3781 struct cam_ed *device; 3782 union ccb *work_ccb; 3783 struct cam_sim *sim; 3784 3785 if (devq->send_queue.qfrozen_cnt > 1) { 3786 break; 3787 } 3788 3789 qinfo = (struct cam_ed_qinfo *)camq_remove(&devq->send_queue, 3790 CAMQ_HEAD); 3791 device = qinfo->device; 3792 3793 /* 3794 * If the device has been "frozen", don't attempt 3795 * to run it. 3796 */ 3797 if (device->qfrozen_cnt > 0) { 3798 continue; 3799 } 3800 3801 CAM_DEBUG_PRINT(CAM_DEBUG_XPT, 3802 ("running device %p\n", device)); 3803 3804 work_ccb = cam_ccbq_peek_ccb(&device->ccbq, CAMQ_HEAD); 3805 if (work_ccb == NULL) { 3806 kprintf("device on run queue with no ccbs???\n"); 3807 continue; 3808 } 3809 3810 if ((work_ccb->ccb_h.flags & CAM_HIGH_POWER) != 0) { 3811 3812 lockmgr(&xsoftc.xpt_lock, LK_EXCLUSIVE); 3813 if (xsoftc.num_highpower <= 0) { 3814 /* 3815 * We got a high power command, but we 3816 * don't have any available slots. Freeze 3817 * the device queue until we have a slot 3818 * available. 3819 */ 3820 device->qfrozen_cnt++; 3821 STAILQ_INSERT_TAIL(&xsoftc.highpowerq, 3822 &work_ccb->ccb_h, 3823 xpt_links.stqe); 3824 3825 lockmgr(&xsoftc.xpt_lock, LK_RELEASE); 3826 continue; 3827 } else { 3828 /* 3829 * Consume a high power slot while 3830 * this ccb runs. 3831 */ 3832 xsoftc.num_highpower--; 3833 } 3834 lockmgr(&xsoftc.xpt_lock, LK_RELEASE); 3835 } 3836 devq->active_dev = device; 3837 cam_ccbq_remove_ccb(&device->ccbq, work_ccb); 3838 3839 cam_ccbq_send_ccb(&device->ccbq, work_ccb); 3840 3841 devq->send_openings--; 3842 devq->send_active++; 3843 3844 if (device->ccbq.queue.entries > 0) 3845 xpt_schedule_dev_sendq(bus, device); 3846 3847 if (work_ccb && (work_ccb->ccb_h.flags & CAM_DEV_QFREEZE) != 0){ 3848 /* 3849 * The client wants to freeze the queue 3850 * after this CCB is sent. 3851 */ 3852 device->qfrozen_cnt++; 3853 } 3854 3855 /* In Target mode, the peripheral driver knows best... */ 3856 if (work_ccb->ccb_h.func_code == XPT_SCSI_IO) { 3857 if ((device->inq_flags & SID_CmdQue) != 0 3858 && work_ccb->csio.tag_action != CAM_TAG_ACTION_NONE) 3859 work_ccb->ccb_h.flags |= CAM_TAG_ACTION_VALID; 3860 else 3861 /* 3862 * Clear this in case of a retried CCB that 3863 * failed due to a rejected tag. 3864 */ 3865 work_ccb->ccb_h.flags &= ~CAM_TAG_ACTION_VALID; 3866 } 3867 3868 /* 3869 * Device queues can be shared among multiple sim instances 3870 * that reside on different busses. Use the SIM in the queue 3871 * CCB's path, rather than the one in the bus that was passed 3872 * into this function. 3873 */ 3874 sim = work_ccb->ccb_h.path->bus->sim; 3875 (*(sim->sim_action))(sim, work_ccb); 3876 3877 devq->active_dev = NULL; 3878 } 3879 devq->send_queue.qfrozen_cnt--; 3880 } 3881 3882 /* 3883 * This function merges stuff from the slave ccb into the master ccb, while 3884 * keeping important fields in the master ccb constant. 3885 */ 3886 void 3887 xpt_merge_ccb(union ccb *master_ccb, union ccb *slave_ccb) 3888 { 3889 /* 3890 * Pull fields that are valid for peripheral drivers to set 3891 * into the master CCB along with the CCB "payload". 3892 */ 3893 master_ccb->ccb_h.retry_count = slave_ccb->ccb_h.retry_count; 3894 master_ccb->ccb_h.func_code = slave_ccb->ccb_h.func_code; 3895 master_ccb->ccb_h.timeout = slave_ccb->ccb_h.timeout; 3896 master_ccb->ccb_h.flags = slave_ccb->ccb_h.flags; 3897 bcopy(&(&slave_ccb->ccb_h)[1], &(&master_ccb->ccb_h)[1], 3898 sizeof(union ccb) - sizeof(struct ccb_hdr)); 3899 } 3900 3901 void 3902 xpt_setup_ccb(struct ccb_hdr *ccb_h, struct cam_path *path, u_int32_t priority) 3903 { 3904 CAM_DEBUG(path, CAM_DEBUG_TRACE, ("xpt_setup_ccb\n")); 3905 callout_init(ccb_h->timeout_ch); 3906 ccb_h->pinfo.priority = priority; 3907 ccb_h->path = path; 3908 ccb_h->path_id = path->bus->path_id; 3909 if (path->target) 3910 ccb_h->target_id = path->target->target_id; 3911 else 3912 ccb_h->target_id = CAM_TARGET_WILDCARD; 3913 if (path->device) { 3914 ccb_h->target_lun = path->device->lun_id; 3915 ccb_h->pinfo.generation = ++path->device->ccbq.queue.generation; 3916 } else { 3917 ccb_h->target_lun = CAM_TARGET_WILDCARD; 3918 } 3919 ccb_h->pinfo.index = CAM_UNQUEUED_INDEX; 3920 ccb_h->flags = 0; 3921 } 3922 3923 /* Path manipulation functions */ 3924 cam_status 3925 xpt_create_path(struct cam_path **new_path_ptr, struct cam_periph *perph, 3926 path_id_t path_id, target_id_t target_id, lun_id_t lun_id) 3927 { 3928 struct cam_path *path; 3929 cam_status status; 3930 3931 path = kmalloc(sizeof(*path), M_CAMXPT, M_INTWAIT); 3932 status = xpt_compile_path(path, perph, path_id, target_id, lun_id); 3933 if (status != CAM_REQ_CMP) { 3934 kfree(path, M_CAMXPT); 3935 path = NULL; 3936 } 3937 *new_path_ptr = path; 3938 return (status); 3939 } 3940 3941 cam_status 3942 xpt_create_path_unlocked(struct cam_path **new_path_ptr, 3943 struct cam_periph *periph, path_id_t path_id, 3944 target_id_t target_id, lun_id_t lun_id) 3945 { 3946 struct cam_path *path; 3947 struct cam_eb *bus = NULL; 3948 cam_status status; 3949 int need_unlock = 0; 3950 3951 path = (struct cam_path *)kmalloc(sizeof(*path), M_CAMXPT, M_WAITOK); 3952 3953 if (path_id != CAM_BUS_WILDCARD) { 3954 bus = xpt_find_bus(path_id); 3955 if (bus != NULL) { 3956 need_unlock = 1; 3957 CAM_SIM_LOCK(bus->sim); 3958 } 3959 } 3960 status = xpt_compile_path(path, periph, path_id, target_id, lun_id); 3961 if (need_unlock) 3962 CAM_SIM_UNLOCK(bus->sim); 3963 if (status != CAM_REQ_CMP) { 3964 kfree(path, M_CAMXPT); 3965 path = NULL; 3966 } 3967 *new_path_ptr = path; 3968 return (status); 3969 } 3970 3971 static cam_status 3972 xpt_compile_path(struct cam_path *new_path, struct cam_periph *perph, 3973 path_id_t path_id, target_id_t target_id, lun_id_t lun_id) 3974 { 3975 struct cam_eb *bus; 3976 struct cam_et *target; 3977 struct cam_ed *device; 3978 cam_status status; 3979 3980 status = CAM_REQ_CMP; /* Completed without error */ 3981 target = NULL; /* Wildcarded */ 3982 device = NULL; /* Wildcarded */ 3983 3984 /* 3985 * We will potentially modify the EDT, so block interrupts 3986 * that may attempt to create cam paths. 3987 */ 3988 bus = xpt_find_bus(path_id); 3989 if (bus == NULL) { 3990 status = CAM_PATH_INVALID; 3991 } else { 3992 target = xpt_find_target(bus, target_id); 3993 if (target == NULL) { 3994 /* Create one */ 3995 struct cam_et *new_target; 3996 3997 new_target = xpt_alloc_target(bus, target_id); 3998 if (new_target == NULL) { 3999 status = CAM_RESRC_UNAVAIL; 4000 } else { 4001 target = new_target; 4002 } 4003 } 4004 if (target != NULL) { 4005 device = xpt_find_device(target, lun_id); 4006 if (device == NULL) { 4007 /* Create one */ 4008 struct cam_ed *new_device; 4009 4010 new_device = xpt_alloc_device(bus, 4011 target, 4012 lun_id); 4013 if (new_device == NULL) { 4014 status = CAM_RESRC_UNAVAIL; 4015 } else { 4016 device = new_device; 4017 } 4018 } 4019 } 4020 } 4021 4022 /* 4023 * Only touch the user's data if we are successful. 4024 */ 4025 if (status == CAM_REQ_CMP) { 4026 new_path->periph = perph; 4027 new_path->bus = bus; 4028 new_path->target = target; 4029 new_path->device = device; 4030 CAM_DEBUG(new_path, CAM_DEBUG_TRACE, ("xpt_compile_path\n")); 4031 } else { 4032 if (device != NULL) 4033 xpt_release_device(bus, target, device); 4034 if (target != NULL) 4035 xpt_release_target(bus, target); 4036 if (bus != NULL) 4037 xpt_release_bus(bus); 4038 } 4039 return (status); 4040 } 4041 4042 static void 4043 xpt_release_path(struct cam_path *path) 4044 { 4045 CAM_DEBUG(path, CAM_DEBUG_TRACE, ("xpt_release_path\n")); 4046 if (path->device != NULL) { 4047 xpt_release_device(path->bus, path->target, path->device); 4048 path->device = NULL; 4049 } 4050 if (path->target != NULL) { 4051 xpt_release_target(path->bus, path->target); 4052 path->target = NULL; 4053 } 4054 if (path->bus != NULL) { 4055 xpt_release_bus(path->bus); 4056 path->bus = NULL; 4057 } 4058 } 4059 4060 void 4061 xpt_free_path(struct cam_path *path) 4062 { 4063 CAM_DEBUG(path, CAM_DEBUG_TRACE, ("xpt_free_path\n")); 4064 xpt_release_path(path); 4065 kfree(path, M_CAMXPT); 4066 } 4067 4068 4069 /* 4070 * Return -1 for failure, 0 for exact match, 1 for match with wildcards 4071 * in path1, 2 for match with wildcards in path2. 4072 */ 4073 int 4074 xpt_path_comp(struct cam_path *path1, struct cam_path *path2) 4075 { 4076 int retval = 0; 4077 4078 if (path1->bus != path2->bus) { 4079 if (path1->bus->path_id == CAM_BUS_WILDCARD) 4080 retval = 1; 4081 else if (path2->bus->path_id == CAM_BUS_WILDCARD) 4082 retval = 2; 4083 else 4084 return (-1); 4085 } 4086 if (path1->target != path2->target) { 4087 if (path1->target->target_id == CAM_TARGET_WILDCARD) { 4088 if (retval == 0) 4089 retval = 1; 4090 } else if (path2->target->target_id == CAM_TARGET_WILDCARD) 4091 retval = 2; 4092 else 4093 return (-1); 4094 } 4095 if (path1->device != path2->device) { 4096 if (path1->device->lun_id == CAM_LUN_WILDCARD) { 4097 if (retval == 0) 4098 retval = 1; 4099 } else if (path2->device->lun_id == CAM_LUN_WILDCARD) 4100 retval = 2; 4101 else 4102 return (-1); 4103 } 4104 return (retval); 4105 } 4106 4107 void 4108 xpt_print_path(struct cam_path *path) 4109 { 4110 4111 if (path == NULL) 4112 kprintf("(nopath): "); 4113 else { 4114 if (path->periph != NULL) 4115 kprintf("(%s%d:", path->periph->periph_name, 4116 path->periph->unit_number); 4117 else 4118 kprintf("(noperiph:"); 4119 4120 if (path->bus != NULL) 4121 kprintf("%s%d:%d:", path->bus->sim->sim_name, 4122 path->bus->sim->unit_number, 4123 path->bus->sim->bus_id); 4124 else 4125 kprintf("nobus:"); 4126 4127 if (path->target != NULL) 4128 kprintf("%d:", path->target->target_id); 4129 else 4130 kprintf("X:"); 4131 4132 if (path->device != NULL) 4133 kprintf("%d): ", path->device->lun_id); 4134 else 4135 kprintf("X): "); 4136 } 4137 } 4138 4139 void 4140 xpt_print(struct cam_path *path, const char *fmt, ...) 4141 { 4142 __va_list ap; 4143 xpt_print_path(path); 4144 __va_start(ap, fmt); 4145 kvprintf(fmt, ap); 4146 __va_end(ap); 4147 } 4148 4149 int 4150 xpt_path_string(struct cam_path *path, char *str, size_t str_len) 4151 { 4152 struct sbuf sb; 4153 4154 sim_lock_assert_owned(path->bus->sim->lock); 4155 4156 sbuf_new(&sb, str, str_len, 0); 4157 4158 if (path == NULL) 4159 sbuf_printf(&sb, "(nopath): "); 4160 else { 4161 if (path->periph != NULL) 4162 sbuf_printf(&sb, "(%s%d:", path->periph->periph_name, 4163 path->periph->unit_number); 4164 else 4165 sbuf_printf(&sb, "(noperiph:"); 4166 4167 if (path->bus != NULL) 4168 sbuf_printf(&sb, "%s%d:%d:", path->bus->sim->sim_name, 4169 path->bus->sim->unit_number, 4170 path->bus->sim->bus_id); 4171 else 4172 sbuf_printf(&sb, "nobus:"); 4173 4174 if (path->target != NULL) 4175 sbuf_printf(&sb, "%d:", path->target->target_id); 4176 else 4177 sbuf_printf(&sb, "X:"); 4178 4179 if (path->device != NULL) 4180 sbuf_printf(&sb, "%d): ", path->device->lun_id); 4181 else 4182 sbuf_printf(&sb, "X): "); 4183 } 4184 sbuf_finish(&sb); 4185 4186 return(sbuf_len(&sb)); 4187 } 4188 4189 path_id_t 4190 xpt_path_path_id(struct cam_path *path) 4191 { 4192 sim_lock_assert_owned(path->bus->sim->lock); 4193 4194 return(path->bus->path_id); 4195 } 4196 4197 target_id_t 4198 xpt_path_target_id(struct cam_path *path) 4199 { 4200 sim_lock_assert_owned(path->bus->sim->lock); 4201 4202 if (path->target != NULL) 4203 return (path->target->target_id); 4204 else 4205 return (CAM_TARGET_WILDCARD); 4206 } 4207 4208 lun_id_t 4209 xpt_path_lun_id(struct cam_path *path) 4210 { 4211 sim_lock_assert_owned(path->bus->sim->lock); 4212 4213 if (path->device != NULL) 4214 return (path->device->lun_id); 4215 else 4216 return (CAM_LUN_WILDCARD); 4217 } 4218 4219 struct cam_sim * 4220 xpt_path_sim(struct cam_path *path) 4221 { 4222 return (path->bus->sim); 4223 } 4224 4225 struct cam_periph* 4226 xpt_path_periph(struct cam_path *path) 4227 { 4228 sim_lock_assert_owned(path->bus->sim->lock); 4229 4230 return (path->periph); 4231 } 4232 4233 char * 4234 xpt_path_serialno(struct cam_path *path) 4235 { 4236 return (path->device->serial_num); 4237 } 4238 4239 /* 4240 * Release a CAM control block for the caller. Remit the cost of the structure 4241 * to the device referenced by the path. If the this device had no 'credits' 4242 * and peripheral drivers have registered async callbacks for this notification 4243 * call them now. 4244 */ 4245 void 4246 xpt_release_ccb(union ccb *free_ccb) 4247 { 4248 struct cam_path *path; 4249 struct cam_ed *device; 4250 struct cam_eb *bus; 4251 struct cam_sim *sim; 4252 4253 CAM_DEBUG_PRINT(CAM_DEBUG_XPT, ("xpt_release_ccb\n")); 4254 path = free_ccb->ccb_h.path; 4255 device = path->device; 4256 bus = path->bus; 4257 sim = bus->sim; 4258 4259 sim_lock_assert_owned(sim->lock); 4260 4261 cam_ccbq_release_opening(&device->ccbq); 4262 if (sim->ccb_count > sim->max_ccbs) { 4263 xpt_free_ccb(&free_ccb->ccb_h); 4264 sim->ccb_count--; 4265 } else if (sim == &cam_dead_sim) { 4266 xpt_free_ccb(&free_ccb->ccb_h); 4267 } else { 4268 SLIST_INSERT_HEAD(&sim->ccb_freeq, &free_ccb->ccb_h, 4269 xpt_links.sle); 4270 } 4271 if (sim->devq == NULL) { 4272 return; 4273 } 4274 sim->devq->alloc_openings++; 4275 sim->devq->alloc_active--; 4276 /* XXX Turn this into an inline function - xpt_run_device?? */ 4277 if ((device_is_alloc_queued(device) == 0) 4278 && (device->drvq.entries > 0)) { 4279 xpt_schedule_dev_allocq(bus, device); 4280 } 4281 if (dev_allocq_is_runnable(sim->devq)) 4282 xpt_run_dev_allocq(bus); 4283 } 4284 4285 /* Functions accessed by SIM drivers */ 4286 4287 /* 4288 * A sim structure, listing the SIM entry points and instance 4289 * identification info is passed to xpt_bus_register to hook the SIM 4290 * into the CAM framework. xpt_bus_register creates a cam_eb entry 4291 * for this new bus and places it in the array of busses and assigns 4292 * it a path_id. The path_id may be influenced by "hard wiring" 4293 * information specified by the user. Once interrupt services are 4294 * availible, the bus will be probed. 4295 */ 4296 int32_t 4297 xpt_bus_register(struct cam_sim *sim, u_int32_t bus) 4298 { 4299 struct cam_eb *new_bus; 4300 struct cam_eb *old_bus; 4301 struct ccb_pathinq *cpi; 4302 4303 sim_lock_assert_owned(sim->lock); 4304 4305 sim->bus_id = bus; 4306 new_bus = kmalloc(sizeof(*new_bus), M_CAMXPT, M_INTWAIT); 4307 4308 /* 4309 * Must hold topo lock across xptpathid() through installation of 4310 * new_bus to avoid duplication due to SMP races. 4311 */ 4312 lockmgr(&xsoftc.xpt_topo_lock, LK_EXCLUSIVE); 4313 if (strcmp(sim->sim_name, "xpt") != 0) { 4314 sim->path_id = 4315 xptpathid(sim->sim_name, sim->unit_number, sim->bus_id); 4316 } 4317 4318 TAILQ_INIT(&new_bus->et_entries); 4319 new_bus->path_id = sim->path_id; 4320 new_bus->sim = sim; 4321 atomic_add_int(&sim->refcount, 1); 4322 timevalclear(&new_bus->last_reset); 4323 new_bus->flags = 0; 4324 new_bus->refcount = 1; /* Held until a bus_deregister event */ 4325 new_bus->generation = 0; 4326 new_bus->counted_to_config = 0; 4327 old_bus = TAILQ_FIRST(&xsoftc.xpt_busses); 4328 while (old_bus != NULL && old_bus->path_id < new_bus->path_id) 4329 old_bus = TAILQ_NEXT(old_bus, links); 4330 if (old_bus != NULL) 4331 TAILQ_INSERT_BEFORE(old_bus, new_bus, links); 4332 else 4333 TAILQ_INSERT_TAIL(&xsoftc.xpt_busses, new_bus, links); 4334 xsoftc.bus_generation++; 4335 lockmgr(&xsoftc.xpt_topo_lock, LK_RELEASE); 4336 4337 /* Notify interested parties */ 4338 if (sim->path_id != CAM_XPT_PATH_ID) { 4339 struct cam_path path; 4340 4341 cpi = &xpt_alloc_ccb()->cpi; 4342 xpt_compile_path(&path, /*periph*/NULL, sim->path_id, 4343 CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD); 4344 xpt_setup_ccb(&cpi->ccb_h, &path, /*priority*/1); 4345 cpi->ccb_h.func_code = XPT_PATH_INQ; 4346 xpt_action((union ccb *)cpi); 4347 xpt_async(AC_PATH_REGISTERED, &path, cpi); 4348 xpt_release_path(&path); 4349 xpt_free_ccb(&cpi->ccb_h); 4350 } 4351 return (CAM_SUCCESS); 4352 } 4353 4354 /* 4355 * Deregister a bus. We must clean out all transactions pending on the bus. 4356 * This routine is typically called prior to cam_sim_free() (e.g. see 4357 * dev/usbmisc/umass/umass.c) 4358 */ 4359 int32_t 4360 xpt_bus_deregister(path_id_t pathid) 4361 { 4362 struct cam_path bus_path; 4363 struct cam_et *target; 4364 struct cam_ed *device; 4365 struct cam_ed_qinfo *qinfo; 4366 struct cam_devq *devq; 4367 struct cam_periph *periph; 4368 struct cam_sim *ccbsim; 4369 union ccb *work_ccb; 4370 cam_status status; 4371 int retries = 0; 4372 4373 status = xpt_compile_path(&bus_path, NULL, pathid, 4374 CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD); 4375 if (status != CAM_REQ_CMP) 4376 return (status); 4377 4378 /* 4379 * This should clear out all pending requests and timeouts, but 4380 * the ccb's may be queued to a software interrupt. 4381 * 4382 * XXX AC_LOST_DEVICE does not precisely abort the pending requests, 4383 * and it really ought to. 4384 */ 4385 xpt_async(AC_LOST_DEVICE, &bus_path, NULL); 4386 xpt_async(AC_PATH_DEREGISTERED, &bus_path, NULL); 4387 4388 /* 4389 * Mark the SIM as having been deregistered. This prevents 4390 * certain operations from re-queueing to it, stops new devices 4391 * from being added, etc. 4392 */ 4393 devq = bus_path.bus->sim->devq; 4394 ccbsim = bus_path.bus->sim; 4395 ccbsim->flags |= CAM_SIM_DEREGISTERED; 4396 4397 again: 4398 /* 4399 * Execute any pending operations now. 4400 */ 4401 while ((qinfo = (struct cam_ed_qinfo *)camq_remove(&devq->send_queue, 4402 CAMQ_HEAD)) != NULL || 4403 (qinfo = (struct cam_ed_qinfo *)camq_remove(&devq->alloc_queue, 4404 CAMQ_HEAD)) != NULL) { 4405 do { 4406 device = qinfo->device; 4407 work_ccb = cam_ccbq_peek_ccb(&device->ccbq, CAMQ_HEAD); 4408 if (work_ccb != NULL) { 4409 devq->active_dev = device; 4410 cam_ccbq_remove_ccb(&device->ccbq, work_ccb); 4411 cam_ccbq_send_ccb(&device->ccbq, work_ccb); 4412 (*(ccbsim->sim_action))(ccbsim, work_ccb); 4413 } 4414 4415 periph = (struct cam_periph *)camq_remove(&device->drvq, 4416 CAMQ_HEAD); 4417 if (periph != NULL) 4418 xpt_schedule(periph, periph->pinfo.priority); 4419 } while (work_ccb != NULL || periph != NULL); 4420 } 4421 4422 /* 4423 * Make sure all completed CCBs are processed. 4424 */ 4425 while (!TAILQ_EMPTY(&ccbsim->sim_doneq)) { 4426 camisr_runqueue(ccbsim); 4427 } 4428 4429 /* 4430 * Check for requeues, reissues asyncs if necessary 4431 */ 4432 if (CAMQ_GET_HEAD(&devq->send_queue)) 4433 kprintf("camq: devq send_queue still in use (%d entries)\n", 4434 devq->send_queue.entries); 4435 if (CAMQ_GET_HEAD(&devq->alloc_queue)) 4436 kprintf("camq: devq alloc_queue still in use (%d entries)\n", 4437 devq->alloc_queue.entries); 4438 if (CAMQ_GET_HEAD(&devq->send_queue) || 4439 CAMQ_GET_HEAD(&devq->alloc_queue)) { 4440 if (++retries < 5) { 4441 xpt_async(AC_LOST_DEVICE, &bus_path, NULL); 4442 xpt_async(AC_PATH_DEREGISTERED, &bus_path, NULL); 4443 goto again; 4444 } 4445 } 4446 4447 /* 4448 * Retarget the bus and all cached sim pointers to dead_sim. 4449 * 4450 * Various CAM subsystems may be holding on to targets, devices, 4451 * and/or peripherals and may attempt to use the sim pointer cached 4452 * in some of these structures during close. 4453 */ 4454 lockmgr(&xsoftc.xpt_topo_lock, LK_EXCLUSIVE); 4455 bus_path.bus->sim = &cam_dead_sim; 4456 TAILQ_FOREACH(target, &bus_path.bus->et_entries, links) { 4457 TAILQ_FOREACH(device, &target->ed_entries, links) { 4458 device->sim = &cam_dead_sim; 4459 SLIST_FOREACH(periph, &device->periphs, periph_links) { 4460 periph->sim = &cam_dead_sim; 4461 } 4462 } 4463 } 4464 lockmgr(&xsoftc.xpt_topo_lock, LK_RELEASE); 4465 4466 /* 4467 * Repeat the async's for the benefit of any new devices, such as 4468 * might be created from completed probes. Any new device 4469 * ops will run on dead_sim. 4470 * 4471 * XXX There are probably races :-( 4472 */ 4473 CAM_SIM_LOCK(&cam_dead_sim); 4474 xpt_async(AC_LOST_DEVICE, &bus_path, NULL); 4475 xpt_async(AC_PATH_DEREGISTERED, &bus_path, NULL); 4476 CAM_SIM_UNLOCK(&cam_dead_sim); 4477 4478 /* Release the reference count held while registered. */ 4479 xpt_release_bus(bus_path.bus); 4480 xpt_release_path(&bus_path); 4481 4482 /* Release the ref we got when the bus was registered */ 4483 cam_sim_release(ccbsim, 0); 4484 4485 return (CAM_REQ_CMP); 4486 } 4487 4488 /* 4489 * Must be called with xpt_topo_lock held. 4490 */ 4491 static path_id_t 4492 xptnextfreepathid(void) 4493 { 4494 struct cam_eb *bus; 4495 path_id_t pathid; 4496 const char *strval; 4497 4498 pathid = 0; 4499 bus = TAILQ_FIRST(&xsoftc.xpt_busses); 4500 retry: 4501 /* Find an unoccupied pathid */ 4502 while (bus != NULL && bus->path_id <= pathid) { 4503 if (bus->path_id == pathid) 4504 pathid++; 4505 bus = TAILQ_NEXT(bus, links); 4506 } 4507 4508 /* 4509 * Ensure that this pathid is not reserved for 4510 * a bus that may be registered in the future. 4511 */ 4512 if (resource_string_value("scbus", pathid, "at", &strval) == 0) { 4513 ++pathid; 4514 /* Start the search over */ 4515 goto retry; 4516 } 4517 return (pathid); 4518 } 4519 4520 /* 4521 * Must be called with xpt_topo_lock held. 4522 */ 4523 static path_id_t 4524 xptpathid(const char *sim_name, int sim_unit, int sim_bus) 4525 { 4526 path_id_t pathid; 4527 int i, dunit, val; 4528 char buf[32]; 4529 4530 pathid = CAM_XPT_PATH_ID; 4531 ksnprintf(buf, sizeof(buf), "%s%d", sim_name, sim_unit); 4532 i = -1; 4533 while ((i = resource_query_string(i, "at", buf)) != -1) { 4534 if (strcmp(resource_query_name(i), "scbus")) { 4535 /* Avoid a bit of foot shooting. */ 4536 continue; 4537 } 4538 dunit = resource_query_unit(i); 4539 if (dunit < 0) /* unwired?! */ 4540 continue; 4541 if (resource_int_value("scbus", dunit, "bus", &val) == 0) { 4542 if (sim_bus == val) { 4543 pathid = dunit; 4544 break; 4545 } 4546 } else if (sim_bus == 0) { 4547 /* Unspecified matches bus 0 */ 4548 pathid = dunit; 4549 break; 4550 } else { 4551 kprintf("Ambiguous scbus configuration for %s%d " 4552 "bus %d, cannot wire down. The kernel " 4553 "config entry for scbus%d should " 4554 "specify a controller bus.\n" 4555 "Scbus will be assigned dynamically.\n", 4556 sim_name, sim_unit, sim_bus, dunit); 4557 break; 4558 } 4559 } 4560 4561 if (pathid == CAM_XPT_PATH_ID) 4562 pathid = xptnextfreepathid(); 4563 return (pathid); 4564 } 4565 4566 void 4567 xpt_async(u_int32_t async_code, struct cam_path *path, void *async_arg) 4568 { 4569 struct cam_eb *bus; 4570 struct cam_et *target, *next_target; 4571 struct cam_ed *device, *next_device; 4572 4573 sim_lock_assert_owned(path->bus->sim->lock); 4574 4575 CAM_DEBUG(path, CAM_DEBUG_TRACE, ("xpt_async\n")); 4576 4577 /* 4578 * Most async events come from a CAM interrupt context. In 4579 * a few cases, the error recovery code at the peripheral layer, 4580 * which may run from our SWI or a process context, may signal 4581 * deferred events with a call to xpt_async. 4582 */ 4583 4584 bus = path->bus; 4585 4586 if (async_code == AC_BUS_RESET) { 4587 /* Update our notion of when the last reset occurred */ 4588 microuptime(&bus->last_reset); 4589 } 4590 4591 for (target = TAILQ_FIRST(&bus->et_entries); 4592 target != NULL; 4593 target = next_target) { 4594 4595 next_target = TAILQ_NEXT(target, links); 4596 4597 if (path->target != target 4598 && path->target->target_id != CAM_TARGET_WILDCARD 4599 && target->target_id != CAM_TARGET_WILDCARD) 4600 continue; 4601 4602 if (async_code == AC_SENT_BDR) { 4603 /* Update our notion of when the last reset occurred */ 4604 microuptime(&path->target->last_reset); 4605 } 4606 4607 for (device = TAILQ_FIRST(&target->ed_entries); 4608 device != NULL; 4609 device = next_device) { 4610 4611 next_device = TAILQ_NEXT(device, links); 4612 4613 if (path->device != device 4614 && path->device->lun_id != CAM_LUN_WILDCARD 4615 && device->lun_id != CAM_LUN_WILDCARD) 4616 continue; 4617 4618 xpt_dev_async(async_code, bus, target, 4619 device, async_arg); 4620 4621 xpt_async_bcast(&device->asyncs, async_code, 4622 path, async_arg); 4623 } 4624 } 4625 4626 /* 4627 * If this wasn't a fully wildcarded async, tell all 4628 * clients that want all async events. 4629 */ 4630 if (bus != xpt_periph->path->bus) 4631 xpt_async_bcast(&xpt_periph->path->device->asyncs, async_code, 4632 path, async_arg); 4633 } 4634 4635 static void 4636 xpt_async_bcast(struct async_list *async_head, 4637 u_int32_t async_code, 4638 struct cam_path *path, void *async_arg) 4639 { 4640 struct async_node *cur_entry; 4641 4642 cur_entry = SLIST_FIRST(async_head); 4643 while (cur_entry != NULL) { 4644 struct async_node *next_entry; 4645 /* 4646 * Grab the next list entry before we call the current 4647 * entry's callback. This is because the callback function 4648 * can delete its async callback entry. 4649 */ 4650 next_entry = SLIST_NEXT(cur_entry, links); 4651 if ((cur_entry->event_enable & async_code) != 0) 4652 cur_entry->callback(cur_entry->callback_arg, 4653 async_code, path, 4654 async_arg); 4655 cur_entry = next_entry; 4656 } 4657 } 4658 4659 /* 4660 * Handle any per-device event notifications that require action by the XPT. 4661 */ 4662 static void 4663 xpt_dev_async(u_int32_t async_code, struct cam_eb *bus, struct cam_et *target, 4664 struct cam_ed *device, void *async_arg) 4665 { 4666 cam_status status; 4667 struct cam_path newpath; 4668 4669 /* 4670 * We only need to handle events for real devices. 4671 */ 4672 if (target->target_id == CAM_TARGET_WILDCARD 4673 || device->lun_id == CAM_LUN_WILDCARD) 4674 return; 4675 4676 /* 4677 * We need our own path with wildcards expanded to 4678 * handle certain types of events. 4679 */ 4680 if ((async_code == AC_SENT_BDR) 4681 || (async_code == AC_BUS_RESET) 4682 || (async_code == AC_INQ_CHANGED)) 4683 status = xpt_compile_path(&newpath, NULL, 4684 bus->path_id, 4685 target->target_id, 4686 device->lun_id); 4687 else 4688 status = CAM_REQ_CMP_ERR; 4689 4690 if (status == CAM_REQ_CMP) { 4691 4692 /* 4693 * Allow transfer negotiation to occur in a 4694 * tag free environment. 4695 */ 4696 if (async_code == AC_SENT_BDR 4697 || async_code == AC_BUS_RESET) 4698 xpt_toggle_tags(&newpath); 4699 4700 if (async_code == AC_INQ_CHANGED) { 4701 /* 4702 * We've sent a start unit command, or 4703 * something similar to a device that 4704 * may have caused its inquiry data to 4705 * change. So we re-scan the device to 4706 * refresh the inquiry data for it. 4707 */ 4708 xpt_scan_lun(newpath.periph, &newpath, 4709 CAM_EXPECT_INQ_CHANGE, NULL); 4710 } 4711 xpt_release_path(&newpath); 4712 } else if (async_code == AC_LOST_DEVICE) { 4713 /* 4714 * When we lose a device the device may be about to detach 4715 * the sim, we have to clear out all pending timeouts and 4716 * requests before that happens. 4717 * 4718 * This typically happens most often with USB/UMASS devices. 4719 * 4720 * XXX it would be nice if we could abort the requests 4721 * pertaining to the device. 4722 */ 4723 xpt_release_devq_device(device, /*count*/1, /*run_queue*/TRUE); 4724 if ((device->flags & CAM_DEV_UNCONFIGURED) == 0) { 4725 device->flags |= CAM_DEV_UNCONFIGURED; 4726 xpt_release_device(bus, target, device); 4727 } 4728 } else if (async_code == AC_TRANSFER_NEG) { 4729 struct ccb_trans_settings *settings; 4730 4731 settings = (struct ccb_trans_settings *)async_arg; 4732 xpt_set_transfer_settings(settings, device, 4733 /*async_update*/TRUE); 4734 } 4735 } 4736 4737 u_int32_t 4738 xpt_freeze_devq(struct cam_path *path, u_int count) 4739 { 4740 struct ccb_hdr *ccbh; 4741 4742 sim_lock_assert_owned(path->bus->sim->lock); 4743 4744 path->device->qfrozen_cnt += count; 4745 4746 /* 4747 * Mark the last CCB in the queue as needing 4748 * to be requeued if the driver hasn't 4749 * changed it's state yet. This fixes a race 4750 * where a ccb is just about to be queued to 4751 * a controller driver when it's interrupt routine 4752 * freezes the queue. To completly close the 4753 * hole, controller drives must check to see 4754 * if a ccb's status is still CAM_REQ_INPROG 4755 * just before they queue 4756 * the CCB. See ahc_action/ahc_freeze_devq for 4757 * an example. 4758 */ 4759 ccbh = TAILQ_LAST(&path->device->ccbq.active_ccbs, ccb_hdr_tailq); 4760 if (ccbh && ccbh->status == CAM_REQ_INPROG) 4761 ccbh->status = CAM_REQUEUE_REQ; 4762 return (path->device->qfrozen_cnt); 4763 } 4764 4765 u_int32_t 4766 xpt_freeze_simq(struct cam_sim *sim, u_int count) 4767 { 4768 sim_lock_assert_owned(sim->lock); 4769 4770 if (sim->devq == NULL) 4771 return(count); 4772 sim->devq->send_queue.qfrozen_cnt += count; 4773 if (sim->devq->active_dev != NULL) { 4774 struct ccb_hdr *ccbh; 4775 4776 ccbh = TAILQ_LAST(&sim->devq->active_dev->ccbq.active_ccbs, 4777 ccb_hdr_tailq); 4778 if (ccbh && ccbh->status == CAM_REQ_INPROG) 4779 ccbh->status = CAM_REQUEUE_REQ; 4780 } 4781 return (sim->devq->send_queue.qfrozen_cnt); 4782 } 4783 4784 /* 4785 * Release the device queue after a timeout has expired, typically used to 4786 * introduce a delay before retrying after an I/O error or other problem. 4787 */ 4788 static void 4789 xpt_release_devq_timeout(void *arg) 4790 { 4791 struct cam_ed *device; 4792 4793 device = (struct cam_ed *)arg; 4794 CAM_SIM_LOCK(device->sim); 4795 xpt_release_devq_device(device, /*count*/1, /*run_queue*/TRUE); 4796 CAM_SIM_UNLOCK(device->sim); 4797 } 4798 4799 void 4800 xpt_release_devq(struct cam_path *path, u_int count, int run_queue) 4801 { 4802 sim_lock_assert_owned(path->bus->sim->lock); 4803 4804 xpt_release_devq_device(path->device, count, run_queue); 4805 } 4806 4807 static void 4808 xpt_release_devq_device(struct cam_ed *dev, u_int count, int run_queue) 4809 { 4810 int rundevq; 4811 4812 rundevq = 0; 4813 4814 if (dev->qfrozen_cnt > 0) { 4815 4816 count = (count > dev->qfrozen_cnt) ? dev->qfrozen_cnt : count; 4817 dev->qfrozen_cnt -= count; 4818 if (dev->qfrozen_cnt == 0) { 4819 4820 /* 4821 * No longer need to wait for a successful 4822 * command completion. 4823 */ 4824 dev->flags &= ~CAM_DEV_REL_ON_COMPLETE; 4825 4826 /* 4827 * Remove any timeouts that might be scheduled 4828 * to release this queue. 4829 */ 4830 if ((dev->flags & CAM_DEV_REL_TIMEOUT_PENDING) != 0) { 4831 callout_stop(&dev->callout); 4832 dev->flags &= ~CAM_DEV_REL_TIMEOUT_PENDING; 4833 } 4834 4835 /* 4836 * Now that we are unfrozen schedule the 4837 * device so any pending transactions are 4838 * run. 4839 */ 4840 if ((dev->ccbq.queue.entries > 0) 4841 && (xpt_schedule_dev_sendq(dev->target->bus, dev)) 4842 && (run_queue != 0)) { 4843 rundevq = 1; 4844 } 4845 } 4846 } 4847 if (rundevq != 0) 4848 xpt_run_dev_sendq(dev->target->bus); 4849 } 4850 4851 void 4852 xpt_release_simq(struct cam_sim *sim, int run_queue) 4853 { 4854 struct camq *sendq; 4855 4856 sim_lock_assert_owned(sim->lock); 4857 4858 if (sim->devq == NULL) 4859 return; 4860 4861 sendq = &(sim->devq->send_queue); 4862 if (sendq->qfrozen_cnt > 0) { 4863 sendq->qfrozen_cnt--; 4864 if (sendq->qfrozen_cnt == 0) { 4865 struct cam_eb *bus; 4866 4867 /* 4868 * If there is a timeout scheduled to release this 4869 * sim queue, remove it. The queue frozen count is 4870 * already at 0. 4871 */ 4872 if ((sim->flags & CAM_SIM_REL_TIMEOUT_PENDING) != 0){ 4873 callout_stop(&sim->callout); 4874 sim->flags &= ~CAM_SIM_REL_TIMEOUT_PENDING; 4875 } 4876 bus = xpt_find_bus(sim->path_id); 4877 4878 if (run_queue) { 4879 /* 4880 * Now that we are unfrozen run the send queue. 4881 */ 4882 xpt_run_dev_sendq(bus); 4883 } 4884 xpt_release_bus(bus); 4885 } 4886 } 4887 } 4888 4889 void 4890 xpt_done(union ccb *done_ccb) 4891 { 4892 struct cam_sim *sim; 4893 4894 CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_TRACE, ("xpt_done\n")); 4895 if ((done_ccb->ccb_h.func_code & XPT_FC_QUEUED) != 0) { 4896 /* 4897 * Queue up the request for handling by our SWI handler 4898 * any of the "non-immediate" type of ccbs. 4899 */ 4900 sim = done_ccb->ccb_h.path->bus->sim; 4901 switch (done_ccb->ccb_h.path->periph->type) { 4902 case CAM_PERIPH_BIO: 4903 spin_lock(&sim->sim_spin); 4904 TAILQ_INSERT_TAIL(&sim->sim_doneq, &done_ccb->ccb_h, 4905 sim_links.tqe); 4906 done_ccb->ccb_h.pinfo.index = CAM_DONEQ_INDEX; 4907 spin_unlock(&sim->sim_spin); 4908 if ((sim->flags & CAM_SIM_ON_DONEQ) == 0) { 4909 spin_lock(&cam_simq_spin); 4910 if ((sim->flags & CAM_SIM_ON_DONEQ) == 0) { 4911 TAILQ_INSERT_TAIL(&cam_simq, sim, 4912 links); 4913 sim->flags |= CAM_SIM_ON_DONEQ; 4914 } 4915 spin_unlock(&cam_simq_spin); 4916 } 4917 if ((done_ccb->ccb_h.flags & CAM_POLLED) == 0) 4918 setsoftcambio(); 4919 break; 4920 default: 4921 panic("unknown periph type %d", 4922 done_ccb->ccb_h.path->periph->type); 4923 } 4924 } 4925 } 4926 4927 union ccb * 4928 xpt_alloc_ccb(void) 4929 { 4930 union ccb *new_ccb; 4931 4932 new_ccb = kmalloc(sizeof(*new_ccb), M_CAMXPT, M_INTWAIT | M_ZERO); 4933 new_ccb->ccb_h.timeout_ch = kmalloc(sizeof(struct callout), M_CAMXPT, 4934 M_INTWAIT | M_ZERO); 4935 4936 return (new_ccb); 4937 } 4938 4939 void 4940 xpt_free_ccb(struct ccb_hdr *free_ccb) 4941 { 4942 KKASSERT(free_ccb->timeout_ch != NULL); 4943 kfree(free_ccb->timeout_ch, M_CAMXPT); 4944 free_ccb->timeout_ch = NULL; 4945 kfree(free_ccb, M_CAMXPT); 4946 } 4947 4948 /* Private XPT functions */ 4949 4950 /* 4951 * Get a CAM control block for the caller. Charge the structure to the device 4952 * referenced by the path. If the this device has no 'credits' then the 4953 * device already has the maximum number of outstanding operations under way 4954 * and we return NULL. If we don't have sufficient resources to allocate more 4955 * ccbs, we also return NULL. 4956 */ 4957 static union ccb * 4958 xpt_get_ccb(struct cam_ed *device) 4959 { 4960 union ccb *new_ccb; 4961 struct cam_sim *sim; 4962 4963 sim = device->sim; 4964 if ((new_ccb = (union ccb *)SLIST_FIRST(&sim->ccb_freeq)) == NULL) { 4965 new_ccb = xpt_alloc_ccb(); 4966 if ((sim->flags & CAM_SIM_MPSAFE) == 0) 4967 callout_init(new_ccb->ccb_h.timeout_ch); 4968 SLIST_INSERT_HEAD(&sim->ccb_freeq, &new_ccb->ccb_h, 4969 xpt_links.sle); 4970 sim->ccb_count++; 4971 } 4972 cam_ccbq_take_opening(&device->ccbq); 4973 SLIST_REMOVE_HEAD(&sim->ccb_freeq, xpt_links.sle); 4974 return (new_ccb); 4975 } 4976 4977 static void 4978 xpt_release_bus(struct cam_eb *bus) 4979 { 4980 for (;;) { 4981 int count = bus->refcount; 4982 4983 cpu_ccfence(); 4984 if (count == 1) { 4985 lockmgr(&xsoftc.xpt_topo_lock, LK_EXCLUSIVE); 4986 if (atomic_cmpset_int(&bus->refcount, 1, 0)) { 4987 if (TAILQ_EMPTY(&bus->et_entries)) { 4988 TAILQ_REMOVE(&xsoftc.xpt_busses, 4989 bus, links); 4990 xsoftc.bus_generation++; 4991 kfree(bus, M_CAMXPT); 4992 } 4993 lockmgr(&xsoftc.xpt_topo_lock, LK_RELEASE); 4994 return; 4995 } 4996 lockmgr(&xsoftc.xpt_topo_lock, LK_RELEASE); 4997 } else { 4998 if (atomic_cmpset_int(&bus->refcount, count, count-1)) { 4999 return; 5000 } 5001 } 5002 } 5003 } 5004 5005 static struct cam_et * 5006 xpt_alloc_target(struct cam_eb *bus, target_id_t target_id) 5007 { 5008 struct cam_et *target; 5009 struct cam_et *cur_target; 5010 5011 target = kmalloc(sizeof(*target), M_CAMXPT, M_INTWAIT); 5012 5013 TAILQ_INIT(&target->ed_entries); 5014 target->bus = bus; 5015 target->target_id = target_id; 5016 target->refcount = 1; 5017 target->generation = 0; 5018 timevalclear(&target->last_reset); 5019 5020 /* 5021 * Hold a reference to our parent bus so it 5022 * will not go away before we do. 5023 */ 5024 atomic_add_int(&bus->refcount, 1); 5025 5026 lockmgr(&xsoftc.xpt_topo_lock, LK_EXCLUSIVE); 5027 /* Insertion sort into our bus's target list */ 5028 cur_target = TAILQ_FIRST(&bus->et_entries); 5029 while (cur_target != NULL && cur_target->target_id < target_id) 5030 cur_target = TAILQ_NEXT(cur_target, links); 5031 5032 if (cur_target != NULL) { 5033 TAILQ_INSERT_BEFORE(cur_target, target, links); 5034 } else { 5035 TAILQ_INSERT_TAIL(&bus->et_entries, target, links); 5036 } 5037 bus->generation++; 5038 lockmgr(&xsoftc.xpt_topo_lock, LK_RELEASE); 5039 5040 return (target); 5041 } 5042 5043 static void 5044 xpt_release_target(struct cam_eb *bus, struct cam_et *target) 5045 { 5046 for (;;) { 5047 int count = target->refcount; 5048 5049 cpu_ccfence(); 5050 if (count == 1) { 5051 lockmgr(&xsoftc.xpt_topo_lock, LK_EXCLUSIVE); 5052 if (atomic_cmpset_int(&target->refcount, 1, 0)) { 5053 KKASSERT(TAILQ_EMPTY(&target->ed_entries)); 5054 TAILQ_REMOVE(&bus->et_entries, target, links); 5055 bus->generation++; 5056 kfree(target, M_CAMXPT); 5057 lockmgr(&xsoftc.xpt_topo_lock, LK_RELEASE); 5058 xpt_release_bus(bus); 5059 return; 5060 } 5061 lockmgr(&xsoftc.xpt_topo_lock, LK_RELEASE); 5062 } else { 5063 if (atomic_cmpset_int(&target->refcount, 5064 count, count - 1)) { 5065 return; 5066 } 5067 } 5068 } 5069 } 5070 5071 static struct cam_ed * 5072 xpt_alloc_device(struct cam_eb *bus, struct cam_et *target, lun_id_t lun_id) 5073 { 5074 struct cam_path path; 5075 struct cam_ed *device; 5076 struct cam_devq *devq; 5077 cam_status status; 5078 5079 /* 5080 * Disallow new devices while trying to deregister a sim 5081 */ 5082 if (bus->sim->flags & CAM_SIM_DEREGISTERED) 5083 return (NULL); 5084 5085 /* 5086 * Make space for us in the device queue on our bus 5087 */ 5088 lockmgr(&xsoftc.xpt_topo_lock, LK_EXCLUSIVE); 5089 devq = bus->sim->devq; 5090 if (devq == NULL) { 5091 lockmgr(&xsoftc.xpt_topo_lock, LK_RELEASE); 5092 return(NULL); 5093 } 5094 status = cam_devq_resize(devq, devq->alloc_queue.array_size + 1); 5095 lockmgr(&xsoftc.xpt_topo_lock, LK_RELEASE); 5096 5097 if (status != CAM_REQ_CMP) { 5098 device = NULL; 5099 } else { 5100 device = kmalloc(sizeof(*device), M_CAMXPT, M_INTWAIT); 5101 } 5102 5103 if (device != NULL) { 5104 struct cam_ed *cur_device; 5105 5106 cam_init_pinfo(&device->alloc_ccb_entry.pinfo); 5107 device->alloc_ccb_entry.device = device; 5108 cam_init_pinfo(&device->send_ccb_entry.pinfo); 5109 device->send_ccb_entry.device = device; 5110 device->target = target; 5111 device->lun_id = lun_id; 5112 device->sim = bus->sim; 5113 /* Initialize our queues */ 5114 if (camq_init(&device->drvq, 0) != 0) { 5115 kfree(device, M_CAMXPT); 5116 return (NULL); 5117 } 5118 if (cam_ccbq_init(&device->ccbq, 5119 bus->sim->max_dev_openings) != 0) { 5120 camq_fini(&device->drvq); 5121 kfree(device, M_CAMXPT); 5122 return (NULL); 5123 } 5124 SLIST_INIT(&device->asyncs); 5125 SLIST_INIT(&device->periphs); 5126 device->generation = 0; 5127 device->owner = NULL; 5128 /* 5129 * Take the default quirk entry until we have inquiry 5130 * data and can determine a better quirk to use. 5131 */ 5132 device->quirk = &xpt_quirk_table[xpt_quirk_table_size - 1]; 5133 bzero(&device->inq_data, sizeof(device->inq_data)); 5134 device->inq_flags = 0; 5135 device->queue_flags = 0; 5136 device->serial_num = NULL; 5137 device->serial_num_len = 0; 5138 device->qfrozen_cnt = 0; 5139 device->flags = CAM_DEV_UNCONFIGURED; 5140 device->tag_delay_count = 0; 5141 device->tag_saved_openings = 0; 5142 device->refcount = 1; 5143 callout_init(&device->callout); 5144 5145 /* 5146 * Hold a reference to our parent target so it 5147 * will not go away before we do. 5148 */ 5149 atomic_add_int(&target->refcount, 1); 5150 5151 /* 5152 * XXX should be limited by number of CCBs this bus can 5153 * do. 5154 */ 5155 bus->sim->max_ccbs += device->ccbq.devq_openings; 5156 /* Insertion sort into our target's device list */ 5157 cur_device = TAILQ_FIRST(&target->ed_entries); 5158 while (cur_device != NULL && cur_device->lun_id < lun_id) 5159 cur_device = TAILQ_NEXT(cur_device, links); 5160 if (cur_device != NULL) { 5161 TAILQ_INSERT_BEFORE(cur_device, device, links); 5162 } else { 5163 TAILQ_INSERT_TAIL(&target->ed_entries, device, links); 5164 } 5165 target->generation++; 5166 if (lun_id != CAM_LUN_WILDCARD) { 5167 xpt_compile_path(&path, 5168 NULL, 5169 bus->path_id, 5170 target->target_id, 5171 lun_id); 5172 xpt_devise_transport(&path); 5173 xpt_release_path(&path); 5174 } 5175 } 5176 return (device); 5177 } 5178 5179 static void 5180 xpt_reference_device(struct cam_ed *device) 5181 { 5182 atomic_add_int(&device->refcount, 1); 5183 } 5184 5185 static void 5186 xpt_release_device(struct cam_eb *bus, struct cam_et *target, 5187 struct cam_ed *device) 5188 { 5189 struct cam_devq *devq; 5190 5191 for (;;) { 5192 int count = device->refcount; 5193 5194 if (count == 1) { 5195 lockmgr(&xsoftc.xpt_topo_lock, LK_EXCLUSIVE); 5196 if (atomic_cmpset_int(&device->refcount, 1, 0)) { 5197 KKASSERT(device->flags & CAM_DEV_UNCONFIGURED); 5198 if (device->alloc_ccb_entry.pinfo.index != 5199 CAM_UNQUEUED_INDEX || 5200 device->send_ccb_entry.pinfo.index != 5201 CAM_UNQUEUED_INDEX) { 5202 panic("Removing device while " 5203 "still queued for ccbs"); 5204 } 5205 if ((device->flags & CAM_DEV_REL_TIMEOUT_PENDING) != 0) { 5206 device->flags &= ~CAM_DEV_REL_TIMEOUT_PENDING; 5207 callout_stop(&device->callout); 5208 } 5209 TAILQ_REMOVE(&target->ed_entries, device, links); 5210 target->generation++; 5211 bus->sim->max_ccbs -= device->ccbq.devq_openings; 5212 if ((devq = bus->sim->devq) != NULL) { 5213 /* Release our slot in the devq */ 5214 cam_devq_resize(devq, devq->alloc_queue.array_size - 1); 5215 } 5216 lockmgr(&xsoftc.xpt_topo_lock, LK_RELEASE); 5217 5218 camq_fini(&device->drvq); 5219 camq_fini(&device->ccbq.queue); 5220 xpt_release_target(bus, target); 5221 kfree(device, M_CAMXPT); 5222 return; 5223 } 5224 lockmgr(&xsoftc.xpt_topo_lock, LK_RELEASE); 5225 } else { 5226 if (atomic_cmpset_int(&device->refcount, 5227 count, count - 1)) { 5228 return; 5229 } 5230 } 5231 } 5232 } 5233 5234 static u_int32_t 5235 xpt_dev_ccbq_resize(struct cam_path *path, int newopenings) 5236 { 5237 int diff; 5238 int result; 5239 struct cam_ed *dev; 5240 5241 dev = path->device; 5242 5243 diff = newopenings - (dev->ccbq.dev_active + dev->ccbq.dev_openings); 5244 result = cam_ccbq_resize(&dev->ccbq, newopenings); 5245 if (result == CAM_REQ_CMP && (diff < 0)) { 5246 dev->flags |= CAM_DEV_RESIZE_QUEUE_NEEDED; 5247 } 5248 if ((dev->flags & CAM_DEV_TAG_AFTER_COUNT) != 0 5249 || (dev->inq_flags & SID_CmdQue) != 0) 5250 dev->tag_saved_openings = newopenings; 5251 /* Adjust the global limit */ 5252 dev->sim->max_ccbs += diff; 5253 return (result); 5254 } 5255 5256 static struct cam_eb * 5257 xpt_find_bus(path_id_t path_id) 5258 { 5259 struct cam_eb *bus; 5260 5261 lockmgr(&xsoftc.xpt_topo_lock, LK_EXCLUSIVE); 5262 TAILQ_FOREACH(bus, &xsoftc.xpt_busses, links) { 5263 if (bus->path_id == path_id) { 5264 atomic_add_int(&bus->refcount, 1); 5265 break; 5266 } 5267 } 5268 lockmgr(&xsoftc.xpt_topo_lock, LK_RELEASE); 5269 5270 return (bus); 5271 } 5272 5273 static struct cam_et * 5274 xpt_find_target(struct cam_eb *bus, target_id_t target_id) 5275 { 5276 struct cam_et *target; 5277 5278 lockmgr(&xsoftc.xpt_topo_lock, LK_EXCLUSIVE); 5279 TAILQ_FOREACH(target, &bus->et_entries, links) { 5280 if (target->target_id == target_id) { 5281 atomic_add_int(&target->refcount, 1); 5282 break; 5283 } 5284 } 5285 lockmgr(&xsoftc.xpt_topo_lock, LK_RELEASE); 5286 5287 return (target); 5288 } 5289 5290 static struct cam_ed * 5291 xpt_find_device(struct cam_et *target, lun_id_t lun_id) 5292 { 5293 struct cam_ed *device; 5294 5295 lockmgr(&xsoftc.xpt_topo_lock, LK_EXCLUSIVE); 5296 TAILQ_FOREACH(device, &target->ed_entries, links) { 5297 if (device->lun_id == lun_id) { 5298 atomic_add_int(&device->refcount, 1); 5299 break; 5300 } 5301 } 5302 lockmgr(&xsoftc.xpt_topo_lock, LK_RELEASE); 5303 5304 return (device); 5305 } 5306 5307 typedef struct { 5308 union ccb *request_ccb; 5309 struct ccb_pathinq *cpi; 5310 int counter; 5311 } xpt_scan_bus_info; 5312 5313 /* 5314 * To start a scan, request_ccb is an XPT_SCAN_BUS ccb. 5315 * As the scan progresses, xpt_scan_bus is used as the 5316 * callback on completion function. 5317 */ 5318 static void 5319 xpt_scan_bus(struct cam_periph *periph, union ccb *request_ccb) 5320 { 5321 CAM_DEBUG(request_ccb->ccb_h.path, CAM_DEBUG_TRACE, 5322 ("xpt_scan_bus\n")); 5323 switch (request_ccb->ccb_h.func_code) { 5324 case XPT_SCAN_BUS: 5325 { 5326 xpt_scan_bus_info *scan_info; 5327 union ccb *work_ccb; 5328 struct cam_path *path; 5329 u_int i; 5330 u_int max_target; 5331 u_int initiator_id; 5332 5333 /* Find out the characteristics of the bus */ 5334 work_ccb = xpt_alloc_ccb(); 5335 xpt_setup_ccb(&work_ccb->ccb_h, request_ccb->ccb_h.path, 5336 request_ccb->ccb_h.pinfo.priority); 5337 work_ccb->ccb_h.func_code = XPT_PATH_INQ; 5338 xpt_action(work_ccb); 5339 if (work_ccb->ccb_h.status != CAM_REQ_CMP) { 5340 request_ccb->ccb_h.status = work_ccb->ccb_h.status; 5341 xpt_free_ccb(&work_ccb->ccb_h); 5342 xpt_done(request_ccb); 5343 return; 5344 } 5345 5346 if ((work_ccb->cpi.hba_misc & PIM_NOINITIATOR) != 0) { 5347 /* 5348 * Can't scan the bus on an adapter that 5349 * cannot perform the initiator role. 5350 */ 5351 request_ccb->ccb_h.status = CAM_REQ_CMP; 5352 xpt_free_ccb(&work_ccb->ccb_h); 5353 xpt_done(request_ccb); 5354 return; 5355 } 5356 5357 /* Save some state for use while we probe for devices */ 5358 scan_info = (xpt_scan_bus_info *) 5359 kmalloc(sizeof(xpt_scan_bus_info), M_CAMXPT, M_INTWAIT); 5360 scan_info->request_ccb = request_ccb; 5361 scan_info->cpi = &work_ccb->cpi; 5362 5363 /* Cache on our stack so we can work asynchronously */ 5364 max_target = scan_info->cpi->max_target; 5365 initiator_id = scan_info->cpi->initiator_id; 5366 5367 5368 /* 5369 * We can scan all targets in parallel, or do it sequentially. 5370 */ 5371 if (scan_info->cpi->hba_misc & PIM_SEQSCAN) { 5372 max_target = 0; 5373 scan_info->counter = 0; 5374 } else { 5375 scan_info->counter = scan_info->cpi->max_target + 1; 5376 if (scan_info->cpi->initiator_id < scan_info->counter) { 5377 scan_info->counter--; 5378 } 5379 } 5380 5381 for (i = 0; i <= max_target; i++) { 5382 cam_status status; 5383 if (i == initiator_id) 5384 continue; 5385 5386 status = xpt_create_path(&path, xpt_periph, 5387 request_ccb->ccb_h.path_id, 5388 i, 0); 5389 if (status != CAM_REQ_CMP) { 5390 kprintf("xpt_scan_bus: xpt_create_path failed" 5391 " with status %#x, bus scan halted\n", 5392 status); 5393 kfree(scan_info, M_CAMXPT); 5394 request_ccb->ccb_h.status = status; 5395 xpt_free_ccb(&work_ccb->ccb_h); 5396 xpt_done(request_ccb); 5397 break; 5398 } 5399 work_ccb = xpt_alloc_ccb(); 5400 xpt_setup_ccb(&work_ccb->ccb_h, path, 5401 request_ccb->ccb_h.pinfo.priority); 5402 work_ccb->ccb_h.func_code = XPT_SCAN_LUN; 5403 work_ccb->ccb_h.cbfcnp = xpt_scan_bus; 5404 work_ccb->ccb_h.ppriv_ptr0 = scan_info; 5405 work_ccb->crcn.flags = request_ccb->crcn.flags; 5406 xpt_action(work_ccb); 5407 } 5408 break; 5409 } 5410 case XPT_SCAN_LUN: 5411 { 5412 cam_status status; 5413 struct cam_path *path; 5414 xpt_scan_bus_info *scan_info; 5415 path_id_t path_id; 5416 target_id_t target_id; 5417 lun_id_t lun_id; 5418 5419 /* Reuse the same CCB to query if a device was really found */ 5420 scan_info = (xpt_scan_bus_info *)request_ccb->ccb_h.ppriv_ptr0; 5421 xpt_setup_ccb(&request_ccb->ccb_h, request_ccb->ccb_h.path, 5422 request_ccb->ccb_h.pinfo.priority); 5423 request_ccb->ccb_h.func_code = XPT_GDEV_TYPE; 5424 5425 path_id = request_ccb->ccb_h.path_id; 5426 target_id = request_ccb->ccb_h.target_id; 5427 lun_id = request_ccb->ccb_h.target_lun; 5428 xpt_action(request_ccb); 5429 5430 if (request_ccb->ccb_h.status != CAM_REQ_CMP) { 5431 struct cam_ed *device; 5432 struct cam_et *target; 5433 int phl; 5434 5435 /* 5436 * If we already probed lun 0 successfully, or 5437 * we have additional configured luns on this 5438 * target that might have "gone away", go onto 5439 * the next lun. 5440 */ 5441 target = request_ccb->ccb_h.path->target; 5442 /* 5443 * We may touch devices that we don't 5444 * hold references too, so ensure they 5445 * don't disappear out from under us. 5446 * The target above is referenced by the 5447 * path in the request ccb. 5448 */ 5449 phl = 0; 5450 device = TAILQ_FIRST(&target->ed_entries); 5451 if (device != NULL) { 5452 phl = CAN_SRCH_HI_SPARSE(device); 5453 if (device->lun_id == 0) 5454 device = TAILQ_NEXT(device, links); 5455 } 5456 if ((lun_id != 0) || (device != NULL)) { 5457 if (lun_id < (CAM_SCSI2_MAXLUN-1) || phl) 5458 lun_id++; 5459 } 5460 } else { 5461 struct cam_ed *device; 5462 5463 device = request_ccb->ccb_h.path->device; 5464 5465 if ((device->quirk->quirks & CAM_QUIRK_NOLUNS) == 0) { 5466 /* Try the next lun */ 5467 if (lun_id < (CAM_SCSI2_MAXLUN-1) 5468 || CAN_SRCH_HI_DENSE(device)) 5469 lun_id++; 5470 } 5471 } 5472 5473 /* 5474 * Free the current request path- we're done with it. 5475 */ 5476 xpt_free_path(request_ccb->ccb_h.path); 5477 5478 /* 5479 * Check to see if we scan any further luns. 5480 */ 5481 if (lun_id == request_ccb->ccb_h.target_lun 5482 || lun_id > scan_info->cpi->max_lun) { 5483 int done; 5484 5485 hop_again: 5486 done = 0; 5487 if (scan_info->cpi->hba_misc & PIM_SEQSCAN) { 5488 scan_info->counter++; 5489 if (scan_info->counter == 5490 scan_info->cpi->initiator_id) { 5491 scan_info->counter++; 5492 } 5493 if (scan_info->counter >= 5494 scan_info->cpi->max_target+1) { 5495 done = 1; 5496 } 5497 } else { 5498 scan_info->counter--; 5499 if (scan_info->counter == 0) { 5500 done = 1; 5501 } 5502 } 5503 if (done) { 5504 xpt_free_ccb(&request_ccb->ccb_h); 5505 xpt_free_ccb(&scan_info->cpi->ccb_h); 5506 request_ccb = scan_info->request_ccb; 5507 kfree(scan_info, M_CAMXPT); 5508 request_ccb->ccb_h.status = CAM_REQ_CMP; 5509 xpt_done(request_ccb); 5510 break; 5511 } 5512 5513 if ((scan_info->cpi->hba_misc & PIM_SEQSCAN) == 0) { 5514 break; 5515 } 5516 status = xpt_create_path(&path, xpt_periph, 5517 scan_info->request_ccb->ccb_h.path_id, 5518 scan_info->counter, 0); 5519 if (status != CAM_REQ_CMP) { 5520 kprintf("xpt_scan_bus: xpt_create_path failed" 5521 " with status %#x, bus scan halted\n", 5522 status); 5523 xpt_free_ccb(&request_ccb->ccb_h); 5524 xpt_free_ccb(&scan_info->cpi->ccb_h); 5525 request_ccb = scan_info->request_ccb; 5526 kfree(scan_info, M_CAMXPT); 5527 request_ccb->ccb_h.status = status; 5528 xpt_done(request_ccb); 5529 break; 5530 } 5531 xpt_setup_ccb(&request_ccb->ccb_h, path, 5532 request_ccb->ccb_h.pinfo.priority); 5533 request_ccb->ccb_h.func_code = XPT_SCAN_LUN; 5534 request_ccb->ccb_h.cbfcnp = xpt_scan_bus; 5535 request_ccb->ccb_h.ppriv_ptr0 = scan_info; 5536 request_ccb->crcn.flags = 5537 scan_info->request_ccb->crcn.flags; 5538 } else { 5539 status = xpt_create_path(&path, xpt_periph, 5540 path_id, target_id, lun_id); 5541 if (status != CAM_REQ_CMP) { 5542 kprintf("xpt_scan_bus: xpt_create_path failed " 5543 "with status %#x, halting LUN scan\n", 5544 status); 5545 goto hop_again; 5546 } 5547 xpt_setup_ccb(&request_ccb->ccb_h, path, 5548 request_ccb->ccb_h.pinfo.priority); 5549 request_ccb->ccb_h.func_code = XPT_SCAN_LUN; 5550 request_ccb->ccb_h.cbfcnp = xpt_scan_bus; 5551 request_ccb->ccb_h.ppriv_ptr0 = scan_info; 5552 request_ccb->crcn.flags = 5553 scan_info->request_ccb->crcn.flags; 5554 } 5555 xpt_action(request_ccb); 5556 break; 5557 } 5558 default: 5559 break; 5560 } 5561 } 5562 5563 typedef enum { 5564 PROBE_TUR, 5565 PROBE_INQUIRY, /* this counts as DV0 for Basic Domain Validation */ 5566 PROBE_FULL_INQUIRY, 5567 PROBE_MODE_SENSE, 5568 PROBE_SERIAL_NUM_0, 5569 PROBE_SERIAL_NUM_1, 5570 PROBE_TUR_FOR_NEGOTIATION, 5571 PROBE_INQUIRY_BASIC_DV1, 5572 PROBE_INQUIRY_BASIC_DV2, 5573 PROBE_DV_EXIT, 5574 PROBE_INVALID 5575 } probe_action; 5576 5577 static char *probe_action_text[] = { 5578 "PROBE_TUR", 5579 "PROBE_INQUIRY", 5580 "PROBE_FULL_INQUIRY", 5581 "PROBE_MODE_SENSE", 5582 "PROBE_SERIAL_NUM_0", 5583 "PROBE_SERIAL_NUM_1", 5584 "PROBE_TUR_FOR_NEGOTIATION", 5585 "PROBE_INQUIRY_BASIC_DV1", 5586 "PROBE_INQUIRY_BASIC_DV2", 5587 "PROBE_DV_EXIT", 5588 "PROBE_INVALID" 5589 }; 5590 5591 #define PROBE_SET_ACTION(softc, newaction) \ 5592 do { \ 5593 char **text; \ 5594 text = probe_action_text; \ 5595 CAM_DEBUG((softc)->periph->path, CAM_DEBUG_INFO, \ 5596 ("Probe %s to %s\n", text[(softc)->action], \ 5597 text[(newaction)])); \ 5598 (softc)->action = (newaction); \ 5599 } while(0) 5600 5601 typedef enum { 5602 PROBE_INQUIRY_CKSUM = 0x01, 5603 PROBE_SERIAL_CKSUM = 0x02, 5604 PROBE_NO_ANNOUNCE = 0x04 5605 } probe_flags; 5606 5607 typedef struct { 5608 TAILQ_HEAD(, ccb_hdr) request_ccbs; 5609 probe_action action; 5610 union ccb saved_ccb; 5611 probe_flags flags; 5612 MD5_CTX context; 5613 u_int8_t digest[16]; 5614 struct cam_periph *periph; 5615 } probe_softc; 5616 5617 static void 5618 xpt_scan_lun(struct cam_periph *periph, struct cam_path *path, 5619 cam_flags flags, union ccb *request_ccb) 5620 { 5621 struct ccb_pathinq *cpi; 5622 cam_status status; 5623 struct cam_path *new_path; 5624 struct cam_periph *old_periph; 5625 5626 CAM_DEBUG(request_ccb->ccb_h.path, CAM_DEBUG_TRACE, 5627 ("xpt_scan_lun\n")); 5628 5629 cpi = &xpt_alloc_ccb()->cpi; 5630 xpt_setup_ccb(&cpi->ccb_h, path, /*priority*/1); 5631 cpi->ccb_h.func_code = XPT_PATH_INQ; 5632 xpt_action((union ccb *)cpi); 5633 5634 if (cpi->ccb_h.status != CAM_REQ_CMP) { 5635 if (request_ccb != NULL) { 5636 request_ccb->ccb_h.status = cpi->ccb_h.status; 5637 xpt_done(request_ccb); 5638 } 5639 xpt_free_ccb(&cpi->ccb_h); 5640 return; 5641 } 5642 5643 if ((cpi->hba_misc & PIM_NOINITIATOR) != 0) { 5644 /* 5645 * Can't scan the bus on an adapter that 5646 * cannot perform the initiator role. 5647 */ 5648 if (request_ccb != NULL) { 5649 request_ccb->ccb_h.status = CAM_REQ_CMP; 5650 xpt_done(request_ccb); 5651 } 5652 xpt_free_ccb(&cpi->ccb_h); 5653 return; 5654 } 5655 xpt_free_ccb(&cpi->ccb_h); 5656 5657 if (request_ccb == NULL) { 5658 request_ccb = xpt_alloc_ccb(); 5659 new_path = kmalloc(sizeof(*new_path), M_CAMXPT, M_INTWAIT); 5660 status = xpt_compile_path(new_path, xpt_periph, 5661 path->bus->path_id, 5662 path->target->target_id, 5663 path->device->lun_id); 5664 5665 if (status != CAM_REQ_CMP) { 5666 xpt_print(path, "xpt_scan_lun: can't compile path, " 5667 "can't continue\n"); 5668 xpt_free_ccb(&request_ccb->ccb_h); 5669 kfree(new_path, M_CAMXPT); 5670 return; 5671 } 5672 xpt_setup_ccb(&request_ccb->ccb_h, new_path, /*priority*/ 1); 5673 request_ccb->ccb_h.cbfcnp = xptscandone; 5674 request_ccb->ccb_h.func_code = XPT_SCAN_LUN; 5675 request_ccb->crcn.flags = flags; 5676 } 5677 5678 if ((old_periph = cam_periph_find(path, "probe")) != NULL) { 5679 probe_softc *softc; 5680 5681 softc = (probe_softc *)old_periph->softc; 5682 TAILQ_INSERT_TAIL(&softc->request_ccbs, &request_ccb->ccb_h, 5683 periph_links.tqe); 5684 } else { 5685 status = cam_periph_alloc(proberegister, NULL, probecleanup, 5686 probestart, "probe", 5687 CAM_PERIPH_BIO, 5688 request_ccb->ccb_h.path, NULL, 0, 5689 request_ccb); 5690 5691 if (status != CAM_REQ_CMP) { 5692 xpt_print(path, "xpt_scan_lun: cam_alloc_periph " 5693 "returned an error, can't continue probe\n"); 5694 request_ccb->ccb_h.status = status; 5695 xpt_done(request_ccb); 5696 } 5697 } 5698 } 5699 5700 static void 5701 xptscandone(struct cam_periph *periph, union ccb *done_ccb) 5702 { 5703 xpt_release_path(done_ccb->ccb_h.path); 5704 kfree(done_ccb->ccb_h.path, M_CAMXPT); 5705 xpt_free_ccb(&done_ccb->ccb_h); 5706 } 5707 5708 static cam_status 5709 proberegister(struct cam_periph *periph, void *arg) 5710 { 5711 union ccb *request_ccb; /* CCB representing the probe request */ 5712 cam_status status; 5713 probe_softc *softc; 5714 5715 request_ccb = (union ccb *)arg; 5716 if (periph == NULL) { 5717 kprintf("proberegister: periph was NULL!!\n"); 5718 return(CAM_REQ_CMP_ERR); 5719 } 5720 5721 if (request_ccb == NULL) { 5722 kprintf("proberegister: no probe CCB, " 5723 "can't register device\n"); 5724 return(CAM_REQ_CMP_ERR); 5725 } 5726 5727 softc = kmalloc(sizeof(*softc), M_CAMXPT, M_INTWAIT | M_ZERO); 5728 TAILQ_INIT(&softc->request_ccbs); 5729 TAILQ_INSERT_TAIL(&softc->request_ccbs, &request_ccb->ccb_h, 5730 periph_links.tqe); 5731 softc->flags = 0; 5732 periph->softc = softc; 5733 softc->periph = periph; 5734 softc->action = PROBE_INVALID; 5735 status = cam_periph_acquire(periph); 5736 if (status != CAM_REQ_CMP) { 5737 return (status); 5738 } 5739 5740 5741 /* 5742 * Ensure we've waited at least a bus settle 5743 * delay before attempting to probe the device. 5744 * For HBAs that don't do bus resets, this won't make a difference. 5745 */ 5746 cam_periph_freeze_after_event(periph, &periph->path->bus->last_reset, 5747 scsi_delay); 5748 probeschedule(periph); 5749 return(CAM_REQ_CMP); 5750 } 5751 5752 static void 5753 probeschedule(struct cam_periph *periph) 5754 { 5755 struct ccb_pathinq *cpi; 5756 union ccb *ccb; 5757 probe_softc *softc; 5758 5759 softc = (probe_softc *)periph->softc; 5760 ccb = (union ccb *)TAILQ_FIRST(&softc->request_ccbs); 5761 5762 cpi = &xpt_alloc_ccb()->cpi; 5763 xpt_setup_ccb(&cpi->ccb_h, periph->path, /*priority*/1); 5764 cpi->ccb_h.func_code = XPT_PATH_INQ; 5765 xpt_action((union ccb *)cpi); 5766 5767 /* 5768 * If a device has gone away and another device, or the same one, 5769 * is back in the same place, it should have a unit attention 5770 * condition pending. It will not report the unit attention in 5771 * response to an inquiry, which may leave invalid transfer 5772 * negotiations in effect. The TUR will reveal the unit attention 5773 * condition. Only send the TUR for lun 0, since some devices 5774 * will get confused by commands other than inquiry to non-existent 5775 * luns. If you think a device has gone away start your scan from 5776 * lun 0. This will insure that any bogus transfer settings are 5777 * invalidated. 5778 * 5779 * If we haven't seen the device before and the controller supports 5780 * some kind of transfer negotiation, negotiate with the first 5781 * sent command if no bus reset was performed at startup. This 5782 * ensures that the device is not confused by transfer negotiation 5783 * settings left over by loader or BIOS action. 5784 */ 5785 if (((ccb->ccb_h.path->device->flags & CAM_DEV_UNCONFIGURED) == 0) 5786 && (ccb->ccb_h.target_lun == 0)) { 5787 PROBE_SET_ACTION(softc, PROBE_TUR); 5788 } else if ((cpi->hba_inquiry & (PI_WIDE_32|PI_WIDE_16|PI_SDTR_ABLE)) != 0 5789 && (cpi->hba_misc & PIM_NOBUSRESET) != 0) { 5790 proberequestdefaultnegotiation(periph); 5791 PROBE_SET_ACTION(softc, PROBE_INQUIRY); 5792 } else { 5793 PROBE_SET_ACTION(softc, PROBE_INQUIRY); 5794 } 5795 5796 if (ccb->crcn.flags & CAM_EXPECT_INQ_CHANGE) 5797 softc->flags |= PROBE_NO_ANNOUNCE; 5798 else 5799 softc->flags &= ~PROBE_NO_ANNOUNCE; 5800 5801 xpt_schedule(periph, ccb->ccb_h.pinfo.priority); 5802 xpt_free_ccb(&cpi->ccb_h); 5803 } 5804 5805 static void 5806 probestart(struct cam_periph *periph, union ccb *start_ccb) 5807 { 5808 /* Probe the device that our peripheral driver points to */ 5809 struct ccb_scsiio *csio; 5810 probe_softc *softc; 5811 5812 CAM_DEBUG(start_ccb->ccb_h.path, CAM_DEBUG_TRACE, ("probestart\n")); 5813 5814 softc = (probe_softc *)periph->softc; 5815 csio = &start_ccb->csio; 5816 5817 switch (softc->action) { 5818 case PROBE_TUR: 5819 case PROBE_TUR_FOR_NEGOTIATION: 5820 case PROBE_DV_EXIT: 5821 { 5822 scsi_test_unit_ready(csio, 5823 /*retries*/4, 5824 probedone, 5825 MSG_SIMPLE_Q_TAG, 5826 SSD_FULL_SIZE, 5827 /*timeout*/60000); 5828 break; 5829 } 5830 case PROBE_INQUIRY: 5831 case PROBE_FULL_INQUIRY: 5832 case PROBE_INQUIRY_BASIC_DV1: 5833 case PROBE_INQUIRY_BASIC_DV2: 5834 { 5835 u_int inquiry_len; 5836 struct scsi_inquiry_data *inq_buf; 5837 5838 inq_buf = &periph->path->device->inq_data; 5839 5840 /* 5841 * If the device is currently configured, we calculate an 5842 * MD5 checksum of the inquiry data, and if the serial number 5843 * length is greater than 0, add the serial number data 5844 * into the checksum as well. Once the inquiry and the 5845 * serial number check finish, we attempt to figure out 5846 * whether we still have the same device. 5847 */ 5848 if ((periph->path->device->flags & CAM_DEV_UNCONFIGURED) == 0) { 5849 5850 MD5Init(&softc->context); 5851 MD5Update(&softc->context, (unsigned char *)inq_buf, 5852 sizeof(struct scsi_inquiry_data)); 5853 softc->flags |= PROBE_INQUIRY_CKSUM; 5854 if (periph->path->device->serial_num_len > 0) { 5855 MD5Update(&softc->context, 5856 periph->path->device->serial_num, 5857 periph->path->device->serial_num_len); 5858 softc->flags |= PROBE_SERIAL_CKSUM; 5859 } 5860 MD5Final(softc->digest, &softc->context); 5861 } 5862 5863 if (softc->action == PROBE_INQUIRY) 5864 inquiry_len = SHORT_INQUIRY_LENGTH; 5865 else 5866 inquiry_len = SID_ADDITIONAL_LENGTH(inq_buf); 5867 5868 /* 5869 * Some parallel SCSI devices fail to send an 5870 * ignore wide residue message when dealing with 5871 * odd length inquiry requests. Round up to be 5872 * safe. 5873 */ 5874 inquiry_len = roundup2(inquiry_len, 2); 5875 5876 if (softc->action == PROBE_INQUIRY_BASIC_DV1 5877 || softc->action == PROBE_INQUIRY_BASIC_DV2) { 5878 inq_buf = kmalloc(inquiry_len, M_CAMXPT, M_INTWAIT); 5879 } 5880 scsi_inquiry(csio, 5881 /*retries*/4, 5882 probedone, 5883 MSG_SIMPLE_Q_TAG, 5884 (u_int8_t *)inq_buf, 5885 inquiry_len, 5886 /*evpd*/FALSE, 5887 /*page_code*/0, 5888 SSD_MIN_SIZE, 5889 /*timeout*/60 * 1000); 5890 break; 5891 } 5892 case PROBE_MODE_SENSE: 5893 { 5894 void *mode_buf; 5895 int mode_buf_len; 5896 5897 mode_buf_len = sizeof(struct scsi_mode_header_6) 5898 + sizeof(struct scsi_mode_blk_desc) 5899 + sizeof(struct scsi_control_page); 5900 mode_buf = kmalloc(mode_buf_len, M_CAMXPT, M_INTWAIT); 5901 scsi_mode_sense(csio, 5902 /*retries*/4, 5903 probedone, 5904 MSG_SIMPLE_Q_TAG, 5905 /*dbd*/FALSE, 5906 SMS_PAGE_CTRL_CURRENT, 5907 SMS_CONTROL_MODE_PAGE, 5908 mode_buf, 5909 mode_buf_len, 5910 SSD_FULL_SIZE, 5911 /*timeout*/60000); 5912 break; 5913 } 5914 case PROBE_SERIAL_NUM_0: 5915 { 5916 struct scsi_vpd_supported_page_list *vpd_list = NULL; 5917 struct cam_ed *device; 5918 5919 device = periph->path->device; 5920 if ((device->quirk->quirks & CAM_QUIRK_NOSERIAL) == 0) { 5921 vpd_list = kmalloc(sizeof(*vpd_list), M_CAMXPT, 5922 M_INTWAIT | M_ZERO); 5923 } 5924 5925 if (vpd_list != NULL) { 5926 scsi_inquiry(csio, 5927 /*retries*/4, 5928 probedone, 5929 MSG_SIMPLE_Q_TAG, 5930 (u_int8_t *)vpd_list, 5931 sizeof(*vpd_list), 5932 /*evpd*/TRUE, 5933 SVPD_SUPPORTED_PAGE_LIST, 5934 SSD_MIN_SIZE, 5935 /*timeout*/60 * 1000); 5936 break; 5937 } 5938 /* 5939 * We'll have to do without, let our probedone 5940 * routine finish up for us. 5941 */ 5942 start_ccb->csio.data_ptr = NULL; 5943 probedone(periph, start_ccb); 5944 return; 5945 } 5946 case PROBE_SERIAL_NUM_1: 5947 { 5948 struct scsi_vpd_unit_serial_number *serial_buf; 5949 struct cam_ed* device; 5950 5951 serial_buf = NULL; 5952 device = periph->path->device; 5953 device->serial_num = NULL; 5954 device->serial_num_len = 0; 5955 5956 serial_buf = (struct scsi_vpd_unit_serial_number *) 5957 kmalloc(sizeof(*serial_buf), M_CAMXPT, 5958 M_INTWAIT | M_ZERO); 5959 scsi_inquiry(csio, 5960 /*retries*/4, 5961 probedone, 5962 MSG_SIMPLE_Q_TAG, 5963 (u_int8_t *)serial_buf, 5964 sizeof(*serial_buf), 5965 /*evpd*/TRUE, 5966 SVPD_UNIT_SERIAL_NUMBER, 5967 SSD_MIN_SIZE, 5968 /*timeout*/60 * 1000); 5969 break; 5970 } 5971 case PROBE_INVALID: 5972 CAM_DEBUG(start_ccb->ccb_h.path, CAM_DEBUG_INFO, 5973 ("probestart: invalid action state\n")); 5974 default: 5975 break; 5976 } 5977 xpt_action(start_ccb); 5978 } 5979 5980 static void 5981 proberequestdefaultnegotiation(struct cam_periph *periph) 5982 { 5983 struct ccb_trans_settings *cts; 5984 5985 cts = &xpt_alloc_ccb()->cts; 5986 xpt_setup_ccb(&cts->ccb_h, periph->path, /*priority*/1); 5987 cts->ccb_h.func_code = XPT_GET_TRAN_SETTINGS; 5988 cts->type = CTS_TYPE_USER_SETTINGS; 5989 xpt_action((union ccb *)cts); 5990 if ((cts->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 5991 xpt_free_ccb(&cts->ccb_h); 5992 return; 5993 } 5994 cts->ccb_h.func_code = XPT_SET_TRAN_SETTINGS; 5995 cts->type = CTS_TYPE_CURRENT_SETTINGS; 5996 xpt_action((union ccb *)cts); 5997 xpt_free_ccb(&cts->ccb_h); 5998 } 5999 6000 /* 6001 * Backoff Negotiation Code- only pertinent for SPI devices. 6002 */ 6003 static int 6004 proberequestbackoff(struct cam_periph *periph, struct cam_ed *device) 6005 { 6006 struct ccb_trans_settings *cts; 6007 struct ccb_trans_settings_spi *spi; 6008 int result; 6009 6010 result = 0; 6011 cts = &xpt_alloc_ccb()->cts; 6012 xpt_setup_ccb(&cts->ccb_h, periph->path, /*priority*/1); 6013 cts->ccb_h.func_code = XPT_GET_TRAN_SETTINGS; 6014 cts->type = CTS_TYPE_CURRENT_SETTINGS; 6015 xpt_action((union ccb *)cts); 6016 if ((cts->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 6017 if (bootverbose) { 6018 xpt_print(periph->path, 6019 "failed to get current device settings\n"); 6020 } 6021 goto done; 6022 } 6023 if (cts->transport != XPORT_SPI) { 6024 if (bootverbose) { 6025 xpt_print(periph->path, "not SPI transport\n"); 6026 } 6027 goto done; 6028 } 6029 spi = &cts->xport_specific.spi; 6030 6031 /* 6032 * We cannot renegotiate sync rate if we don't have one. 6033 */ 6034 if ((spi->valid & CTS_SPI_VALID_SYNC_RATE) == 0) { 6035 if (bootverbose) { 6036 xpt_print(periph->path, "no sync rate known\n"); 6037 } 6038 goto done; 6039 } 6040 6041 /* 6042 * We'll assert that we don't have to touch PPR options- the 6043 * SIM will see what we do with period and offset and adjust 6044 * the PPR options as appropriate. 6045 */ 6046 6047 /* 6048 * A sync rate with unknown or zero offset is nonsensical. 6049 * A sync period of zero means Async. 6050 */ 6051 if ((spi->valid & CTS_SPI_VALID_SYNC_OFFSET) == 0 6052 || spi->sync_offset == 0 || spi->sync_period == 0) { 6053 if (bootverbose) { 6054 xpt_print(periph->path, "no sync rate available\n"); 6055 } 6056 goto done; 6057 } 6058 6059 if (device->flags & CAM_DEV_DV_HIT_BOTTOM) { 6060 CAM_DEBUG(periph->path, CAM_DEBUG_INFO, 6061 ("hit async: giving up on DV\n")); 6062 goto done; 6063 } 6064 6065 6066 /* 6067 * Jump sync_period up by one, but stop at 5MHz and fall back to Async. 6068 * We don't try to remember 'last' settings to see if the SIM actually 6069 * gets into the speed we want to set. We check on the SIM telling 6070 * us that a requested speed is bad, but otherwise don't try and 6071 * check the speed due to the asynchronous and handshake nature 6072 * of speed setting. 6073 */ 6074 spi->valid = CTS_SPI_VALID_SYNC_RATE | CTS_SPI_VALID_SYNC_OFFSET; 6075 for (;;) { 6076 spi->sync_period++; 6077 if (spi->sync_period >= 0xf) { 6078 spi->sync_period = 0; 6079 spi->sync_offset = 0; 6080 CAM_DEBUG(periph->path, CAM_DEBUG_INFO, 6081 ("setting to async for DV\n")); 6082 /* 6083 * Once we hit async, we don't want to try 6084 * any more settings. 6085 */ 6086 device->flags |= CAM_DEV_DV_HIT_BOTTOM; 6087 } else if (bootverbose) { 6088 CAM_DEBUG(periph->path, CAM_DEBUG_INFO, 6089 ("DV: period 0x%x\n", spi->sync_period)); 6090 kprintf("setting period to 0x%x\n", spi->sync_period); 6091 } 6092 cts->ccb_h.func_code = XPT_SET_TRAN_SETTINGS; 6093 cts->type = CTS_TYPE_CURRENT_SETTINGS; 6094 xpt_action((union ccb *)cts); 6095 if ((cts->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) { 6096 break; 6097 } 6098 CAM_DEBUG(periph->path, CAM_DEBUG_INFO, 6099 ("DV: failed to set period 0x%x\n", spi->sync_period)); 6100 if (spi->sync_period == 0) 6101 goto done; 6102 } 6103 result = 1; 6104 done: 6105 xpt_free_ccb(&cts->ccb_h); 6106 6107 return result; 6108 } 6109 6110 static void 6111 probedone(struct cam_periph *periph, union ccb *done_ccb) 6112 { 6113 probe_softc *softc; 6114 struct cam_path *path; 6115 u_int32_t priority; 6116 6117 CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_TRACE, ("probedone\n")); 6118 6119 softc = (probe_softc *)periph->softc; 6120 path = done_ccb->ccb_h.path; 6121 priority = done_ccb->ccb_h.pinfo.priority; 6122 6123 switch (softc->action) { 6124 case PROBE_TUR: 6125 { 6126 if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 6127 6128 if (cam_periph_error(done_ccb, 0, 6129 SF_NO_PRINT, NULL) == ERESTART) 6130 return; 6131 else if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) 6132 /* Don't wedge the queue */ 6133 xpt_release_devq(done_ccb->ccb_h.path, 6134 /*count*/1, 6135 /*run_queue*/TRUE); 6136 } 6137 PROBE_SET_ACTION(softc, PROBE_INQUIRY); 6138 xpt_release_ccb(done_ccb); 6139 xpt_schedule(periph, priority); 6140 return; 6141 } 6142 case PROBE_INQUIRY: 6143 case PROBE_FULL_INQUIRY: 6144 { 6145 if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) { 6146 struct scsi_inquiry_data *inq_buf; 6147 u_int8_t periph_qual; 6148 6149 path->device->flags |= CAM_DEV_INQUIRY_DATA_VALID; 6150 inq_buf = &path->device->inq_data; 6151 6152 periph_qual = SID_QUAL(inq_buf); 6153 6154 switch(periph_qual) { 6155 case SID_QUAL_LU_CONNECTED: 6156 { 6157 u_int8_t len; 6158 6159 /* 6160 * We conservatively request only 6161 * SHORT_INQUIRY_LEN bytes of inquiry 6162 * information during our first try 6163 * at sending an INQUIRY. If the device 6164 * has more information to give, 6165 * perform a second request specifying 6166 * the amount of information the device 6167 * is willing to give. 6168 */ 6169 len = inq_buf->additional_length 6170 + offsetof(struct scsi_inquiry_data, 6171 additional_length) + 1; 6172 if (softc->action == PROBE_INQUIRY 6173 && len > SHORT_INQUIRY_LENGTH) { 6174 PROBE_SET_ACTION(softc, 6175 PROBE_FULL_INQUIRY); 6176 xpt_release_ccb(done_ccb); 6177 xpt_schedule(periph, priority); 6178 return; 6179 } 6180 6181 xpt_find_quirk(path->device); 6182 6183 xpt_devise_transport(path); 6184 if (INQ_DATA_TQ_ENABLED(inq_buf)) 6185 PROBE_SET_ACTION(softc, PROBE_MODE_SENSE); 6186 else 6187 PROBE_SET_ACTION(softc, PROBE_SERIAL_NUM_0); 6188 6189 path->device->flags &= ~CAM_DEV_UNCONFIGURED; 6190 xpt_reference_device(path->device); 6191 6192 xpt_release_ccb(done_ccb); 6193 xpt_schedule(periph, priority); 6194 return; 6195 } 6196 default: 6197 break; 6198 } 6199 } else if (cam_periph_error(done_ccb, 0, 6200 done_ccb->ccb_h.target_lun > 0 6201 ? SF_RETRY_UA|SF_QUIET_IR|SF_NO_PRINT 6202 : SF_RETRY_UA|SF_NO_PRINT, 6203 &softc->saved_ccb) == ERESTART) { 6204 return; 6205 } else if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) { 6206 /* Don't wedge the queue */ 6207 xpt_release_devq(done_ccb->ccb_h.path, /*count*/1, 6208 /*run_queue*/TRUE); 6209 } 6210 /* 6211 * If we get to this point, we got an error status back 6212 * from the inquiry and the error status doesn't require 6213 * automatically retrying the command. Therefore, the 6214 * inquiry failed. If we had inquiry information before 6215 * for this device, but this latest inquiry command failed, 6216 * the device has probably gone away. If this device isn't 6217 * already marked unconfigured, notify the peripheral 6218 * drivers that this device is no more. 6219 */ 6220 if ((path->device->flags & CAM_DEV_UNCONFIGURED) == 0) { 6221 /* Send the async notification. */ 6222 xpt_async(AC_LOST_DEVICE, path, NULL); 6223 } 6224 6225 xpt_release_ccb(done_ccb); 6226 break; 6227 } 6228 case PROBE_MODE_SENSE: 6229 { 6230 struct ccb_scsiio *csio; 6231 struct scsi_mode_header_6 *mode_hdr; 6232 6233 csio = &done_ccb->csio; 6234 mode_hdr = (struct scsi_mode_header_6 *)csio->data_ptr; 6235 if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) { 6236 struct scsi_control_page *page; 6237 u_int8_t *offset; 6238 6239 offset = ((u_int8_t *)&mode_hdr[1]) 6240 + mode_hdr->blk_desc_len; 6241 page = (struct scsi_control_page *)offset; 6242 path->device->queue_flags = page->queue_flags; 6243 } else if (cam_periph_error(done_ccb, 0, 6244 SF_RETRY_UA|SF_NO_PRINT, 6245 &softc->saved_ccb) == ERESTART) { 6246 return; 6247 } else if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) { 6248 /* Don't wedge the queue */ 6249 xpt_release_devq(done_ccb->ccb_h.path, 6250 /*count*/1, /*run_queue*/TRUE); 6251 } 6252 xpt_release_ccb(done_ccb); 6253 kfree(mode_hdr, M_CAMXPT); 6254 PROBE_SET_ACTION(softc, PROBE_SERIAL_NUM_0); 6255 xpt_schedule(periph, priority); 6256 return; 6257 } 6258 case PROBE_SERIAL_NUM_0: 6259 { 6260 struct ccb_scsiio *csio; 6261 struct scsi_vpd_supported_page_list *page_list; 6262 int length, serialnum_supported, i; 6263 6264 serialnum_supported = 0; 6265 csio = &done_ccb->csio; 6266 page_list = 6267 (struct scsi_vpd_supported_page_list *)csio->data_ptr; 6268 6269 if (page_list == NULL) { 6270 /* 6271 * Don't process the command as it was never sent 6272 */ 6273 } else if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP 6274 && (page_list->length > 0)) { 6275 length = min(page_list->length, 6276 SVPD_SUPPORTED_PAGES_SIZE); 6277 for (i = 0; i < length; i++) { 6278 if (page_list->list[i] == 6279 SVPD_UNIT_SERIAL_NUMBER) { 6280 serialnum_supported = 1; 6281 break; 6282 } 6283 } 6284 } else if (cam_periph_error(done_ccb, 0, 6285 SF_RETRY_UA|SF_NO_PRINT, 6286 &softc->saved_ccb) == ERESTART) { 6287 return; 6288 } else if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) { 6289 /* Don't wedge the queue */ 6290 xpt_release_devq(done_ccb->ccb_h.path, /*count*/1, 6291 /*run_queue*/TRUE); 6292 } 6293 6294 if (page_list != NULL) 6295 kfree(page_list, M_DEVBUF); 6296 6297 if (serialnum_supported) { 6298 xpt_release_ccb(done_ccb); 6299 PROBE_SET_ACTION(softc, PROBE_SERIAL_NUM_1); 6300 xpt_schedule(periph, priority); 6301 return; 6302 } 6303 6304 csio->data_ptr = NULL; 6305 /* FALLTHROUGH */ 6306 } 6307 6308 case PROBE_SERIAL_NUM_1: 6309 { 6310 struct ccb_scsiio *csio; 6311 struct scsi_vpd_unit_serial_number *serial_buf; 6312 u_int32_t priority; 6313 int changed; 6314 int have_serialnum; 6315 6316 changed = 1; 6317 have_serialnum = 0; 6318 csio = &done_ccb->csio; 6319 priority = done_ccb->ccb_h.pinfo.priority; 6320 serial_buf = 6321 (struct scsi_vpd_unit_serial_number *)csio->data_ptr; 6322 6323 /* Clean up from previous instance of this device */ 6324 if (path->device->serial_num != NULL) { 6325 kfree(path->device->serial_num, M_CAMXPT); 6326 path->device->serial_num = NULL; 6327 path->device->serial_num_len = 0; 6328 } 6329 6330 if (serial_buf == NULL) { 6331 /* 6332 * Don't process the command as it was never sent 6333 */ 6334 } else if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP 6335 && (serial_buf->length > 0)) { 6336 6337 have_serialnum = 1; 6338 path->device->serial_num = 6339 kmalloc((serial_buf->length + 1), 6340 M_CAMXPT, M_INTWAIT); 6341 bcopy(serial_buf->serial_num, 6342 path->device->serial_num, 6343 serial_buf->length); 6344 path->device->serial_num_len = serial_buf->length; 6345 path->device->serial_num[serial_buf->length] = '\0'; 6346 } else if (cam_periph_error(done_ccb, 0, 6347 SF_RETRY_UA|SF_NO_PRINT, 6348 &softc->saved_ccb) == ERESTART) { 6349 return; 6350 } else if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) { 6351 /* Don't wedge the queue */ 6352 xpt_release_devq(done_ccb->ccb_h.path, /*count*/1, 6353 /*run_queue*/TRUE); 6354 } 6355 6356 /* 6357 * Let's see if we have seen this device before. 6358 */ 6359 if ((softc->flags & PROBE_INQUIRY_CKSUM) != 0) { 6360 MD5_CTX context; 6361 u_int8_t digest[16]; 6362 6363 MD5Init(&context); 6364 6365 MD5Update(&context, 6366 (unsigned char *)&path->device->inq_data, 6367 sizeof(struct scsi_inquiry_data)); 6368 6369 if (have_serialnum) 6370 MD5Update(&context, serial_buf->serial_num, 6371 serial_buf->length); 6372 6373 MD5Final(digest, &context); 6374 if (bcmp(softc->digest, digest, 16) == 0) 6375 changed = 0; 6376 6377 /* 6378 * XXX Do we need to do a TUR in order to ensure 6379 * that the device really hasn't changed??? 6380 */ 6381 if ((changed != 0) 6382 && ((softc->flags & PROBE_NO_ANNOUNCE) == 0)) 6383 xpt_async(AC_LOST_DEVICE, path, NULL); 6384 } 6385 if (serial_buf != NULL) 6386 kfree(serial_buf, M_CAMXPT); 6387 6388 if (changed != 0) { 6389 /* 6390 * Now that we have all the necessary 6391 * information to safely perform transfer 6392 * negotiations... Controllers don't perform 6393 * any negotiation or tagged queuing until 6394 * after the first XPT_SET_TRAN_SETTINGS ccb is 6395 * received. So, on a new device, just retrieve 6396 * the user settings, and set them as the current 6397 * settings to set the device up. 6398 */ 6399 proberequestdefaultnegotiation(periph); 6400 xpt_release_ccb(done_ccb); 6401 6402 /* 6403 * Perform a TUR to allow the controller to 6404 * perform any necessary transfer negotiation. 6405 */ 6406 PROBE_SET_ACTION(softc, PROBE_TUR_FOR_NEGOTIATION); 6407 xpt_schedule(periph, priority); 6408 return; 6409 } 6410 xpt_release_ccb(done_ccb); 6411 break; 6412 } 6413 case PROBE_TUR_FOR_NEGOTIATION: 6414 case PROBE_DV_EXIT: 6415 if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) { 6416 /* Don't wedge the queue */ 6417 xpt_release_devq(done_ccb->ccb_h.path, /*count*/1, 6418 /*run_queue*/TRUE); 6419 } 6420 6421 xpt_reference_device(path->device); 6422 6423 /* 6424 * Do Domain Validation for lun 0 on devices that claim 6425 * to support Synchronous Transfer modes. 6426 * 6427 * The SID_Sync flag is obsolete or misused in some 6428 * situations (some virtio block devices), ignore it. 6429 */ 6430 if (softc->action == PROBE_TUR_FOR_NEGOTIATION 6431 && done_ccb->ccb_h.target_lun == 0 6432 /* && (path->device->inq_data.flags & SID_Sync) != 0 */ 6433 && (path->device->flags & CAM_DEV_IN_DV) == 0) { 6434 CAM_DEBUG(periph->path, CAM_DEBUG_INFO, 6435 ("Begin Domain Validation\n")); 6436 path->device->flags |= CAM_DEV_IN_DV; 6437 xpt_release_ccb(done_ccb); 6438 PROBE_SET_ACTION(softc, PROBE_INQUIRY_BASIC_DV1); 6439 xpt_schedule(periph, priority); 6440 return; 6441 } 6442 if (softc->action == PROBE_DV_EXIT) { 6443 CAM_DEBUG(periph->path, CAM_DEBUG_INFO, 6444 ("Leave Domain Validation\n")); 6445 } 6446 path->device->flags &= 6447 ~(CAM_DEV_UNCONFIGURED|CAM_DEV_IN_DV|CAM_DEV_DV_HIT_BOTTOM); 6448 if ((softc->flags & PROBE_NO_ANNOUNCE) == 0) { 6449 /* Inform the XPT that a new device has been found */ 6450 done_ccb->ccb_h.func_code = XPT_GDEV_TYPE; 6451 xpt_action(done_ccb); 6452 xpt_async(AC_FOUND_DEVICE, done_ccb->ccb_h.path, 6453 done_ccb); 6454 } 6455 xpt_release_ccb(done_ccb); 6456 break; 6457 case PROBE_INQUIRY_BASIC_DV1: 6458 case PROBE_INQUIRY_BASIC_DV2: 6459 { 6460 struct scsi_inquiry_data *nbuf; 6461 struct ccb_scsiio *csio; 6462 6463 if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) { 6464 /* Don't wedge the queue */ 6465 xpt_release_devq(done_ccb->ccb_h.path, /*count*/1, 6466 /*run_queue*/TRUE); 6467 } 6468 csio = &done_ccb->csio; 6469 nbuf = (struct scsi_inquiry_data *)csio->data_ptr; 6470 if (bcmp(nbuf, &path->device->inq_data, SHORT_INQUIRY_LENGTH)) { 6471 xpt_print(path, 6472 "inquiry data fails comparison at DV%d step\n", 6473 softc->action == PROBE_INQUIRY_BASIC_DV1 ? 1 : 2); 6474 if (proberequestbackoff(periph, path->device)) { 6475 path->device->flags &= ~CAM_DEV_IN_DV; 6476 PROBE_SET_ACTION(softc, PROBE_TUR_FOR_NEGOTIATION); 6477 } else { 6478 /* give up */ 6479 PROBE_SET_ACTION(softc, PROBE_DV_EXIT); 6480 } 6481 kfree(nbuf, M_CAMXPT); 6482 xpt_release_ccb(done_ccb); 6483 xpt_schedule(periph, priority); 6484 return; 6485 } 6486 kfree(nbuf, M_CAMXPT); 6487 if (softc->action == PROBE_INQUIRY_BASIC_DV1) { 6488 PROBE_SET_ACTION(softc, PROBE_INQUIRY_BASIC_DV2); 6489 xpt_release_ccb(done_ccb); 6490 xpt_schedule(periph, priority); 6491 return; 6492 } 6493 if (softc->action == PROBE_DV_EXIT) { 6494 CAM_DEBUG(periph->path, CAM_DEBUG_INFO, 6495 ("Leave Domain Validation Successfully\n")); 6496 } 6497 path->device->flags &= 6498 ~(CAM_DEV_UNCONFIGURED|CAM_DEV_IN_DV|CAM_DEV_DV_HIT_BOTTOM); 6499 if ((softc->flags & PROBE_NO_ANNOUNCE) == 0) { 6500 /* Inform the XPT that a new device has been found */ 6501 done_ccb->ccb_h.func_code = XPT_GDEV_TYPE; 6502 xpt_action(done_ccb); 6503 xpt_async(AC_FOUND_DEVICE, done_ccb->ccb_h.path, 6504 done_ccb); 6505 } 6506 xpt_release_ccb(done_ccb); 6507 break; 6508 } 6509 case PROBE_INVALID: 6510 CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_INFO, 6511 ("probedone: invalid action state\n")); 6512 default: 6513 break; 6514 } 6515 done_ccb = (union ccb *)TAILQ_FIRST(&softc->request_ccbs); 6516 TAILQ_REMOVE(&softc->request_ccbs, &done_ccb->ccb_h, periph_links.tqe); 6517 done_ccb->ccb_h.status = CAM_REQ_CMP; 6518 xpt_done(done_ccb); 6519 if (TAILQ_FIRST(&softc->request_ccbs) == NULL) { 6520 cam_periph_invalidate(periph); 6521 cam_periph_release(periph); 6522 } else { 6523 probeschedule(periph); 6524 } 6525 } 6526 6527 static void 6528 probecleanup(struct cam_periph *periph) 6529 { 6530 kfree(periph->softc, M_CAMXPT); 6531 } 6532 6533 static void 6534 xpt_find_quirk(struct cam_ed *device) 6535 { 6536 caddr_t match; 6537 6538 match = cam_quirkmatch((caddr_t)&device->inq_data, 6539 (caddr_t)xpt_quirk_table, 6540 NELEM(xpt_quirk_table), 6541 sizeof(*xpt_quirk_table), scsi_inquiry_match); 6542 6543 if (match == NULL) 6544 panic("xpt_find_quirk: device didn't match wildcard entry!!"); 6545 6546 device->quirk = (struct xpt_quirk_entry *)match; 6547 } 6548 6549 static int 6550 sysctl_cam_search_luns(SYSCTL_HANDLER_ARGS) 6551 { 6552 int error, lbool; 6553 6554 lbool = cam_srch_hi; 6555 error = sysctl_handle_int(oidp, &lbool, 0, req); 6556 if (error != 0 || req->newptr == NULL) 6557 return (error); 6558 if (lbool == 0 || lbool == 1) { 6559 cam_srch_hi = lbool; 6560 return (0); 6561 } else { 6562 return (EINVAL); 6563 } 6564 } 6565 6566 static void 6567 xpt_devise_transport(struct cam_path *path) 6568 { 6569 struct ccb_pathinq *cpi; 6570 struct ccb_trans_settings *cts; 6571 struct scsi_inquiry_data *inq_buf; 6572 6573 /* Get transport information from the SIM */ 6574 cpi = &xpt_alloc_ccb()->cpi; 6575 cts = &xpt_alloc_ccb()->cts; 6576 6577 xpt_setup_ccb(&cpi->ccb_h, path, /*priority*/1); 6578 cpi->ccb_h.func_code = XPT_PATH_INQ; 6579 xpt_action((union ccb *)cpi); 6580 6581 inq_buf = NULL; 6582 if ((path->device->flags & CAM_DEV_INQUIRY_DATA_VALID) != 0) 6583 inq_buf = &path->device->inq_data; 6584 path->device->protocol = PROTO_SCSI; 6585 path->device->protocol_version = 6586 inq_buf != NULL ? SID_ANSI_REV(inq_buf) : cpi->protocol_version; 6587 path->device->transport = cpi->transport; 6588 path->device->transport_version = cpi->transport_version; 6589 6590 /* 6591 * Any device not using SPI3 features should 6592 * be considered SPI2 or lower. 6593 */ 6594 if (inq_buf != NULL) { 6595 if (path->device->transport == XPORT_SPI 6596 && (inq_buf->spi3data & SID_SPI_MASK) == 0 6597 && path->device->transport_version > 2) 6598 path->device->transport_version = 2; 6599 } else { 6600 struct cam_ed* otherdev; 6601 6602 for (otherdev = TAILQ_FIRST(&path->target->ed_entries); 6603 otherdev != NULL; 6604 otherdev = TAILQ_NEXT(otherdev, links)) { 6605 if (otherdev != path->device) 6606 break; 6607 } 6608 6609 if (otherdev != NULL) { 6610 /* 6611 * Initially assume the same versioning as 6612 * prior luns for this target. 6613 */ 6614 path->device->protocol_version = 6615 otherdev->protocol_version; 6616 path->device->transport_version = 6617 otherdev->transport_version; 6618 } else { 6619 /* Until we know better, opt for safty */ 6620 path->device->protocol_version = 2; 6621 if (path->device->transport == XPORT_SPI) 6622 path->device->transport_version = 2; 6623 else 6624 path->device->transport_version = 0; 6625 } 6626 } 6627 6628 /* 6629 * XXX 6630 * For a device compliant with SPC-2 we should be able 6631 * to determine the transport version supported by 6632 * scrutinizing the version descriptors in the 6633 * inquiry buffer. 6634 */ 6635 6636 /* Tell the controller what we think */ 6637 xpt_setup_ccb(&cts->ccb_h, path, /*priority*/1); 6638 cts->ccb_h.func_code = XPT_SET_TRAN_SETTINGS; 6639 cts->type = CTS_TYPE_CURRENT_SETTINGS; 6640 cts->transport = path->device->transport; 6641 cts->transport_version = path->device->transport_version; 6642 cts->protocol = path->device->protocol; 6643 cts->protocol_version = path->device->protocol_version; 6644 cts->proto_specific.valid = 0; 6645 cts->xport_specific.valid = 0; 6646 xpt_action((union ccb *)cts); 6647 6648 xpt_free_ccb(&cts->ccb_h); 6649 xpt_free_ccb(&cpi->ccb_h); 6650 } 6651 6652 static void 6653 xpt_set_transfer_settings(struct ccb_trans_settings *cts, struct cam_ed *device, 6654 int async_update) 6655 { 6656 struct ccb_pathinq *cpi; 6657 struct ccb_trans_settings *cur_cts; 6658 struct ccb_trans_settings_scsi *scsi; 6659 struct ccb_trans_settings_scsi *cur_scsi; 6660 struct cam_sim *sim; 6661 struct scsi_inquiry_data *inq_data; 6662 6663 if (device == NULL) { 6664 cts->ccb_h.status = CAM_PATH_INVALID; 6665 xpt_done((union ccb *)cts); 6666 return; 6667 } 6668 6669 if (cts->protocol == PROTO_UNKNOWN 6670 || cts->protocol == PROTO_UNSPECIFIED) { 6671 cts->protocol = device->protocol; 6672 cts->protocol_version = device->protocol_version; 6673 } 6674 6675 if (cts->protocol_version == PROTO_VERSION_UNKNOWN 6676 || cts->protocol_version == PROTO_VERSION_UNSPECIFIED) 6677 cts->protocol_version = device->protocol_version; 6678 6679 if (cts->protocol != device->protocol) { 6680 xpt_print(cts->ccb_h.path, "Uninitialized Protocol %x:%x?\n", 6681 cts->protocol, device->protocol); 6682 cts->protocol = device->protocol; 6683 } 6684 6685 if (cts->protocol_version > device->protocol_version) { 6686 if (bootverbose) { 6687 xpt_print(cts->ccb_h.path, "Down reving Protocol " 6688 "Version from %d to %d?\n", cts->protocol_version, 6689 device->protocol_version); 6690 } 6691 cts->protocol_version = device->protocol_version; 6692 } 6693 6694 if (cts->transport == XPORT_UNKNOWN 6695 || cts->transport == XPORT_UNSPECIFIED) { 6696 cts->transport = device->transport; 6697 cts->transport_version = device->transport_version; 6698 } 6699 6700 if (cts->transport_version == XPORT_VERSION_UNKNOWN 6701 || cts->transport_version == XPORT_VERSION_UNSPECIFIED) 6702 cts->transport_version = device->transport_version; 6703 6704 if (cts->transport != device->transport) { 6705 xpt_print(cts->ccb_h.path, "Uninitialized Transport %x:%x?\n", 6706 cts->transport, device->transport); 6707 cts->transport = device->transport; 6708 } 6709 6710 if (cts->transport_version > device->transport_version) { 6711 if (bootverbose) { 6712 xpt_print(cts->ccb_h.path, "Down reving Transport " 6713 "Version from %d to %d?\n", cts->transport_version, 6714 device->transport_version); 6715 } 6716 cts->transport_version = device->transport_version; 6717 } 6718 6719 sim = cts->ccb_h.path->bus->sim; 6720 6721 /* 6722 * Nothing more of interest to do unless 6723 * this is a device connected via the 6724 * SCSI protocol. 6725 */ 6726 if (cts->protocol != PROTO_SCSI) { 6727 if (async_update == FALSE) 6728 (*(sim->sim_action))(sim, (union ccb *)cts); 6729 return; 6730 } 6731 6732 cpi = &xpt_alloc_ccb()->cpi; 6733 cur_cts = &xpt_alloc_ccb()->cts; 6734 6735 inq_data = &device->inq_data; 6736 scsi = &cts->proto_specific.scsi; 6737 xpt_setup_ccb(&cpi->ccb_h, cts->ccb_h.path, /*priority*/1); 6738 cpi->ccb_h.func_code = XPT_PATH_INQ; 6739 xpt_action((union ccb *)cpi); 6740 6741 /* SCSI specific sanity checking */ 6742 if ((cpi->hba_inquiry & PI_TAG_ABLE) == 0 6743 || (INQ_DATA_TQ_ENABLED(inq_data)) == 0 6744 || (device->queue_flags & SCP_QUEUE_DQUE) != 0 6745 || (device->quirk->mintags == 0)) { 6746 /* 6747 * Can't tag on hardware that doesn't support tags, 6748 * doesn't have it enabled, or has broken tag support. 6749 */ 6750 scsi->flags &= ~CTS_SCSI_FLAGS_TAG_ENB; 6751 } 6752 6753 if (async_update == FALSE) { 6754 /* 6755 * Perform sanity checking against what the 6756 * controller and device can do. 6757 */ 6758 xpt_setup_ccb(&cur_cts->ccb_h, cts->ccb_h.path, /*priority*/1); 6759 cur_cts->ccb_h.func_code = XPT_GET_TRAN_SETTINGS; 6760 cur_cts->type = cts->type; 6761 xpt_action((union ccb *)cur_cts); 6762 if ((cur_cts->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 6763 goto done; 6764 } 6765 cur_scsi = &cur_cts->proto_specific.scsi; 6766 if ((scsi->valid & CTS_SCSI_VALID_TQ) == 0) { 6767 scsi->flags &= ~CTS_SCSI_FLAGS_TAG_ENB; 6768 scsi->flags |= cur_scsi->flags & CTS_SCSI_FLAGS_TAG_ENB; 6769 } 6770 if ((cur_scsi->valid & CTS_SCSI_VALID_TQ) == 0) 6771 scsi->flags &= ~CTS_SCSI_FLAGS_TAG_ENB; 6772 } 6773 6774 /* SPI specific sanity checking */ 6775 if (cts->transport == XPORT_SPI && async_update == FALSE) { 6776 u_int spi3caps; 6777 struct ccb_trans_settings_spi *spi; 6778 struct ccb_trans_settings_spi *cur_spi; 6779 6780 spi = &cts->xport_specific.spi; 6781 6782 cur_spi = &cur_cts->xport_specific.spi; 6783 6784 /* Fill in any gaps in what the user gave us */ 6785 if ((spi->valid & CTS_SPI_VALID_SYNC_RATE) == 0) 6786 spi->sync_period = cur_spi->sync_period; 6787 if ((cur_spi->valid & CTS_SPI_VALID_SYNC_RATE) == 0) 6788 spi->sync_period = 0; 6789 if ((spi->valid & CTS_SPI_VALID_SYNC_OFFSET) == 0) 6790 spi->sync_offset = cur_spi->sync_offset; 6791 if ((cur_spi->valid & CTS_SPI_VALID_SYNC_OFFSET) == 0) 6792 spi->sync_offset = 0; 6793 if ((spi->valid & CTS_SPI_VALID_PPR_OPTIONS) == 0) 6794 spi->ppr_options = cur_spi->ppr_options; 6795 if ((cur_spi->valid & CTS_SPI_VALID_PPR_OPTIONS) == 0) 6796 spi->ppr_options = 0; 6797 if ((spi->valid & CTS_SPI_VALID_BUS_WIDTH) == 0) 6798 spi->bus_width = cur_spi->bus_width; 6799 if ((cur_spi->valid & CTS_SPI_VALID_BUS_WIDTH) == 0) 6800 spi->bus_width = 0; 6801 if ((spi->valid & CTS_SPI_VALID_DISC) == 0) { 6802 spi->flags &= ~CTS_SPI_FLAGS_DISC_ENB; 6803 spi->flags |= cur_spi->flags & CTS_SPI_FLAGS_DISC_ENB; 6804 } 6805 if ((cur_spi->valid & CTS_SPI_VALID_DISC) == 0) 6806 spi->flags &= ~CTS_SPI_FLAGS_DISC_ENB; 6807 if (((device->flags & CAM_DEV_INQUIRY_DATA_VALID) != 0 6808 && (inq_data->flags & SID_Sync) == 0 6809 && cts->type == CTS_TYPE_CURRENT_SETTINGS) 6810 || ((cpi->hba_inquiry & PI_SDTR_ABLE) == 0)) { 6811 /* Force async */ 6812 spi->sync_period = 0; 6813 spi->sync_offset = 0; 6814 } 6815 6816 switch (spi->bus_width) { 6817 case MSG_EXT_WDTR_BUS_32_BIT: 6818 if (((device->flags & CAM_DEV_INQUIRY_DATA_VALID) == 0 6819 || (inq_data->flags & SID_WBus32) != 0 6820 || cts->type == CTS_TYPE_USER_SETTINGS) 6821 && (cpi->hba_inquiry & PI_WIDE_32) != 0) 6822 break; 6823 /* Fall Through to 16-bit */ 6824 case MSG_EXT_WDTR_BUS_16_BIT: 6825 if (((device->flags & CAM_DEV_INQUIRY_DATA_VALID) == 0 6826 || (inq_data->flags & SID_WBus16) != 0 6827 || cts->type == CTS_TYPE_USER_SETTINGS) 6828 && (cpi->hba_inquiry & PI_WIDE_16) != 0) { 6829 spi->bus_width = MSG_EXT_WDTR_BUS_16_BIT; 6830 break; 6831 } 6832 /* Fall Through to 8-bit */ 6833 default: /* New bus width?? */ 6834 case MSG_EXT_WDTR_BUS_8_BIT: 6835 /* All targets can do this */ 6836 spi->bus_width = MSG_EXT_WDTR_BUS_8_BIT; 6837 break; 6838 } 6839 6840 spi3caps = cpi->xport_specific.spi.ppr_options; 6841 if ((device->flags & CAM_DEV_INQUIRY_DATA_VALID) != 0 6842 && cts->type == CTS_TYPE_CURRENT_SETTINGS) 6843 spi3caps &= inq_data->spi3data; 6844 6845 if ((spi3caps & SID_SPI_CLOCK_DT) == 0) 6846 spi->ppr_options &= ~MSG_EXT_PPR_DT_REQ; 6847 6848 if ((spi3caps & SID_SPI_IUS) == 0) 6849 spi->ppr_options &= ~MSG_EXT_PPR_IU_REQ; 6850 6851 if ((spi3caps & SID_SPI_QAS) == 0) 6852 spi->ppr_options &= ~MSG_EXT_PPR_QAS_REQ; 6853 6854 /* No SPI Transfer settings are allowed unless we are wide */ 6855 if (spi->bus_width == 0) 6856 spi->ppr_options = 0; 6857 6858 if ((spi->valid & CTS_SPI_VALID_DISC) 6859 && ((spi->flags & CTS_SPI_FLAGS_DISC_ENB) == 0)) { 6860 /* 6861 * Can't tag queue without disconnection. 6862 */ 6863 scsi->flags &= ~CTS_SCSI_FLAGS_TAG_ENB; 6864 scsi->valid |= CTS_SCSI_VALID_TQ; 6865 } 6866 6867 /* 6868 * If we are currently performing tagged transactions to 6869 * this device and want to change its negotiation parameters, 6870 * go non-tagged for a bit to give the controller a chance to 6871 * negotiate unhampered by tag messages. 6872 */ 6873 if (cts->type == CTS_TYPE_CURRENT_SETTINGS 6874 && (device->inq_flags & SID_CmdQue) != 0 6875 && (scsi->flags & CTS_SCSI_FLAGS_TAG_ENB) != 0 6876 && (spi->flags & (CTS_SPI_VALID_SYNC_RATE| 6877 CTS_SPI_VALID_SYNC_OFFSET| 6878 CTS_SPI_VALID_BUS_WIDTH)) != 0) 6879 xpt_toggle_tags(cts->ccb_h.path); 6880 } 6881 6882 if (cts->type == CTS_TYPE_CURRENT_SETTINGS 6883 && (scsi->valid & CTS_SCSI_VALID_TQ) != 0) { 6884 int device_tagenb; 6885 6886 /* 6887 * If we are transitioning from tags to no-tags or 6888 * vice-versa, we need to carefully freeze and restart 6889 * the queue so that we don't overlap tagged and non-tagged 6890 * commands. We also temporarily stop tags if there is 6891 * a change in transfer negotiation settings to allow 6892 * "tag-less" negotiation. 6893 */ 6894 if ((device->flags & CAM_DEV_TAG_AFTER_COUNT) != 0 6895 || (device->inq_flags & SID_CmdQue) != 0) 6896 device_tagenb = TRUE; 6897 else 6898 device_tagenb = FALSE; 6899 6900 if (((scsi->flags & CTS_SCSI_FLAGS_TAG_ENB) != 0 6901 && device_tagenb == FALSE) 6902 || ((scsi->flags & CTS_SCSI_FLAGS_TAG_ENB) == 0 6903 && device_tagenb == TRUE)) { 6904 6905 if ((scsi->flags & CTS_SCSI_FLAGS_TAG_ENB) != 0) { 6906 /* 6907 * Delay change to use tags until after a 6908 * few commands have gone to this device so 6909 * the controller has time to perform transfer 6910 * negotiations without tagged messages getting 6911 * in the way. 6912 */ 6913 device->tag_delay_count = CAM_TAG_DELAY_COUNT; 6914 device->flags |= CAM_DEV_TAG_AFTER_COUNT; 6915 } else { 6916 struct ccb_relsim crs; 6917 6918 xpt_freeze_devq(cts->ccb_h.path, /*count*/1); 6919 device->inq_flags &= ~SID_CmdQue; 6920 xpt_dev_ccbq_resize(cts->ccb_h.path, 6921 sim->max_dev_openings); 6922 device->flags &= ~CAM_DEV_TAG_AFTER_COUNT; 6923 device->tag_delay_count = 0; 6924 6925 xpt_setup_ccb(&crs.ccb_h, cts->ccb_h.path, 6926 /*priority*/1); 6927 crs.ccb_h.func_code = XPT_REL_SIMQ; 6928 crs.release_flags = RELSIM_RELEASE_AFTER_QEMPTY; 6929 crs.openings 6930 = crs.release_timeout 6931 = crs.qfrozen_cnt 6932 = 0; 6933 xpt_action((union ccb *)&crs); 6934 } 6935 } 6936 } 6937 if (async_update == FALSE) 6938 (*(sim->sim_action))(sim, (union ccb *)cts); 6939 done: 6940 xpt_free_ccb(&cur_cts->ccb_h); 6941 xpt_free_ccb(&cpi->ccb_h); 6942 } 6943 6944 static void 6945 xpt_toggle_tags(struct cam_path *path) 6946 { 6947 struct cam_ed *dev; 6948 6949 /* 6950 * Give controllers a chance to renegotiate 6951 * before starting tag operations. We 6952 * "toggle" tagged queuing off then on 6953 * which causes the tag enable command delay 6954 * counter to come into effect. 6955 */ 6956 dev = path->device; 6957 if ((dev->flags & CAM_DEV_TAG_AFTER_COUNT) != 0 6958 || ((dev->inq_flags & SID_CmdQue) != 0 6959 && (dev->inq_flags & (SID_Sync|SID_WBus16|SID_WBus32)) != 0)) { 6960 struct ccb_trans_settings *cts; 6961 6962 cts = &xpt_alloc_ccb()->cts; 6963 xpt_setup_ccb(&cts->ccb_h, path, 1); 6964 cts->protocol = PROTO_SCSI; 6965 cts->protocol_version = PROTO_VERSION_UNSPECIFIED; 6966 cts->transport = XPORT_UNSPECIFIED; 6967 cts->transport_version = XPORT_VERSION_UNSPECIFIED; 6968 cts->proto_specific.scsi.flags = 0; 6969 cts->proto_specific.scsi.valid = CTS_SCSI_VALID_TQ; 6970 xpt_set_transfer_settings(cts, path->device, 6971 /*async_update*/TRUE); 6972 cts->proto_specific.scsi.flags = CTS_SCSI_FLAGS_TAG_ENB; 6973 xpt_set_transfer_settings(cts, path->device, 6974 /*async_update*/TRUE); 6975 xpt_free_ccb(&cts->ccb_h); 6976 } 6977 } 6978 6979 static void 6980 xpt_start_tags(struct cam_path *path) 6981 { 6982 struct ccb_relsim *crs; 6983 struct cam_ed *device; 6984 struct cam_sim *sim; 6985 int newopenings; 6986 6987 crs = &xpt_alloc_ccb()->crs; 6988 device = path->device; 6989 sim = path->bus->sim; 6990 device->flags &= ~CAM_DEV_TAG_AFTER_COUNT; 6991 xpt_freeze_devq(path, /*count*/1); 6992 device->inq_flags |= SID_CmdQue; 6993 if (device->tag_saved_openings != 0) 6994 newopenings = device->tag_saved_openings; 6995 else 6996 newopenings = min(device->quirk->maxtags, 6997 sim->max_tagged_dev_openings); 6998 xpt_dev_ccbq_resize(path, newopenings); 6999 xpt_setup_ccb(&crs->ccb_h, path, /*priority*/1); 7000 crs->ccb_h.func_code = XPT_REL_SIMQ; 7001 crs->release_flags = RELSIM_RELEASE_AFTER_QEMPTY; 7002 crs->openings 7003 = crs->release_timeout 7004 = crs->qfrozen_cnt 7005 = 0; 7006 xpt_action((union ccb *)crs); 7007 xpt_free_ccb(&crs->ccb_h); 7008 } 7009 7010 static int busses_to_config; 7011 static int busses_to_reset; 7012 7013 static int 7014 xptconfigbuscountfunc(struct cam_eb *bus, void *arg) 7015 { 7016 sim_lock_assert_owned(bus->sim->lock); 7017 7018 if (bus->counted_to_config == 0 && bus->path_id != CAM_XPT_PATH_ID) { 7019 struct cam_path path; 7020 struct ccb_pathinq *cpi; 7021 int can_negotiate; 7022 7023 if (bootverbose) { 7024 kprintf("CAM: Configuring bus:"); 7025 if (bus->sim) { 7026 kprintf(" %s%d\n", 7027 bus->sim->sim_name, 7028 bus->sim->unit_number); 7029 } else { 7030 kprintf(" (unknown)\n"); 7031 } 7032 } 7033 7034 cpi = &xpt_alloc_ccb()->cpi; 7035 7036 atomic_add_int(&busses_to_config, 1); 7037 bus->counted_to_config = 1; 7038 xpt_compile_path(&path, NULL, bus->path_id, 7039 CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD); 7040 xpt_setup_ccb(&cpi->ccb_h, &path, /*priority*/1); 7041 cpi->ccb_h.func_code = XPT_PATH_INQ; 7042 xpt_action((union ccb *)cpi); 7043 can_negotiate = cpi->hba_inquiry; 7044 can_negotiate &= (PI_WIDE_32|PI_WIDE_16|PI_SDTR_ABLE); 7045 if ((cpi->hba_misc & PIM_NOBUSRESET) == 0 && can_negotiate) 7046 busses_to_reset++; 7047 xpt_release_path(&path); 7048 xpt_free_ccb(&cpi->ccb_h); 7049 } else 7050 if (bus->counted_to_config == 0 && bus->path_id == CAM_XPT_PATH_ID) { 7051 /* this is our dummy periph/bus */ 7052 atomic_add_int(&busses_to_config, 1); 7053 bus->counted_to_config = 1; 7054 } 7055 7056 return(1); 7057 } 7058 7059 static int 7060 xptconfigfunc(struct cam_eb *bus, void *arg) 7061 { 7062 struct cam_path *path; 7063 union ccb *work_ccb; 7064 7065 sim_lock_assert_owned(bus->sim->lock); 7066 7067 if (bus->path_id != CAM_XPT_PATH_ID) { 7068 cam_status status; 7069 int can_negotiate; 7070 7071 work_ccb = xpt_alloc_ccb(); 7072 if ((status = xpt_create_path(&path, xpt_periph, bus->path_id, 7073 CAM_TARGET_WILDCARD, 7074 CAM_LUN_WILDCARD)) !=CAM_REQ_CMP){ 7075 kprintf("xptconfigfunc: xpt_create_path failed with " 7076 "status %#x for bus %d\n", status, bus->path_id); 7077 kprintf("xptconfigfunc: halting bus configuration\n"); 7078 xpt_free_ccb(&work_ccb->ccb_h); 7079 xpt_uncount_bus(bus); 7080 return(0); 7081 } 7082 xpt_setup_ccb(&work_ccb->ccb_h, path, /*priority*/1); 7083 work_ccb->ccb_h.func_code = XPT_PATH_INQ; 7084 xpt_action(work_ccb); 7085 if (work_ccb->ccb_h.status != CAM_REQ_CMP) { 7086 kprintf("xptconfigfunc: CPI failed on bus %d " 7087 "with status %d\n", bus->path_id, 7088 work_ccb->ccb_h.status); 7089 xpt_finishconfig(xpt_periph, work_ccb); 7090 return(1); 7091 } 7092 7093 can_negotiate = work_ccb->cpi.hba_inquiry; 7094 can_negotiate &= (PI_WIDE_32|PI_WIDE_16|PI_SDTR_ABLE); 7095 if ((work_ccb->cpi.hba_misc & PIM_NOBUSRESET) == 0 7096 && (can_negotiate != 0)) { 7097 xpt_setup_ccb(&work_ccb->ccb_h, path, /*priority*/1); 7098 work_ccb->ccb_h.func_code = XPT_RESET_BUS; 7099 work_ccb->ccb_h.cbfcnp = NULL; 7100 CAM_DEBUG(path, CAM_DEBUG_SUBTRACE, 7101 ("Resetting Bus\n")); 7102 xpt_action(work_ccb); 7103 xpt_finishconfig(xpt_periph, work_ccb); 7104 } else { 7105 /* Act as though we performed a successful BUS RESET */ 7106 work_ccb->ccb_h.func_code = XPT_RESET_BUS; 7107 xpt_finishconfig(xpt_periph, work_ccb); 7108 } 7109 } else { 7110 xpt_uncount_bus(bus); 7111 } 7112 7113 return(1); 7114 } 7115 7116 /* 7117 * Now that interrupts are enabled, go find our devices. 7118 * 7119 * This hook function is called once by run_interrupt_driven_config_hooks(). 7120 * XPT is expected to disestablish its hook when done. 7121 */ 7122 static void 7123 xpt_config(void *arg) 7124 { 7125 7126 #ifdef CAMDEBUG 7127 /* Setup debugging flags and path */ 7128 #ifdef CAM_DEBUG_FLAGS 7129 cam_dflags = CAM_DEBUG_FLAGS; 7130 #else /* !CAM_DEBUG_FLAGS */ 7131 cam_dflags = CAM_DEBUG_NONE; 7132 #endif /* CAM_DEBUG_FLAGS */ 7133 #ifdef CAM_DEBUG_BUS 7134 if (cam_dflags != CAM_DEBUG_NONE) { 7135 /* 7136 * Locking is specifically omitted here. No SIMs have 7137 * registered yet, so xpt_create_path will only be searching 7138 * empty lists of targets and devices. 7139 */ 7140 if (xpt_create_path(&cam_dpath, xpt_periph, 7141 CAM_DEBUG_BUS, CAM_DEBUG_TARGET, 7142 CAM_DEBUG_LUN) != CAM_REQ_CMP) { 7143 kprintf("xpt_config: xpt_create_path() failed for debug" 7144 " target %d:%d:%d, debugging disabled\n", 7145 CAM_DEBUG_BUS, CAM_DEBUG_TARGET, CAM_DEBUG_LUN); 7146 cam_dflags = CAM_DEBUG_NONE; 7147 } 7148 } else { 7149 cam_dpath = NULL; 7150 } 7151 #else /* !CAM_DEBUG_BUS */ 7152 cam_dpath = NULL; 7153 #endif /* CAM_DEBUG_BUS */ 7154 #endif /* CAMDEBUG */ 7155 7156 /* 7157 * Scan all installed busses. This will also add a count 7158 * for our dummy placeholder (xpt_periph). 7159 */ 7160 xpt_for_all_busses(xptconfigbuscountfunc, NULL); 7161 7162 kprintf("CAM: Configuring %d busses\n", busses_to_config - 1); 7163 if (busses_to_reset > 0 && scsi_delay >= 2000) { 7164 kprintf("Waiting %d seconds for SCSI " 7165 "devices to settle\n", 7166 scsi_delay/1000); 7167 } 7168 xpt_for_all_busses(xptconfigfunc, NULL); 7169 } 7170 7171 /* 7172 * If the given device only has one peripheral attached to it, and if that 7173 * peripheral is the passthrough driver, announce it. This insures that the 7174 * user sees some sort of announcement for every peripheral in their system. 7175 */ 7176 static int 7177 xptpassannouncefunc(struct cam_ed *device, void *arg) 7178 { 7179 struct cam_periph *periph; 7180 int i; 7181 7182 for (periph = SLIST_FIRST(&device->periphs), i = 0; periph != NULL; 7183 periph = SLIST_NEXT(periph, periph_links), i++); 7184 7185 periph = SLIST_FIRST(&device->periphs); 7186 if ((i == 1) 7187 && (strncmp(periph->periph_name, "pass", 4) == 0)) 7188 xpt_announce_periph(periph, NULL); 7189 7190 return(1); 7191 } 7192 7193 static void 7194 xpt_finishconfig_task(void *context, int pending) 7195 { 7196 struct periph_driver **p_drv; 7197 int i; 7198 7199 kprintf("CAM: finished configuring all busses\n"); 7200 7201 if (busses_to_config == 0) { 7202 /* Register all the peripheral drivers */ 7203 /* XXX This will have to change when we have loadable modules */ 7204 p_drv = periph_drivers; 7205 for (i = 0; p_drv[i] != NULL; i++) { 7206 (*p_drv[i]->init)(); 7207 } 7208 7209 /* 7210 * Check for devices with no "standard" peripheral driver 7211 * attached. For any devices like that, announce the 7212 * passthrough driver so the user will see something. 7213 */ 7214 xpt_for_all_devices(xptpassannouncefunc, NULL); 7215 7216 /* Release our hook so that the boot can continue. */ 7217 config_intrhook_disestablish(xsoftc.xpt_config_hook); 7218 kfree(xsoftc.xpt_config_hook, M_CAMXPT); 7219 xsoftc.xpt_config_hook = NULL; 7220 } 7221 kfree(context, M_CAMXPT); 7222 } 7223 7224 static void 7225 xpt_uncount_bus (struct cam_eb *bus) 7226 { 7227 struct xpt_task *task; 7228 7229 if (bus->counted_to_config) { 7230 bus->counted_to_config = 0; 7231 if (atomic_fetchadd_int(&busses_to_config, -1) == 1) { 7232 task = kmalloc(sizeof(struct xpt_task), M_CAMXPT, 7233 M_INTWAIT | M_ZERO); 7234 TASK_INIT(&task->task, 0, xpt_finishconfig_task, task); 7235 taskqueue_enqueue(taskqueue_thread[mycpuid], 7236 &task->task); 7237 } 7238 } 7239 } 7240 7241 static void 7242 xpt_finishconfig(struct cam_periph *periph, union ccb *done_ccb) 7243 { 7244 struct cam_path *path; 7245 7246 path = done_ccb->ccb_h.path; 7247 CAM_DEBUG(path, CAM_DEBUG_TRACE, ("xpt_finishconfig\n")); 7248 7249 switch(done_ccb->ccb_h.func_code) { 7250 case XPT_RESET_BUS: 7251 if (done_ccb->ccb_h.status == CAM_REQ_CMP) { 7252 done_ccb->ccb_h.func_code = XPT_SCAN_BUS; 7253 done_ccb->ccb_h.cbfcnp = xpt_finishconfig; 7254 done_ccb->crcn.flags = 0; 7255 xpt_action(done_ccb); 7256 return; 7257 } 7258 /* FALLTHROUGH */ 7259 case XPT_SCAN_BUS: 7260 default: 7261 if (bootverbose) { 7262 kprintf("CAM: Finished configuring bus:"); 7263 if (path->bus->sim) { 7264 kprintf(" %s%d\n", 7265 path->bus->sim->sim_name, 7266 path->bus->sim->unit_number); 7267 } else { 7268 kprintf(" (unknown)\n"); 7269 } 7270 } 7271 xpt_uncount_bus(path->bus); 7272 xpt_free_path(path); 7273 xpt_free_ccb(&done_ccb->ccb_h); 7274 break; 7275 } 7276 } 7277 7278 cam_status 7279 xpt_register_async(int event, ac_callback_t *cbfunc, void *cbarg, 7280 struct cam_path *path) 7281 { 7282 struct ccb_setasync *csa; 7283 cam_status status; 7284 int xptpath = 0; 7285 7286 if (path == NULL) { 7287 lockmgr(&xsoftc.xpt_lock, LK_EXCLUSIVE); 7288 status = xpt_create_path(&path, /*periph*/NULL, CAM_XPT_PATH_ID, 7289 CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD); 7290 if (status != CAM_REQ_CMP) { 7291 lockmgr(&xsoftc.xpt_lock, LK_RELEASE); 7292 return (status); 7293 } 7294 xptpath = 1; 7295 } 7296 7297 csa = &xpt_alloc_ccb()->csa; 7298 xpt_setup_ccb(&csa->ccb_h, path, /*priority*/5); 7299 csa->ccb_h.func_code = XPT_SASYNC_CB; 7300 csa->event_enable = event; 7301 csa->callback = cbfunc; 7302 csa->callback_arg = cbarg; 7303 xpt_action((union ccb *)csa); 7304 status = csa->ccb_h.status; 7305 if (xptpath) { 7306 xpt_free_path(path); 7307 lockmgr(&xsoftc.xpt_lock, LK_RELEASE); 7308 } 7309 xpt_free_ccb(&csa->ccb_h); 7310 7311 return (status); 7312 } 7313 7314 static void 7315 xptaction(struct cam_sim *sim, union ccb *work_ccb) 7316 { 7317 CAM_DEBUG(work_ccb->ccb_h.path, CAM_DEBUG_TRACE, ("xptaction\n")); 7318 7319 switch (work_ccb->ccb_h.func_code) { 7320 /* Common cases first */ 7321 case XPT_PATH_INQ: /* Path routing inquiry */ 7322 { 7323 struct ccb_pathinq *cpi; 7324 7325 cpi = &work_ccb->cpi; 7326 cpi->version_num = 1; /* XXX??? */ 7327 cpi->hba_inquiry = 0; 7328 cpi->target_sprt = 0; 7329 cpi->hba_misc = 0; 7330 cpi->hba_eng_cnt = 0; 7331 cpi->max_target = 0; 7332 cpi->max_lun = 0; 7333 cpi->initiator_id = 0; 7334 strncpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN); 7335 strncpy(cpi->hba_vid, "", HBA_IDLEN); 7336 strncpy(cpi->dev_name, sim->sim_name, DEV_IDLEN); 7337 cpi->unit_number = sim->unit_number; 7338 cpi->bus_id = sim->bus_id; 7339 cpi->base_transfer_speed = 0; 7340 cpi->protocol = PROTO_UNSPECIFIED; 7341 cpi->protocol_version = PROTO_VERSION_UNSPECIFIED; 7342 cpi->transport = XPORT_UNSPECIFIED; 7343 cpi->transport_version = XPORT_VERSION_UNSPECIFIED; 7344 cpi->ccb_h.status = CAM_REQ_CMP; 7345 xpt_done(work_ccb); 7346 break; 7347 } 7348 default: 7349 work_ccb->ccb_h.status = CAM_REQ_INVALID; 7350 xpt_done(work_ccb); 7351 break; 7352 } 7353 } 7354 7355 /* 7356 * The xpt as a "controller" has no interrupt sources, so polling 7357 * is a no-op. 7358 */ 7359 static void 7360 xptpoll(struct cam_sim *sim) 7361 { 7362 } 7363 7364 void 7365 xpt_lock_buses(void) 7366 { 7367 lockmgr(&xsoftc.xpt_topo_lock, LK_EXCLUSIVE); 7368 } 7369 7370 void 7371 xpt_unlock_buses(void) 7372 { 7373 lockmgr(&xsoftc.xpt_topo_lock, LK_RELEASE); 7374 } 7375 7376 7377 /* 7378 * Should only be called by the machine interrupt dispatch routines, 7379 * so put these prototypes here instead of in the header. 7380 */ 7381 7382 static void 7383 swi_cambio(void *arg, void *frame) 7384 { 7385 camisr(NULL); 7386 } 7387 7388 static void 7389 camisr(void *dummy) 7390 { 7391 cam_simq_t queue; 7392 struct cam_sim *sim; 7393 7394 spin_lock(&cam_simq_spin); 7395 TAILQ_INIT(&queue); 7396 TAILQ_CONCAT(&queue, &cam_simq, links); 7397 spin_unlock(&cam_simq_spin); 7398 7399 while ((sim = TAILQ_FIRST(&queue)) != NULL) { 7400 TAILQ_REMOVE(&queue, sim, links); 7401 CAM_SIM_LOCK(sim); 7402 sim->flags &= ~CAM_SIM_ON_DONEQ; 7403 camisr_runqueue(sim); 7404 CAM_SIM_UNLOCK(sim); 7405 } 7406 } 7407 7408 static void 7409 camisr_runqueue(struct cam_sim *sim) 7410 { 7411 struct ccb_hdr *ccb_h; 7412 int runq; 7413 7414 spin_lock(&sim->sim_spin); 7415 while ((ccb_h = TAILQ_FIRST(&sim->sim_doneq)) != NULL) { 7416 TAILQ_REMOVE(&sim->sim_doneq, ccb_h, sim_links.tqe); 7417 spin_unlock(&sim->sim_spin); 7418 ccb_h->pinfo.index = CAM_UNQUEUED_INDEX; 7419 7420 CAM_DEBUG(ccb_h->path, CAM_DEBUG_TRACE, 7421 ("camisr\n")); 7422 7423 runq = FALSE; 7424 7425 if (ccb_h->flags & CAM_HIGH_POWER) { 7426 struct highpowerlist *hphead; 7427 union ccb *send_ccb; 7428 7429 lockmgr(&xsoftc.xpt_lock, LK_EXCLUSIVE); 7430 hphead = &xsoftc.highpowerq; 7431 7432 send_ccb = (union ccb *)STAILQ_FIRST(hphead); 7433 7434 /* 7435 * Increment the count since this command is done. 7436 */ 7437 xsoftc.num_highpower++; 7438 7439 /* 7440 * Any high powered commands queued up? 7441 */ 7442 if (send_ccb != NULL) { 7443 STAILQ_REMOVE_HEAD(hphead, xpt_links.stqe); 7444 lockmgr(&xsoftc.xpt_lock, LK_RELEASE); 7445 7446 xpt_release_devq(send_ccb->ccb_h.path, 7447 /*count*/1, /*runqueue*/TRUE); 7448 } else 7449 lockmgr(&xsoftc.xpt_lock, LK_RELEASE); 7450 } 7451 7452 if ((ccb_h->func_code & XPT_FC_USER_CCB) == 0) { 7453 struct cam_ed *dev; 7454 7455 dev = ccb_h->path->device; 7456 7457 cam_ccbq_ccb_done(&dev->ccbq, (union ccb *)ccb_h); 7458 7459 /* 7460 * devq may be NULL if this is cam_dead_sim 7461 */ 7462 if (ccb_h->path->bus->sim->devq) { 7463 ccb_h->path->bus->sim->devq->send_active--; 7464 ccb_h->path->bus->sim->devq->send_openings++; 7465 } 7466 7467 if (((dev->flags & CAM_DEV_REL_ON_COMPLETE) != 0 7468 && (ccb_h->status&CAM_STATUS_MASK) != CAM_REQUEUE_REQ) 7469 || ((dev->flags & CAM_DEV_REL_ON_QUEUE_EMPTY) != 0 7470 && (dev->ccbq.dev_active == 0))) { 7471 7472 xpt_release_devq(ccb_h->path, /*count*/1, 7473 /*run_queue*/TRUE); 7474 } 7475 7476 if ((dev->flags & CAM_DEV_TAG_AFTER_COUNT) != 0 7477 && (--dev->tag_delay_count == 0)) 7478 xpt_start_tags(ccb_h->path); 7479 7480 if ((dev->ccbq.queue.entries > 0) 7481 && (dev->qfrozen_cnt == 0) 7482 && (device_is_send_queued(dev) == 0)) { 7483 runq = xpt_schedule_dev_sendq(ccb_h->path->bus, 7484 dev); 7485 } 7486 } 7487 7488 if (ccb_h->status & CAM_RELEASE_SIMQ) { 7489 xpt_release_simq(ccb_h->path->bus->sim, 7490 /*run_queue*/TRUE); 7491 ccb_h->status &= ~CAM_RELEASE_SIMQ; 7492 runq = FALSE; 7493 } 7494 7495 if ((ccb_h->flags & CAM_DEV_QFRZDIS) 7496 && (ccb_h->status & CAM_DEV_QFRZN)) { 7497 xpt_release_devq(ccb_h->path, /*count*/1, 7498 /*run_queue*/TRUE); 7499 ccb_h->status &= ~CAM_DEV_QFRZN; 7500 } else if (runq) { 7501 xpt_run_dev_sendq(ccb_h->path->bus); 7502 } 7503 7504 /* Call the peripheral driver's callback */ 7505 (*ccb_h->cbfcnp)(ccb_h->path->periph, (union ccb *)ccb_h); 7506 spin_lock(&sim->sim_spin); 7507 } 7508 spin_unlock(&sim->sim_spin); 7509 } 7510 7511 /* 7512 * The dead_sim isn't completely hooked into CAM, we have to make sure 7513 * the doneq is cleared after calling xpt_done() so cam_periph_ccbwait() 7514 * doesn't block. 7515 */ 7516 static void 7517 dead_sim_action(struct cam_sim *sim, union ccb *ccb) 7518 { 7519 7520 ccb->ccb_h.status = CAM_DEV_NOT_THERE; 7521 xpt_done(ccb); 7522 camisr_runqueue(sim); 7523 } 7524 7525 static void 7526 dead_sim_poll(struct cam_sim *sim) 7527 { 7528 } 7529