// SPDX-License-Identifier: GPL-2.0 /* * zfcp device driver * * Functions to handle diagnostics. * * Copyright IBM Corp. 2018 */ #include <linux/spinlock.h> #include <linux/jiffies.h> #include <linux/string.h> #include <linux/errno.h> #include <linux/slab.h> #include "zfcp_diag.h" #include "zfcp_ext.h" #include "zfcp_def.h" static DECLARE_WAIT_QUEUE_HEAD(__zfcp_diag_publish_wait); /** * zfcp_diag_adapter_setup() - Setup storage for adapter diagnostics. * @adapter: the adapter to setup diagnostics for. * * Creates the data-structures to store the diagnostics for an adapter. This * overwrites whatever was stored before at &zfcp_adapter->diagnostics! * * Return: * * 0 - Everyting is OK * * -ENOMEM - Could not allocate all/parts of the data-structures; * &zfcp_adapter->diagnostics remains unchanged */ int zfcp_diag_adapter_setup(struct zfcp_adapter *const adapter) { struct zfcp_diag_adapter *diag; struct zfcp_diag_header *hdr; diag = kzalloc_obj(*diag); if (diag == NULL) return -ENOMEM; diag->max_age = (5 * 1000); /* default value: 5 s */ /* setup header for port_data */ hdr = &diag->port_data.header; spin_lock_init(&hdr->access_lock); hdr->buffer = &diag->port_data.data; hdr->buffer_size = sizeof(diag->port_data.data); /* set the timestamp so that the first test on age will always fail */ hdr->timestamp = jiffies - msecs_to_jiffies(diag->max_age); /* setup header for config_data */ hdr = &diag->config_data.header; spin_lock_init(&hdr->access_lock); hdr->buffer = &diag->config_data.data; hdr->buffer_size = sizeof(diag->config_data.data); /* set the timestamp so that the first test on age will always fail */ hdr->timestamp = jiffies - msecs_to_jiffies(diag->max_age); adapter->diagnostics = diag; return 0; } /** * zfcp_diag_adapter_free() - Frees all adapter diagnostics allocations. * @adapter: the adapter whose diagnostic structures should be freed. * * Frees all data-structures in the given adapter that store diagnostics * information. Can savely be called with partially setup diagnostics. */ void zfcp_diag_adapter_free(struct zfcp_adapter *const adapter) { kfree(adapter->diagnostics); adapter->diagnostics = NULL; } /** * zfcp_diag_update_xdata() - Update a diagnostics buffer. * @hdr: the meta data to update. * @data: data to use for the update. * @incomplete: flag stating whether the data in @data is incomplete. */ void zfcp_diag_update_xdata(struct zfcp_diag_header *const hdr, const void *const data, const bool incomplete) { const unsigned long capture_timestamp = jiffies; unsigned long flags; spin_lock_irqsave(&hdr->access_lock, flags); /* make sure we never go into the past with an update */ if (!time_after_eq(capture_timestamp, hdr->timestamp)) goto out; hdr->timestamp = capture_timestamp; hdr->incomplete = incomplete; memcpy(hdr->buffer, data, hdr->buffer_size); out: spin_unlock_irqrestore(&hdr->access_lock, flags); } /** * zfcp_diag_update_port_data_buffer() - Implementation of * &typedef zfcp_diag_update_buffer_func * to collect and update Port Data. * @adapter: Adapter to collect Port Data from. * * This call is SYNCHRONOUS ! It blocks till the respective command has * finished completely, or has failed in some way. * * Return: * * 0 - Successfully retrieved new Diagnostics and Updated the buffer; * this also includes cases where data was retrieved, but * incomplete; you'll have to check the flag ``incomplete`` * of &struct zfcp_diag_header. * * see zfcp_fsf_exchange_port_data_sync() for possible error-codes ( * excluding -EAGAIN) */ int zfcp_diag_update_port_data_buffer(struct zfcp_adapter *const adapter) { int rc; rc = zfcp_fsf_exchange_port_data_sync(adapter->qdio, NULL); if (rc == -EAGAIN) rc = 0; /* signaling incomplete via struct zfcp_diag_header */ /* buffer-data was updated in zfcp_fsf_exchange_port_data_handler() */ return rc; } /** * zfcp_diag_update_config_data_buffer() - Implementation of * &typedef zfcp_diag_update_buffer_func * to collect and update Config Data. * @adapter: Adapter to collect Config Data from. * * This call is SYNCHRONOUS ! It blocks till the respective command has * finished completely, or has failed in some way. * * Return: * * 0 - Successfully retrieved new Diagnostics and Updated the buffer; * this also includes cases where data was retrieved, but * incomplete; you'll have to check the flag ``incomplete`` * of &struct zfcp_diag_header. * * see zfcp_fsf_exchange_config_data_sync() for possible error-codes ( * excluding -EAGAIN) */ int zfcp_diag_update_config_data_buffer(struct zfcp_adapter *const adapter) { int rc; rc = zfcp_fsf_exchange_config_data_sync(adapter->qdio, NULL); if (rc == -EAGAIN) rc = 0; /* signaling incomplete via struct zfcp_diag_header */ /* buffer-data was updated in zfcp_fsf_exchange_config_data_handler() */ return rc; } static int __zfcp_diag_update_buffer(struct zfcp_adapter *const adapter, struct zfcp_diag_header *const hdr, zfcp_diag_update_buffer_func buffer_update, unsigned long *const flags) __must_hold(hdr->access_lock) { int rc; if (hdr->updating == 1) { rc = wait_event_interruptible_lock_irq(__zfcp_diag_publish_wait, hdr->updating == 0, hdr->access_lock); rc = (rc == 0 ? -EAGAIN : -EINTR); } else { hdr->updating = 1; spin_unlock_irqrestore(&hdr->access_lock, *flags); /* unlocked, because update function sleeps */ rc = buffer_update(adapter); spin_lock_irqsave(&hdr->access_lock, *flags); hdr->updating = 0; /* * every thread waiting here went via an interruptible wait, * so its fine to only wake those */ wake_up_interruptible_all(&__zfcp_diag_publish_wait); } return rc; } static bool __zfcp_diag_test_buffer_age_isfresh(const struct zfcp_diag_adapter *const diag, const struct zfcp_diag_header *const hdr) __must_hold(hdr->access_lock) { const unsigned long now = jiffies; /* * Should not happen (data is from the future).. if it does, still * signal that it needs refresh */ if (!time_after_eq(now, hdr->timestamp)) return false; if (jiffies_to_msecs(now - hdr->timestamp) >= diag->max_age) return false; return true; } /** * zfcp_diag_update_buffer_limited() - Collect diagnostics and update a * diagnostics buffer rate limited. * @adapter: Adapter to collect the diagnostics from. * @hdr: buffer-header for which to update with the collected diagnostics. * @buffer_update: Specific implementation for collecting and updating. * * This function will cause an update of the given @hdr by calling the also * given @buffer_update function. If called by multiple sources at the same * time, it will synchornize the update by only allowing one source to call * @buffer_update and the others to wait for that source to complete instead * (the wait is interruptible). * * Additionally this version is rate-limited and will only exit if either the * buffer is fresh enough (within the limit) - it will do nothing if the buffer * is fresh enough to begin with -, or if the source/thread that started this * update is the one that made the update (to prevent endless loops). * * Return: * * 0 - If the update was successfully published and/or the buffer is * fresh enough * * -EINTR - If the thread went into the wait-state and was interrupted * * whatever @buffer_update returns */ int zfcp_diag_update_buffer_limited(struct zfcp_adapter *const adapter, struct zfcp_diag_header *const hdr, zfcp_diag_update_buffer_func buffer_update) { unsigned long flags; int rc; spin_lock_irqsave(&hdr->access_lock, flags); for (rc = 0; !__zfcp_diag_test_buffer_age_isfresh(adapter->diagnostics, hdr); rc = 0) { rc = __zfcp_diag_update_buffer(adapter, hdr, buffer_update, &flags); if (rc != -EAGAIN) break; } spin_unlock_irqrestore(&hdr->access_lock, flags); return rc; }
