264 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * zfcp device driver4 *5 * Functions to handle diagnostics.6 *7 * Copyright IBM Corp. 20188 */9 10#include <linux/spinlock.h>11#include <linux/jiffies.h>12#include <linux/string.h>13#include <linux/errno.h>14#include <linux/slab.h>15 16#include "zfcp_diag.h"17#include "zfcp_ext.h"18#include "zfcp_def.h"19 20static DECLARE_WAIT_QUEUE_HEAD(__zfcp_diag_publish_wait);21 22/**23 * zfcp_diag_adapter_setup() - Setup storage for adapter diagnostics.24 * @adapter: the adapter to setup diagnostics for.25 *26 * Creates the data-structures to store the diagnostics for an adapter. This27 * overwrites whatever was stored before at &zfcp_adapter->diagnostics!28 *29 * Return:30 * * 0 - Everyting is OK31 * * -ENOMEM - Could not allocate all/parts of the data-structures;32 * &zfcp_adapter->diagnostics remains unchanged33 */34int zfcp_diag_adapter_setup(struct zfcp_adapter *const adapter)35{36 struct zfcp_diag_adapter *diag;37 struct zfcp_diag_header *hdr;38 39 diag = kzalloc(sizeof(*diag), GFP_KERNEL);40 if (diag == NULL)41 return -ENOMEM;42 43 diag->max_age = (5 * 1000); /* default value: 5 s */44 45 /* setup header for port_data */46 hdr = &diag->port_data.header;47 48 spin_lock_init(&hdr->access_lock);49 hdr->buffer = &diag->port_data.data;50 hdr->buffer_size = sizeof(diag->port_data.data);51 /* set the timestamp so that the first test on age will always fail */52 hdr->timestamp = jiffies - msecs_to_jiffies(diag->max_age);53 54 /* setup header for config_data */55 hdr = &diag->config_data.header;56 57 spin_lock_init(&hdr->access_lock);58 hdr->buffer = &diag->config_data.data;59 hdr->buffer_size = sizeof(diag->config_data.data);60 /* set the timestamp so that the first test on age will always fail */61 hdr->timestamp = jiffies - msecs_to_jiffies(diag->max_age);62 63 adapter->diagnostics = diag;64 return 0;65}66 67/**68 * zfcp_diag_adapter_free() - Frees all adapter diagnostics allocations.69 * @adapter: the adapter whose diagnostic structures should be freed.70 *71 * Frees all data-structures in the given adapter that store diagnostics72 * information. Can savely be called with partially setup diagnostics.73 */74void zfcp_diag_adapter_free(struct zfcp_adapter *const adapter)75{76 kfree(adapter->diagnostics);77 adapter->diagnostics = NULL;78}79 80/**81 * zfcp_diag_update_xdata() - Update a diagnostics buffer.82 * @hdr: the meta data to update.83 * @data: data to use for the update.84 * @incomplete: flag stating whether the data in @data is incomplete.85 */86void zfcp_diag_update_xdata(struct zfcp_diag_header *const hdr,87 const void *const data, const bool incomplete)88{89 const unsigned long capture_timestamp = jiffies;90 unsigned long flags;91 92 spin_lock_irqsave(&hdr->access_lock, flags);93 94 /* make sure we never go into the past with an update */95 if (!time_after_eq(capture_timestamp, hdr->timestamp))96 goto out;97 98 hdr->timestamp = capture_timestamp;99 hdr->incomplete = incomplete;100 memcpy(hdr->buffer, data, hdr->buffer_size);101out:102 spin_unlock_irqrestore(&hdr->access_lock, flags);103}104 105/**106 * zfcp_diag_update_port_data_buffer() - Implementation of107 * &typedef zfcp_diag_update_buffer_func108 * to collect and update Port Data.109 * @adapter: Adapter to collect Port Data from.110 *111 * This call is SYNCHRONOUS ! It blocks till the respective command has112 * finished completely, or has failed in some way.113 *114 * Return:115 * * 0 - Successfully retrieved new Diagnostics and Updated the buffer;116 * this also includes cases where data was retrieved, but117 * incomplete; you'll have to check the flag ``incomplete``118 * of &struct zfcp_diag_header.119 * * see zfcp_fsf_exchange_port_data_sync() for possible error-codes (120 * excluding -EAGAIN)121 */122int zfcp_diag_update_port_data_buffer(struct zfcp_adapter *const adapter)123{124 int rc;125 126 rc = zfcp_fsf_exchange_port_data_sync(adapter->qdio, NULL);127 if (rc == -EAGAIN)128 rc = 0; /* signaling incomplete via struct zfcp_diag_header */129 130 /* buffer-data was updated in zfcp_fsf_exchange_port_data_handler() */131 132 return rc;133}134 135/**136 * zfcp_diag_update_config_data_buffer() - Implementation of137 * &typedef zfcp_diag_update_buffer_func138 * to collect and update Config Data.139 * @adapter: Adapter to collect Config Data from.140 *141 * This call is SYNCHRONOUS ! It blocks till the respective command has142 * finished completely, or has failed in some way.143 *144 * Return:145 * * 0 - Successfully retrieved new Diagnostics and Updated the buffer;146 * this also includes cases where data was retrieved, but147 * incomplete; you'll have to check the flag ``incomplete``148 * of &struct zfcp_diag_header.149 * * see zfcp_fsf_exchange_config_data_sync() for possible error-codes (150 * excluding -EAGAIN)151 */152int zfcp_diag_update_config_data_buffer(struct zfcp_adapter *const adapter)153{154 int rc;155 156 rc = zfcp_fsf_exchange_config_data_sync(adapter->qdio, NULL);157 if (rc == -EAGAIN)158 rc = 0; /* signaling incomplete via struct zfcp_diag_header */159 160 /* buffer-data was updated in zfcp_fsf_exchange_config_data_handler() */161 162 return rc;163}164 165static int __zfcp_diag_update_buffer(struct zfcp_adapter *const adapter,166 struct zfcp_diag_header *const hdr,167 zfcp_diag_update_buffer_func buffer_update,168 unsigned long *const flags)169 __must_hold(hdr->access_lock)170{171 int rc;172 173 if (hdr->updating == 1) {174 rc = wait_event_interruptible_lock_irq(__zfcp_diag_publish_wait,175 hdr->updating == 0,176 hdr->access_lock);177 rc = (rc == 0 ? -EAGAIN : -EINTR);178 } else {179 hdr->updating = 1;180 spin_unlock_irqrestore(&hdr->access_lock, *flags);181 182 /* unlocked, because update function sleeps */183 rc = buffer_update(adapter);184 185 spin_lock_irqsave(&hdr->access_lock, *flags);186 hdr->updating = 0;187 188 /*189 * every thread waiting here went via an interruptible wait,190 * so its fine to only wake those191 */192 wake_up_interruptible_all(&__zfcp_diag_publish_wait);193 }194 195 return rc;196}197 198static bool199__zfcp_diag_test_buffer_age_isfresh(const struct zfcp_diag_adapter *const diag,200 const struct zfcp_diag_header *const hdr)201 __must_hold(hdr->access_lock)202{203 const unsigned long now = jiffies;204 205 /*206 * Should not happen (data is from the future).. if it does, still207 * signal that it needs refresh208 */209 if (!time_after_eq(now, hdr->timestamp))210 return false;211 212 if (jiffies_to_msecs(now - hdr->timestamp) >= diag->max_age)213 return false;214 215 return true;216}217 218/**219 * zfcp_diag_update_buffer_limited() - Collect diagnostics and update a220 * diagnostics buffer rate limited.221 * @adapter: Adapter to collect the diagnostics from.222 * @hdr: buffer-header for which to update with the collected diagnostics.223 * @buffer_update: Specific implementation for collecting and updating.224 *225 * This function will cause an update of the given @hdr by calling the also226 * given @buffer_update function. If called by multiple sources at the same227 * time, it will synchornize the update by only allowing one source to call228 * @buffer_update and the others to wait for that source to complete instead229 * (the wait is interruptible).230 *231 * Additionally this version is rate-limited and will only exit if either the232 * buffer is fresh enough (within the limit) - it will do nothing if the buffer233 * is fresh enough to begin with -, or if the source/thread that started this234 * update is the one that made the update (to prevent endless loops).235 *236 * Return:237 * * 0 - If the update was successfully published and/or the buffer is238 * fresh enough239 * * -EINTR - If the thread went into the wait-state and was interrupted240 * * whatever @buffer_update returns241 */242int zfcp_diag_update_buffer_limited(struct zfcp_adapter *const adapter,243 struct zfcp_diag_header *const hdr,244 zfcp_diag_update_buffer_func buffer_update)245{246 unsigned long flags;247 int rc;248 249 spin_lock_irqsave(&hdr->access_lock, flags);250 251 for (rc = 0;252 !__zfcp_diag_test_buffer_age_isfresh(adapter->diagnostics, hdr);253 rc = 0) {254 rc = __zfcp_diag_update_buffer(adapter, hdr, buffer_update,255 &flags);256 if (rc != -EAGAIN)257 break;258 }259 260 spin_unlock_irqrestore(&hdr->access_lock, flags);261 262 return rc;263}264