drivers/s390/scsi/zfcp_diag.c - third_party/kernel - Git at Google

 // 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(sizeof(*diag), GFP_KERNEL);
 	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;
 }
	// 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(sizeof(*diag), GFP_KERNEL);
	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;
	}