drivers/s390/scsi/zfcp_diag.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * zfcp device driver
   4  *
   5  * Functions to handle diagnostics.
   6  *
   7  * Copyright IBM Corp. 2018
   8  */
   9
  10 #include <linux/spinlock.h>
  11 #include <linux/jiffies.h>
  12 #include <linux/string.h>
  13 #include <linux/kernfs.h>
  14 #include <linux/sysfs.h>
  15 #include <linux/errno.h>
  16 #include <linux/slab.h>
  17
  18 #include "zfcp_diag.h"
  19 #include "zfcp_ext.h"
  20 #include "zfcp_def.h"
  21
  22 static DECLARE_WAIT_QUEUE_HEAD(__zfcp_diag_publish_wait);
  23
  24 /**
  25  * zfcp_diag_adapter_setup() - Setup storage for adapter diagnostics.
  26  * @adapter: the adapter to setup diagnostics for.
  27  *
  28  * Creates the data-structures to store the diagnostics for an adapter. This
  29  * overwrites whatever was stored before at &zfcp_adapter->diagnostics!
  30  *
  31  * Return:
  32  * * 0       - Everyting is OK
  33  * * -ENOMEM - Could not allocate all/parts of the data-structures;
  34  *             &zfcp_adapter->diagnostics remains unchanged
  35  */
  36 int zfcp_diag_adapter_setup(struct zfcp_adapter *const adapter)
  37 {
  38         struct zfcp_diag_adapter *diag;
  39         struct zfcp_diag_header *hdr;
  40
  41         diag = kzalloc(sizeof(*diag), GFP_KERNEL);
  42         if (diag == NULL)
  43                 return -ENOMEM;
  44
  45         diag->max_age = (5 * 1000); /* default value: 5 s */
  46
  47         /* setup header for port_data */
  48         hdr = &diag->port_data.header;
  49
  50         spin_lock_init(&hdr->access_lock);
  51         hdr->buffer = &diag->port_data.data;
  52         hdr->buffer_size = sizeof(diag->port_data.data);
  53         /* set the timestamp so that the first test on age will always fail */
  54         hdr->timestamp = jiffies - msecs_to_jiffies(diag->max_age);
  55
  56         /* setup header for config_data */
  57         hdr = &diag->config_data.header;
  58
  59         spin_lock_init(&hdr->access_lock);
  60         hdr->buffer = &diag->config_data.data;
  61         hdr->buffer_size = sizeof(diag->config_data.data);
  62         /* set the timestamp so that the first test on age will always fail */
  63         hdr->timestamp = jiffies - msecs_to_jiffies(diag->max_age);
  64
  65         adapter->diagnostics = diag;
  66         return 0;
  67 }
  68
  69 /**
  70  * zfcp_diag_adapter_free() - Frees all adapter diagnostics allocations.
  71  * @adapter: the adapter whose diagnostic structures should be freed.
  72  *
  73  * Frees all data-structures in the given adapter that store diagnostics
  74  * information. Can savely be called with partially setup diagnostics.
  75  */
  76 void zfcp_diag_adapter_free(struct zfcp_adapter *const adapter)
  77 {
  78         kfree(adapter->diagnostics);
  79         adapter->diagnostics = NULL;
  80 }
  81
  82 /**
  83  * zfcp_diag_sysfs_setup() - Setup the sysfs-group for adapter-diagnostics.
  84  * @adapter: target adapter to which the group should be added.
  85  *
  86  * Return: 0 on success; Something else otherwise (see sysfs_create_group()).
  87  */
  88 int zfcp_diag_sysfs_setup(struct zfcp_adapter *const adapter)
  89 {
  90         int rc = sysfs_create_group(&adapter->ccw_device->dev.kobj,
  91                                     &zfcp_sysfs_diag_attr_group);
  92         if (rc == 0)
  93                 adapter->diagnostics->sysfs_established = 1;
  94
  95         return rc;
  96 }
  97
  98 /**
  99  * zfcp_diag_sysfs_destroy() - Remove the sysfs-group for adapter-diagnostics.
 100  * @adapter: target adapter from which the group should be removed.
 101  */
 102 void zfcp_diag_sysfs_destroy(struct zfcp_adapter *const adapter)
 103 {
 104         if (adapter->diagnostics == NULL ||
 105             !adapter->diagnostics->sysfs_established)
 106                 return;
 107
 108         /*
 109          * We need this state-handling so we can prevent warnings being printed
 110          * on the kernel-console in case we have to abort a halfway done
 111          * zfcp_adapter_enqueue(), in which the sysfs-group was not yet
 112          * established. sysfs_remove_group() does this checking as well, but
 113          * still prints a warning in case we try to remove a group that has not
 114          * been established before
 115          */
 116         adapter->diagnostics->sysfs_established = 0;
 117         sysfs_remove_group(&adapter->ccw_device->dev.kobj,
 118                            &zfcp_sysfs_diag_attr_group);
 119 }
 120
 121
 122 /**
 123  * zfcp_diag_update_xdata() - Update a diagnostics buffer.
 124  * @hdr: the meta data to update.
 125  * @data: data to use for the update.
 126  * @incomplete: flag stating whether the data in @data is incomplete.
 127  */
 128 void zfcp_diag_update_xdata(struct zfcp_diag_header *const hdr,
 129                             const void *const data, const bool incomplete)
 130 {
 131         const unsigned long capture_timestamp = jiffies;
 132         unsigned long flags;
 133
 134         spin_lock_irqsave(&hdr->access_lock, flags);
 135
 136         /* make sure we never go into the past with an update */
 137         if (!time_after_eq(capture_timestamp, hdr->timestamp))
 138                 goto out;
 139
 140         hdr->timestamp = capture_timestamp;
 141         hdr->incomplete = incomplete;
 142         memcpy(hdr->buffer, data, hdr->buffer_size);
 143 out:
 144         spin_unlock_irqrestore(&hdr->access_lock, flags);
 145 }
 146
 147 /**
 148  * zfcp_diag_update_port_data_buffer() - Implementation of
 149  *                                       &typedef zfcp_diag_update_buffer_func
 150  *                                       to collect and update Port Data.
 151  * @adapter: Adapter to collect Port Data from.
 152  *
 153  * This call is SYNCHRONOUS ! It blocks till the respective command has
 154  * finished completely, or has failed in some way.
 155  *
 156  * Return:
 157  * * 0          - Successfully retrieved new Diagnostics and Updated the buffer;
 158  *                this also includes cases where data was retrieved, but
 159  *                incomplete; you'll have to check the flag ``incomplete``
 160  *                of &struct zfcp_diag_header.
 161  * * see zfcp_fsf_exchange_port_data_sync() for possible error-codes (
 162  *   excluding -EAGAIN)
 163  */
 164 int zfcp_diag_update_port_data_buffer(struct zfcp_adapter *const adapter)
 165 {
 166         int rc;
 167
 168         rc = zfcp_fsf_exchange_port_data_sync(adapter->qdio, NULL);
 169         if (rc == -EAGAIN)
 170                 rc = 0; /* signaling incomplete via struct zfcp_diag_header */
 171
 172         /* buffer-data was updated in zfcp_fsf_exchange_port_data_handler() */
 173
 174         return rc;
 175 }
 176
 177 /**
 178  * zfcp_diag_update_config_data_buffer() - Implementation of
 179  *                                         &typedef zfcp_diag_update_buffer_func
 180  *                                         to collect and update Config Data.
 181  * @adapter: Adapter to collect Config Data from.
 182  *
 183  * This call is SYNCHRONOUS ! It blocks till the respective command has
 184  * finished completely, or has failed in some way.
 185  *
 186  * Return:
 187  * * 0          - Successfully retrieved new Diagnostics and Updated the buffer;
 188  *                this also includes cases where data was retrieved, but
 189  *                incomplete; you'll have to check the flag ``incomplete``
 190  *                of &struct zfcp_diag_header.
 191  * * see zfcp_fsf_exchange_config_data_sync() for possible error-codes (
 192  *   excluding -EAGAIN)
 193  */
 194 int zfcp_diag_update_config_data_buffer(struct zfcp_adapter *const adapter)
 195 {
 196         int rc;
 197
 198         rc = zfcp_fsf_exchange_config_data_sync(adapter->qdio, NULL);
 199         if (rc == -EAGAIN)
 200                 rc = 0; /* signaling incomplete via struct zfcp_diag_header */
 201
 202         /* buffer-data was updated in zfcp_fsf_exchange_config_data_handler() */
 203
 204         return rc;
 205 }
 206
 207 static int __zfcp_diag_update_buffer(struct zfcp_adapter *const adapter,
 208                                      struct zfcp_diag_header *const hdr,
 209                                      zfcp_diag_update_buffer_func buffer_update,
 210                                      unsigned long *const flags)
 211         __must_hold(hdr->access_lock)
 212 {
 213         int rc;
 214
 215         if (hdr->updating == 1) {
 216                 rc = wait_event_interruptible_lock_irq(__zfcp_diag_publish_wait,
 217                                                        hdr->updating == 0,
 218                                                        hdr->access_lock);
 219                 rc = (rc == 0 ? -EAGAIN : -EINTR);
 220         } else {
 221                 hdr->updating = 1;
 222                 spin_unlock_irqrestore(&hdr->access_lock, *flags);
 223
 224                 /* unlocked, because update function sleeps */
 225                 rc = buffer_update(adapter);
 226
 227                 spin_lock_irqsave(&hdr->access_lock, *flags);
 228                 hdr->updating = 0;
 229
 230                 /*
 231                  * every thread waiting here went via an interruptible wait,
 232                  * so its fine to only wake those
 233                  */
 234                 wake_up_interruptible_all(&__zfcp_diag_publish_wait);
 235         }
 236
 237         return rc;
 238 }
 239
 240 static bool
 241 __zfcp_diag_test_buffer_age_isfresh(const struct zfcp_diag_adapter *const diag,
 242                                     const struct zfcp_diag_header *const hdr)
 243         __must_hold(hdr->access_lock)
 244 {
 245         const unsigned long now = jiffies;
 246
 247         /*
 248          * Should not happen (data is from the future).. if it does, still
 249          * signal that it needs refresh
 250          */
 251         if (!time_after_eq(now, hdr->timestamp))
 252                 return false;
 253
 254         if (jiffies_to_msecs(now - hdr->timestamp) >= diag->max_age)
 255                 return false;
 256
 257         return true;
 258 }
 259
 260 /**
 261  * zfcp_diag_update_buffer_limited() - Collect diagnostics and update a
 262  *                                     diagnostics buffer rate limited.
 263  * @adapter: Adapter to collect the diagnostics from.
 264  * @hdr: buffer-header for which to update with the collected diagnostics.
 265  * @buffer_update: Specific implementation for collecting and updating.
 266  *
 267  * This function will cause an update of the given @hdr by calling the also
 268  * given @buffer_update function. If called by multiple sources at the same
 269  * time, it will synchornize the update by only allowing one source to call
 270  * @buffer_update and the others to wait for that source to complete instead
 271  * (the wait is interruptible).
 272  *
 273  * Additionally this version is rate-limited and will only exit if either the
 274  * buffer is fresh enough (within the limit) - it will do nothing if the buffer
 275  * is fresh enough to begin with -, or if the source/thread that started this
 276  * update is the one that made the update (to prevent endless loops).
 277  *
 278  * Return:
 279  * * 0          - If the update was successfully published and/or the buffer is
 280  *                fresh enough
 281  * * -EINTR     - If the thread went into the wait-state and was interrupted
 282  * * whatever @buffer_update returns
 283  */
 284 int zfcp_diag_update_buffer_limited(struct zfcp_adapter *const adapter,
 285                                     struct zfcp_diag_header *const hdr,
 286                                     zfcp_diag_update_buffer_func buffer_update)
 287 {
 288         unsigned long flags;
 289         int rc;
 290
 291         spin_lock_irqsave(&hdr->access_lock, flags);
 292
 293         for (rc = 0;
 294              !__zfcp_diag_test_buffer_age_isfresh(adapter->diagnostics, hdr);
 295              rc = 0) {
 296                 rc = __zfcp_diag_update_buffer(adapter, hdr, buffer_update,
 297                                                &flags);
 298                 if (rc != -EAGAIN)
 299                         break;
 300         }
 301
 302         spin_unlock_irqrestore(&hdr->access_lock, flags);
 303
 304         return rc;
 305 }