drivers/scsi/libsas/sas_discover.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Serial Attached SCSI (SAS) Discover process
   4  *
   5  * Copyright (C) 2005 Adaptec, Inc.  All rights reserved.
   6  * Copyright (C) 2005 Luben Tuikov <luben_tuikov@adaptec.com>
   7  */
   8
   9 #include <linux/scatterlist.h>
  10 #include <linux/slab.h>
  11 #include <linux/async.h>
  12 #include <scsi/scsi_host.h>
  13 #include <scsi/scsi_eh.h>
  14 #include "sas_internal.h"
  15
  16 #include <scsi/scsi_transport.h>
  17 #include <scsi/scsi_transport_sas.h>
  18 #include <scsi/sas_ata.h>
  19 #include "../scsi_sas_internal.h"
  20
  21 /* ---------- Basic task processing for discovery purposes ---------- */
  22
  23 void sas_init_dev(struct domain_device *dev)
  24 {
  25         switch (dev->dev_type) {
  26         case SAS_END_DEVICE:
  27                 INIT_LIST_HEAD(&dev->ssp_dev.eh_list_node);
  28                 break;
  29         case SAS_EDGE_EXPANDER_DEVICE:
  30         case SAS_FANOUT_EXPANDER_DEVICE:
  31                 INIT_LIST_HEAD(&dev->ex_dev.children);
  32                 mutex_init(&dev->ex_dev.cmd_mutex);
  33                 break;
  34         default:
  35                 break;
  36         }
  37 }
  38
  39 /* ---------- Domain device discovery ---------- */
  40
  41 /**
  42  * sas_get_port_device - Discover devices which caused port creation
  43  * @port: pointer to struct sas_port of interest
  44  *
  45  * Devices directly attached to a HA port, have no parent.  This is
  46  * how we know they are (domain) "root" devices.  All other devices
  47  * do, and should have their "parent" pointer set appropriately as
  48  * soon as a child device is discovered.
  49  */
  50 static int sas_get_port_device(struct asd_sas_port *port)
  51 {
  52         struct asd_sas_phy *phy;
  53         struct sas_rphy *rphy;
  54         struct domain_device *dev;
  55         int rc = -ENODEV;
  56
  57         dev = sas_alloc_device();
  58         if (!dev)
  59                 return -ENOMEM;
  60
  61         spin_lock_irq(&port->phy_list_lock);
  62         if (list_empty(&port->phy_list)) {
  63                 spin_unlock_irq(&port->phy_list_lock);
  64                 sas_put_device(dev);
  65                 return -ENODEV;
  66         }
  67         phy = container_of(port->phy_list.next, struct asd_sas_phy, port_phy_el);
  68         spin_lock(&phy->frame_rcvd_lock);
  69         memcpy(dev->frame_rcvd, phy->frame_rcvd, min(sizeof(dev->frame_rcvd),
  70                                              (size_t)phy->frame_rcvd_size));
  71         spin_unlock(&phy->frame_rcvd_lock);
  72         spin_unlock_irq(&port->phy_list_lock);
  73
  74         if (dev->frame_rcvd[0] == 0x34 && port->oob_mode == SATA_OOB_MODE) {
  75                 struct dev_to_host_fis *fis =
  76                         (struct dev_to_host_fis *) dev->frame_rcvd;
  77                 if (fis->interrupt_reason == 1 && fis->lbal == 1 &&
  78                     fis->byte_count_low==0x69 && fis->byte_count_high == 0x96
  79                     && (fis->device & ~0x10) == 0)
  80                         dev->dev_type = SAS_SATA_PM;
  81                 else
  82                         dev->dev_type = SAS_SATA_DEV;
  83                 dev->tproto = SAS_PROTOCOL_SATA;
  84         } else {
  85                 struct sas_identify_frame *id =
  86                         (struct sas_identify_frame *) dev->frame_rcvd;
  87                 dev->dev_type = id->dev_type;
  88                 dev->iproto = id->initiator_bits;
  89                 dev->tproto = id->target_bits;
  90         }
  91
  92         sas_init_dev(dev);
  93
  94         dev->port = port;
  95         switch (dev->dev_type) {
  96         case SAS_SATA_DEV:
  97                 rc = sas_ata_init(dev);
  98                 if (rc) {
  99                         rphy = NULL;
 100                         break;
 101                 }
 102                 /* fall through */
 103         case SAS_END_DEVICE:
 104                 rphy = sas_end_device_alloc(port->port);
 105                 break;
 106         case SAS_EDGE_EXPANDER_DEVICE:
 107                 rphy = sas_expander_alloc(port->port,
 108                                           SAS_EDGE_EXPANDER_DEVICE);
 109                 break;
 110         case SAS_FANOUT_EXPANDER_DEVICE:
 111                 rphy = sas_expander_alloc(port->port,
 112                                           SAS_FANOUT_EXPANDER_DEVICE);
 113                 break;
 114         default:
 115                 pr_warn("ERROR: Unidentified device type %d\n", dev->dev_type);
 116                 rphy = NULL;
 117                 break;
 118         }
 119
 120         if (!rphy) {
 121                 sas_put_device(dev);
 122                 return rc;
 123         }
 124
 125         rphy->identify.phy_identifier = phy->phy->identify.phy_identifier;
 126         memcpy(dev->sas_addr, port->attached_sas_addr, SAS_ADDR_SIZE);
 127         sas_fill_in_rphy(dev, rphy);
 128         sas_hash_addr(dev->hashed_sas_addr, dev->sas_addr);
 129         port->port_dev = dev;
 130         dev->linkrate = port->linkrate;
 131         dev->min_linkrate = port->linkrate;
 132         dev->max_linkrate = port->linkrate;
 133         dev->pathways = port->num_phys;
 134         memset(port->disc.fanout_sas_addr, 0, SAS_ADDR_SIZE);
 135         memset(port->disc.eeds_a, 0, SAS_ADDR_SIZE);
 136         memset(port->disc.eeds_b, 0, SAS_ADDR_SIZE);
 137         port->disc.max_level = 0;
 138         sas_device_set_phy(dev, port->port);
 139
 140         dev->rphy = rphy;
 141         get_device(&dev->rphy->dev);
 142
 143         if (dev_is_sata(dev) || dev->dev_type == SAS_END_DEVICE)
 144                 list_add_tail(&dev->disco_list_node, &port->disco_list);
 145         else {
 146                 spin_lock_irq(&port->dev_list_lock);
 147                 list_add_tail(&dev->dev_list_node, &port->dev_list);
 148                 spin_unlock_irq(&port->dev_list_lock);
 149         }
 150
 151         spin_lock_irq(&port->phy_list_lock);
 152         list_for_each_entry(phy, &port->phy_list, port_phy_el)
 153                 sas_phy_set_target(phy, dev);
 154         spin_unlock_irq(&port->phy_list_lock);
 155
 156         return 0;
 157 }
 158
 159 /* ---------- Discover and Revalidate ---------- */
 160
 161 int sas_notify_lldd_dev_found(struct domain_device *dev)
 162 {
 163         int res = 0;
 164         struct sas_ha_struct *sas_ha = dev->port->ha;
 165         struct Scsi_Host *shost = sas_ha->core.shost;
 166         struct sas_internal *i = to_sas_internal(shost->transportt);
 167
 168         if (!i->dft->lldd_dev_found)
 169                 return 0;
 170
 171         res = i->dft->lldd_dev_found(dev);
 172         if (res) {
 173                 pr_warn("driver on host %s cannot handle device %llx, error:%d\n",
 174                         dev_name(sas_ha->dev),
 175                         SAS_ADDR(dev->sas_addr), res);
 176         }
 177         set_bit(SAS_DEV_FOUND, &dev->state);
 178         kref_get(&dev->kref);
 179         return res;
 180 }
 181
 182
 183 void sas_notify_lldd_dev_gone(struct domain_device *dev)
 184 {
 185         struct sas_ha_struct *sas_ha = dev->port->ha;
 186         struct Scsi_Host *shost = sas_ha->core.shost;
 187         struct sas_internal *i = to_sas_internal(shost->transportt);
 188
 189         if (!i->dft->lldd_dev_gone)
 190                 return;
 191
 192         if (test_and_clear_bit(SAS_DEV_FOUND, &dev->state)) {
 193                 i->dft->lldd_dev_gone(dev);
 194                 sas_put_device(dev);
 195         }
 196 }
 197
 198 static void sas_probe_devices(struct asd_sas_port *port)
 199 {
 200         struct domain_device *dev, *n;
 201
 202         /* devices must be domain members before link recovery and probe */
 203         list_for_each_entry(dev, &port->disco_list, disco_list_node) {
 204                 spin_lock_irq(&port->dev_list_lock);
 205                 list_add_tail(&dev->dev_list_node, &port->dev_list);
 206                 spin_unlock_irq(&port->dev_list_lock);
 207         }
 208
 209         sas_probe_sata(port);
 210
 211         list_for_each_entry_safe(dev, n, &port->disco_list, disco_list_node) {
 212                 int err;
 213
 214                 err = sas_rphy_add(dev->rphy);
 215                 if (err)
 216                         sas_fail_probe(dev, __func__, err);
 217                 else
 218                         list_del_init(&dev->disco_list_node);
 219         }
 220 }
 221
 222 static void sas_suspend_devices(struct work_struct *work)
 223 {
 224         struct asd_sas_phy *phy;
 225         struct domain_device *dev;
 226         struct sas_discovery_event *ev = to_sas_discovery_event(work);
 227         struct asd_sas_port *port = ev->port;
 228         struct Scsi_Host *shost = port->ha->core.shost;
 229         struct sas_internal *si = to_sas_internal(shost->transportt);
 230
 231         clear_bit(DISCE_SUSPEND, &port->disc.pending);
 232
 233         sas_suspend_sata(port);
 234
 235         /* lldd is free to forget the domain_device across the
 236          * suspension, we force the issue here to keep the reference
 237          * counts aligned
 238          */
 239         list_for_each_entry(dev, &port->dev_list, dev_list_node)
 240                 sas_notify_lldd_dev_gone(dev);
 241
 242         /* we are suspending, so we know events are disabled and
 243          * phy_list is not being mutated
 244          */
 245         list_for_each_entry(phy, &port->phy_list, port_phy_el) {
 246                 if (si->dft->lldd_port_deformed)
 247                         si->dft->lldd_port_deformed(phy);
 248                 phy->suspended = 1;
 249                 port->suspended = 1;
 250         }
 251 }
 252
 253 static void sas_resume_devices(struct work_struct *work)
 254 {
 255         struct sas_discovery_event *ev = to_sas_discovery_event(work);
 256         struct asd_sas_port *port = ev->port;
 257
 258         clear_bit(DISCE_RESUME, &port->disc.pending);
 259
 260         sas_resume_sata(port);
 261 }
 262
 263 /**
 264  * sas_discover_end_dev - discover an end device (SSP, etc)
 265  * @dev: pointer to domain device of interest
 266  *
 267  * See comment in sas_discover_sata().
 268  */
 269 int sas_discover_end_dev(struct domain_device *dev)
 270 {
 271         int res;
 272
 273         res = sas_notify_lldd_dev_found(dev);
 274         if (res)
 275                 return res;
 276
 277         return 0;
 278 }
 279
 280 /* ---------- Device registration and unregistration ---------- */
 281
 282 void sas_free_device(struct kref *kref)
 283 {
 284         struct domain_device *dev = container_of(kref, typeof(*dev), kref);
 285
 286         put_device(&dev->rphy->dev);
 287         dev->rphy = NULL;
 288
 289         if (dev->parent)
 290                 sas_put_device(dev->parent);
 291
 292         sas_port_put_phy(dev->phy);
 293         dev->phy = NULL;
 294
 295         /* remove the phys and ports, everything else should be gone */
 296         if (dev_is_expander(dev->dev_type))
 297                 kfree(dev->ex_dev.ex_phy);
 298
 299         if (dev_is_sata(dev) && dev->sata_dev.ap) {
 300                 ata_sas_tport_delete(dev->sata_dev.ap);
 301                 ata_sas_port_destroy(dev->sata_dev.ap);
 302                 ata_host_put(dev->sata_dev.ata_host);
 303                 dev->sata_dev.ata_host = NULL;
 304                 dev->sata_dev.ap = NULL;
 305         }
 306
 307         kfree(dev);
 308 }
 309
 310 static void sas_unregister_common_dev(struct asd_sas_port *port, struct domain_device *dev)
 311 {
 312         struct sas_ha_struct *ha = port->ha;
 313
 314         sas_notify_lldd_dev_gone(dev);
 315         if (!dev->parent)
 316                 dev->port->port_dev = NULL;
 317         else
 318                 list_del_init(&dev->siblings);
 319
 320         spin_lock_irq(&port->dev_list_lock);
 321         list_del_init(&dev->dev_list_node);
 322         if (dev_is_sata(dev))
 323                 sas_ata_end_eh(dev->sata_dev.ap);
 324         spin_unlock_irq(&port->dev_list_lock);
 325
 326         spin_lock_irq(&ha->lock);
 327         if (dev->dev_type == SAS_END_DEVICE &&
 328             !list_empty(&dev->ssp_dev.eh_list_node)) {
 329                 list_del_init(&dev->ssp_dev.eh_list_node);
 330                 ha->eh_active--;
 331         }
 332         spin_unlock_irq(&ha->lock);
 333
 334         sas_put_device(dev);
 335 }
 336
 337 void sas_destruct_devices(struct asd_sas_port *port)
 338 {
 339         struct domain_device *dev, *n;
 340
 341         list_for_each_entry_safe(dev, n, &port->destroy_list, disco_list_node) {
 342                 list_del_init(&dev->disco_list_node);
 343
 344                 sas_remove_children(&dev->rphy->dev);
 345                 sas_rphy_delete(dev->rphy);
 346                 sas_unregister_common_dev(port, dev);
 347         }
 348 }
 349
 350 static void sas_destruct_ports(struct asd_sas_port *port)
 351 {
 352         struct sas_port *sas_port, *p;
 353
 354         list_for_each_entry_safe(sas_port, p, &port->sas_port_del_list, del_list) {
 355                 list_del_init(&sas_port->del_list);
 356                 sas_port_delete(sas_port);
 357         }
 358 }
 359
 360 void sas_unregister_dev(struct asd_sas_port *port, struct domain_device *dev)
 361 {
 362         if (!test_bit(SAS_DEV_DESTROY, &dev->state) &&
 363             !list_empty(&dev->disco_list_node)) {
 364                 /* this rphy never saw sas_rphy_add */
 365                 list_del_init(&dev->disco_list_node);
 366                 sas_rphy_free(dev->rphy);
 367                 sas_unregister_common_dev(port, dev);
 368                 return;
 369         }
 370
 371         if (!test_and_set_bit(SAS_DEV_DESTROY, &dev->state)) {
 372                 sas_rphy_unlink(dev->rphy);
 373                 list_move_tail(&dev->disco_list_node, &port->destroy_list);
 374         }
 375 }
 376
 377 void sas_unregister_domain_devices(struct asd_sas_port *port, int gone)
 378 {
 379         struct domain_device *dev, *n;
 380
 381         list_for_each_entry_safe_reverse(dev, n, &port->dev_list, dev_list_node) {
 382                 if (gone)
 383                         set_bit(SAS_DEV_GONE, &dev->state);
 384                 sas_unregister_dev(port, dev);
 385         }
 386
 387         list_for_each_entry_safe(dev, n, &port->disco_list, disco_list_node)
 388                 sas_unregister_dev(port, dev);
 389
 390         port->port->rphy = NULL;
 391
 392 }
 393
 394 void sas_device_set_phy(struct domain_device *dev, struct sas_port *port)
 395 {
 396         struct sas_ha_struct *ha;
 397         struct sas_phy *new_phy;
 398
 399         if (!dev)
 400                 return;
 401
 402         ha = dev->port->ha;
 403         new_phy = sas_port_get_phy(port);
 404
 405         /* pin and record last seen phy */
 406         spin_lock_irq(&ha->phy_port_lock);
 407         if (new_phy) {
 408                 sas_port_put_phy(dev->phy);
 409                 dev->phy = new_phy;
 410         }
 411         spin_unlock_irq(&ha->phy_port_lock);
 412 }
 413
 414 /* ---------- Discovery and Revalidation ---------- */
 415
 416 /**
 417  * sas_discover_domain - discover the domain
 418  * @work: work structure embedded in port domain device.
 419  *
 420  * NOTE: this process _must_ quit (return) as soon as any connection
 421  * errors are encountered.  Connection recovery is done elsewhere.
 422  * Discover process only interrogates devices in order to discover the
 423  * domain.
 424  */
 425 static void sas_discover_domain(struct work_struct *work)
 426 {
 427         struct domain_device *dev;
 428         int error = 0;
 429         struct sas_discovery_event *ev = to_sas_discovery_event(work);
 430         struct asd_sas_port *port = ev->port;
 431
 432         clear_bit(DISCE_DISCOVER_DOMAIN, &port->disc.pending);
 433
 434         if (port->port_dev)
 435                 return;
 436
 437         error = sas_get_port_device(port);
 438         if (error)
 439                 return;
 440         dev = port->port_dev;
 441
 442         pr_debug("DOING DISCOVERY on port %d, pid:%d\n", port->id,
 443                  task_pid_nr(current));
 444
 445         switch (dev->dev_type) {
 446         case SAS_END_DEVICE:
 447                 error = sas_discover_end_dev(dev);
 448                 break;
 449         case SAS_EDGE_EXPANDER_DEVICE:
 450         case SAS_FANOUT_EXPANDER_DEVICE:
 451                 error = sas_discover_root_expander(dev);
 452                 break;
 453         case SAS_SATA_DEV:
 454         case SAS_SATA_PM:
 455 #ifdef CONFIG_SCSI_SAS_ATA
 456                 error = sas_discover_sata(dev);
 457                 break;
 458 #else
 459                 pr_notice("ATA device seen but CONFIG_SCSI_SAS_ATA=N so cannot attach\n");
 460                 /* Fall through */
 461 #endif
 462                 /* Fall through - only for the #else condition above. */
 463         default:
 464                 error = -ENXIO;
 465                 pr_err("unhandled device %d\n", dev->dev_type);
 466                 break;
 467         }
 468
 469         if (error) {
 470                 sas_rphy_free(dev->rphy);
 471                 list_del_init(&dev->disco_list_node);
 472                 spin_lock_irq(&port->dev_list_lock);
 473                 list_del_init(&dev->dev_list_node);
 474                 spin_unlock_irq(&port->dev_list_lock);
 475
 476                 sas_put_device(dev);
 477                 port->port_dev = NULL;
 478         }
 479
 480         sas_probe_devices(port);
 481
 482         pr_debug("DONE DISCOVERY on port %d, pid:%d, result:%d\n", port->id,
 483                  task_pid_nr(current), error);
 484 }
 485
 486 static void sas_revalidate_domain(struct work_struct *work)
 487 {
 488         int res = 0;
 489         struct sas_discovery_event *ev = to_sas_discovery_event(work);
 490         struct asd_sas_port *port = ev->port;
 491         struct sas_ha_struct *ha = port->ha;
 492         struct domain_device *ddev = port->port_dev;
 493
 494         /* prevent revalidation from finding sata links in recovery */
 495         mutex_lock(&ha->disco_mutex);
 496         if (test_bit(SAS_HA_ATA_EH_ACTIVE, &ha->state)) {
 497                 pr_debug("REVALIDATION DEFERRED on port %d, pid:%d\n",
 498                          port->id, task_pid_nr(current));
 499                 goto out;
 500         }
 501
 502         clear_bit(DISCE_REVALIDATE_DOMAIN, &port->disc.pending);
 503
 504         pr_debug("REVALIDATING DOMAIN on port %d, pid:%d\n", port->id,
 505                  task_pid_nr(current));
 506
 507         if (ddev && dev_is_expander(ddev->dev_type))
 508                 res = sas_ex_revalidate_domain(ddev);
 509
 510         pr_debug("done REVALIDATING DOMAIN on port %d, pid:%d, res 0x%x\n",
 511                  port->id, task_pid_nr(current), res);
 512  out:
 513         mutex_unlock(&ha->disco_mutex);
 514
 515         sas_destruct_devices(port);
 516         sas_destruct_ports(port);
 517         sas_probe_devices(port);
 518 }
 519
 520 /* ---------- Events ---------- */
 521
 522 static void sas_chain_work(struct sas_ha_struct *ha, struct sas_work *sw)
 523 {
 524         /* chained work is not subject to SA_HA_DRAINING or
 525          * SAS_HA_REGISTERED, because it is either submitted in the
 526          * workqueue, or known to be submitted from a context that is
 527          * not racing against draining
 528          */
 529         queue_work(ha->disco_q, &sw->work);
 530 }
 531
 532 static void sas_chain_event(int event, unsigned long *pending,
 533                             struct sas_work *sw,
 534                             struct sas_ha_struct *ha)
 535 {
 536         if (!test_and_set_bit(event, pending)) {
 537                 unsigned long flags;
 538
 539                 spin_lock_irqsave(&ha->lock, flags);
 540                 sas_chain_work(ha, sw);
 541                 spin_unlock_irqrestore(&ha->lock, flags);
 542         }
 543 }
 544
 545 int sas_discover_event(struct asd_sas_port *port, enum discover_event ev)
 546 {
 547         struct sas_discovery *disc;
 548
 549         if (!port)
 550                 return 0;
 551         disc = &port->disc;
 552
 553         BUG_ON(ev >= DISC_NUM_EVENTS);
 554
 555         sas_chain_event(ev, &disc->pending, &disc->disc_work[ev].work, port->ha);
 556
 557         return 0;
 558 }
 559
 560 /**
 561  * sas_init_disc - initialize the discovery struct in the port
 562  * @disc: port discovery structure
 563  * @port: pointer to struct port
 564  *
 565  * Called when the ports are being initialized.
 566  */
 567 void sas_init_disc(struct sas_discovery *disc, struct asd_sas_port *port)
 568 {
 569         int i;
 570
 571         static const work_func_t sas_event_fns[DISC_NUM_EVENTS] = {
 572                 [DISCE_DISCOVER_DOMAIN] = sas_discover_domain,
 573                 [DISCE_REVALIDATE_DOMAIN] = sas_revalidate_domain,
 574                 [DISCE_SUSPEND] = sas_suspend_devices,
 575                 [DISCE_RESUME] = sas_resume_devices,
 576         };
 577
 578         disc->pending = 0;
 579         for (i = 0; i < DISC_NUM_EVENTS; i++) {
 580                 INIT_SAS_WORK(&disc->disc_work[i].work, sas_event_fns[i]);
 581                 disc->disc_work[i].port = port;
 582         }
 583 }