drivers/scsi/libsas/sas_event.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Serial Attached SCSI (SAS) Event processing
   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/export.h>
  10 #include <scsi/scsi_host.h>
  11 #include "sas_internal.h"
  12
  13 bool sas_queue_work(struct sas_ha_struct *ha, struct sas_work *sw)
  14 {
  15         if (!test_bit(SAS_HA_REGISTERED, &ha->state))
  16                 return false;
  17
  18         if (test_bit(SAS_HA_DRAINING, &ha->state)) {
  19                 /* add it to the defer list, if not already pending */
  20                 if (list_empty(&sw->drain_node))
  21                         list_add_tail(&sw->drain_node, &ha->defer_q);
  22                 return true;
  23         }
  24
  25         return queue_work(ha->event_q, &sw->work);
  26 }
  27
  28 static bool sas_queue_event(int event, struct sas_work *work,
  29                             struct sas_ha_struct *ha)
  30 {
  31         unsigned long flags;
  32         bool rc;
  33
  34         spin_lock_irqsave(&ha->lock, flags);
  35         rc = sas_queue_work(ha, work);
  36         spin_unlock_irqrestore(&ha->lock, flags);
  37
  38         return rc;
  39 }
  40
  41 void sas_queue_deferred_work(struct sas_ha_struct *ha)
  42 {
  43         struct sas_work *sw, *_sw;
  44
  45         spin_lock_irq(&ha->lock);
  46         list_for_each_entry_safe(sw, _sw, &ha->defer_q, drain_node) {
  47                 list_del_init(&sw->drain_node);
  48
  49                 if (!sas_queue_work(ha, sw)) {
  50                         pm_runtime_put(ha->dev);
  51                         sas_free_event(to_asd_sas_event(&sw->work));
  52                 }
  53         }
  54         spin_unlock_irq(&ha->lock);
  55 }
  56
  57 void __sas_drain_work(struct sas_ha_struct *ha)
  58 {
  59         set_bit(SAS_HA_DRAINING, &ha->state);
  60         /* flush submitters */
  61         spin_lock_irq(&ha->lock);
  62         spin_unlock_irq(&ha->lock);
  63
  64         drain_workqueue(ha->event_q);
  65         drain_workqueue(ha->disco_q);
  66
  67         clear_bit(SAS_HA_DRAINING, &ha->state);
  68         sas_queue_deferred_work(ha);
  69 }
  70
  71 int sas_drain_work(struct sas_ha_struct *ha)
  72 {
  73         int err;
  74
  75         err = mutex_lock_interruptible(&ha->drain_mutex);
  76         if (err)
  77                 return err;
  78         if (test_bit(SAS_HA_REGISTERED, &ha->state))
  79                 __sas_drain_work(ha);
  80         mutex_unlock(&ha->drain_mutex);
  81
  82         return 0;
  83 }
  84 EXPORT_SYMBOL_GPL(sas_drain_work);
  85
  86 void sas_disable_revalidation(struct sas_ha_struct *ha)
  87 {
  88         mutex_lock(&ha->disco_mutex);
  89         set_bit(SAS_HA_ATA_EH_ACTIVE, &ha->state);
  90         mutex_unlock(&ha->disco_mutex);
  91 }
  92
  93 void sas_enable_revalidation(struct sas_ha_struct *ha)
  94 {
  95         int i;
  96
  97         mutex_lock(&ha->disco_mutex);
  98         clear_bit(SAS_HA_ATA_EH_ACTIVE, &ha->state);
  99         for (i = 0; i < ha->num_phys; i++) {
 100                 struct asd_sas_port *port = ha->sas_port[i];
 101                 const int ev = DISCE_REVALIDATE_DOMAIN;
 102                 struct sas_discovery *d = &port->disc;
 103                 struct asd_sas_phy *sas_phy;
 104
 105                 if (!test_and_clear_bit(ev, &d->pending))
 106                         continue;
 107
 108                 spin_lock(&port->phy_list_lock);
 109                 if (list_empty(&port->phy_list)) {
 110                         spin_unlock(&port->phy_list_lock);
 111                         continue;
 112                 }
 113
 114                 sas_phy = container_of(port->phy_list.next, struct asd_sas_phy,
 115                                 port_phy_el);
 116                 spin_unlock(&port->phy_list_lock);
 117                 sas_notify_port_event(sas_phy,
 118                                 PORTE_BROADCAST_RCVD, GFP_KERNEL);
 119         }
 120         mutex_unlock(&ha->disco_mutex);
 121 }
 122
 123
 124 static void sas_port_event_worker(struct work_struct *work)
 125 {
 126         struct asd_sas_event *ev = to_asd_sas_event(work);
 127         struct asd_sas_phy *phy = ev->phy;
 128         struct sas_ha_struct *ha = phy->ha;
 129
 130         sas_port_event_fns[ev->event](work);
 131         pm_runtime_put(ha->dev);
 132         sas_free_event(ev);
 133 }
 134
 135 static void sas_phy_event_worker(struct work_struct *work)
 136 {
 137         struct asd_sas_event *ev = to_asd_sas_event(work);
 138         struct asd_sas_phy *phy = ev->phy;
 139         struct sas_ha_struct *ha = phy->ha;
 140
 141         sas_phy_event_fns[ev->event](work);
 142         pm_runtime_put(ha->dev);
 143         sas_free_event(ev);
 144 }
 145
 146 /* defer works of new phys during suspend */
 147 static bool sas_defer_event(struct asd_sas_phy *phy, struct asd_sas_event *ev)
 148 {
 149         struct sas_ha_struct *ha = phy->ha;
 150         unsigned long flags;
 151         bool deferred = false;
 152
 153         spin_lock_irqsave(&ha->lock, flags);
 154         if (test_bit(SAS_HA_RESUMING, &ha->state) && !phy->suspended) {
 155                 struct sas_work *sw = &ev->work;
 156
 157                 list_add_tail(&sw->drain_node, &ha->defer_q);
 158                 deferred = true;
 159         }
 160         spin_unlock_irqrestore(&ha->lock, flags);
 161         return deferred;
 162 }
 163
 164 void sas_notify_port_event(struct asd_sas_phy *phy, enum port_event event,
 165                            gfp_t gfp_flags)
 166 {
 167         struct sas_ha_struct *ha = phy->ha;
 168         struct asd_sas_event *ev;
 169
 170         BUG_ON(event >= PORT_NUM_EVENTS);
 171
 172         ev = sas_alloc_event(phy, gfp_flags);
 173         if (!ev)
 174                 return;
 175
 176         /* Call pm_runtime_put() with pairs in sas_port_event_worker() */
 177         pm_runtime_get_noresume(ha->dev);
 178
 179         INIT_SAS_EVENT(ev, sas_port_event_worker, phy, event);
 180
 181         if (sas_defer_event(phy, ev))
 182                 return;
 183
 184         if (!sas_queue_event(event, &ev->work, ha)) {
 185                 pm_runtime_put(ha->dev);
 186                 sas_free_event(ev);
 187         }
 188 }
 189 EXPORT_SYMBOL_GPL(sas_notify_port_event);
 190
 191 void sas_notify_phy_event(struct asd_sas_phy *phy, enum phy_event event,
 192                           gfp_t gfp_flags)
 193 {
 194         struct sas_ha_struct *ha = phy->ha;
 195         struct asd_sas_event *ev;
 196
 197         BUG_ON(event >= PHY_NUM_EVENTS);
 198
 199         ev = sas_alloc_event(phy, gfp_flags);
 200         if (!ev)
 201                 return;
 202
 203         /* Call pm_runtime_put() with pairs in sas_phy_event_worker() */
 204         pm_runtime_get_noresume(ha->dev);
 205
 206         INIT_SAS_EVENT(ev, sas_phy_event_worker, phy, event);
 207
 208         if (sas_defer_event(phy, ev))
 209                 return;
 210
 211         if (!sas_queue_event(event, &ev->work, ha)) {
 212                 pm_runtime_put(ha->dev);
 213                 sas_free_event(ev);
 214         }
 215 }
 216 EXPORT_SYMBOL_GPL(sas_notify_phy_event);