License cleanup: add SPDX GPL-2.0 license identifier to files with no license
Many source files in the tree are missing licensing information, which
makes it harder for compliance tools to determine the correct license.
By default all files without license information are under the default
license of the kernel, which is GPL version 2.
Update the files which contain no license information with the 'GPL-2.0'
SPDX license identifier. The SPDX identifier is a legally binding
shorthand, which can be used instead of the full boiler plate text.
This patch is based on work done by Thomas Gleixner and Kate Stewart and
Philippe Ombredanne.
How this work was done:
Patches were generated and checked against linux-4.14-rc6 for a subset of
the use cases:
- file had no licensing information it it.
- file was a */uapi/* one with no licensing information in it,
- file was a */uapi/* one with existing licensing information,
Further patches will be generated in subsequent months to fix up cases
where non-standard license headers were used, and references to license
had to be inferred by heuristics based on keywords.
The analysis to determine which SPDX License Identifier to be applied to
a file was done in a spreadsheet of side by side results from of the
output of two independent scanners (ScanCode & Windriver) producing SPDX
tag:value files created by Philippe Ombredanne. Philippe prepared the
base worksheet, and did an initial spot review of a few 1000 files.
The 4.13 kernel was the starting point of the analysis with 60,537 files
assessed. Kate Stewart did a file by file comparison of the scanner
results in the spreadsheet to determine which SPDX license identifier(s)
to be applied to the file. She confirmed any determination that was not
immediately clear with lawyers working with the Linux Foundation.
Criteria used to select files for SPDX license identifier tagging was:
- Files considered eligible had to be source code files.
- Make and config files were included as candidates if they contained >5
lines of source
- File already had some variant of a license header in it (even if <5
lines).
All documentation files were explicitly excluded.
The following heuristics were used to determine which SPDX license
identifiers to apply.
- when both scanners couldn't find any license traces, file was
considered to have no license information in it, and the top level
COPYING file license applied.
For non */uapi/* files that summary was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 11139
and resulted in the first patch in this series.
If that file was a */uapi/* path one, it was "GPL-2.0 WITH
Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 WITH Linux-syscall-note 930
and resulted in the second patch in this series.
- if a file had some form of licensing information in it, and was one
of the */uapi/* ones, it was denoted with the Linux-syscall-note if
any GPL family license was found in the file or had no licensing in
it (per prior point). Results summary:
SPDX license identifier # files
---------------------------------------------------|------
GPL-2.0 WITH Linux-syscall-note 270
GPL-2.0+ WITH Linux-syscall-note 169
((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21
((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17
LGPL-2.1+ WITH Linux-syscall-note 15
GPL-1.0+ WITH Linux-syscall-note 14
((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5
LGPL-2.0+ WITH Linux-syscall-note 4
LGPL-2.1 WITH Linux-syscall-note 3
((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3
((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1
and that resulted in the third patch in this series.
- when the two scanners agreed on the detected license(s), that became
the concluded license(s).
- when there was disagreement between the two scanners (one detected a
license but the other didn't, or they both detected different
licenses) a manual inspection of the file occurred.
- In most cases a manual inspection of the information in the file
resulted in a clear resolution of the license that should apply (and
which scanner probably needed to revisit its heuristics).
- When it was not immediately clear, the license identifier was
confirmed with lawyers working with the Linux Foundation.
- If there was any question as to the appropriate license identifier,
the file was flagged for further research and to be revisited later
in time.
In total, over 70 hours of logged manual review was done on the
spreadsheet to determine the SPDX license identifiers to apply to the
source files by Kate, Philippe, Thomas and, in some cases, confirmation
by lawyers working with the Linux Foundation.
Kate also obtained a third independent scan of the 4.13 code base from
FOSSology, and compared selected files where the other two scanners
disagreed against that SPDX file, to see if there was new insights. The
Windriver scanner is based on an older version of FOSSology in part, so
they are related.
Thomas did random spot checks in about 500 files from the spreadsheets
for the uapi headers and agreed with SPDX license identifier in the
files he inspected. For the non-uapi files Thomas did random spot checks
in about 15000 files.
In initial set of patches against 4.14-rc6, 3 files were found to have
copy/paste license identifier errors, and have been fixed to reflect the
correct identifier.
Additionally Philippe spent 10 hours this week doing a detailed manual
inspection and review of the 12,461 patched files from the initial patch
version early this week with:
- a full scancode scan run, collecting the matched texts, detected
license ids and scores
- reviewing anything where there was a license detected (about 500+
files) to ensure that the applied SPDX license was correct
- reviewing anything where there was no detection but the patch license
was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied
SPDX license was correct
This produced a worksheet with 20 files needing minor correction. This
worksheet was then exported into 3 different .csv files for the
different types of files to be modified.
These .csv files were then reviewed by Greg. Thomas wrote a script to
parse the csv files and add the proper SPDX tag to the file, in the
format that the file expected. This script was further refined by Greg
based on the output to detect more types of files automatically and to
distinguish between header and source .c files (which need different
comment types.) Finally Greg ran the script using the .csv files to
generate the patches.
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-11-01 14:07:57 +00:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 */
|
2007-09-07 07:15:31 +00:00
|
|
|
/*
|
2008-06-10 16:20:58 +00:00
|
|
|
* zfcp device driver
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2008-06-10 16:20:58 +00:00
|
|
|
* Global definitions for the zfcp device driver.
|
2007-09-07 07:15:31 +00:00
|
|
|
*
|
2020-03-12 17:45:01 +00:00
|
|
|
* Copyright IBM Corp. 2002, 2020
|
2007-09-07 07:15:31 +00:00
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#ifndef ZFCP_DEF_H
|
|
|
|
#define ZFCP_DEF_H
|
|
|
|
|
|
|
|
/*************************** INCLUDES *****************************************/
|
|
|
|
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/moduleparam.h>
|
|
|
|
#include <linux/major.h>
|
|
|
|
#include <linux/blkdev.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/timer.h>
|
2006-09-18 20:28:49 +00:00
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/mempool.h>
|
|
|
|
#include <linux/syscalls.h>
|
2007-07-30 14:01:32 +00:00
|
|
|
#include <linux/scatterlist.h>
|
2006-09-18 20:28:49 +00:00
|
|
|
#include <linux/ioctl.h>
|
2009-04-06 16:31:47 +00:00
|
|
|
#include <scsi/fc/fc_fs.h>
|
|
|
|
#include <scsi/fc/fc_gs.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <scsi/scsi.h>
|
|
|
|
#include <scsi/scsi_tcq.h>
|
|
|
|
#include <scsi/scsi_cmnd.h>
|
|
|
|
#include <scsi/scsi_device.h>
|
|
|
|
#include <scsi/scsi_host.h>
|
|
|
|
#include <scsi/scsi_transport.h>
|
|
|
|
#include <scsi/scsi_transport_fc.h>
|
2009-04-06 16:31:47 +00:00
|
|
|
#include <scsi/scsi_bsg_fc.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <asm/ccwdev.h>
|
|
|
|
#include <asm/debug.h>
|
|
|
|
#include <asm/ebcdic.h>
|
2008-12-25 12:38:50 +00:00
|
|
|
#include <asm/sysinfo.h>
|
2006-09-18 20:28:49 +00:00
|
|
|
#include "zfcp_fsf.h"
|
2010-07-16 13:37:39 +00:00
|
|
|
#include "zfcp_fc.h"
|
2010-02-17 10:18:59 +00:00
|
|
|
#include "zfcp_qdio.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/********************* FSF SPECIFIC DEFINES *********************************/
|
|
|
|
|
|
|
|
/* ATTENTION: value must not be used by hardware */
|
|
|
|
#define FSF_QTCB_UNSOLICITED_STATUS 0x6305
|
2005-06-13 11:15:15 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*************** ADAPTER/PORT/UNIT AND FSF_REQ STATUS FLAGS ******************/
|
|
|
|
|
2007-09-07 07:15:31 +00:00
|
|
|
/*
|
2018-11-08 14:44:41 +00:00
|
|
|
* Note, the leftmost 12 status bits (3 nibbles) are common among adapter, port
|
|
|
|
* and unit. This is a mask for bitwise 'and' with status values.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
#define ZFCP_COMMON_FLAGS 0xfff00000
|
|
|
|
|
|
|
|
/* common status bits */
|
|
|
|
#define ZFCP_STATUS_COMMON_RUNNING 0x40000000
|
|
|
|
#define ZFCP_STATUS_COMMON_ERP_FAILED 0x20000000
|
|
|
|
#define ZFCP_STATUS_COMMON_UNBLOCKED 0x10000000
|
|
|
|
#define ZFCP_STATUS_COMMON_OPEN 0x04000000
|
|
|
|
#define ZFCP_STATUS_COMMON_ERP_INUSE 0x01000000
|
|
|
|
#define ZFCP_STATUS_COMMON_ACCESS_DENIED 0x00800000
|
2005-06-13 11:23:57 +00:00
|
|
|
#define ZFCP_STATUS_COMMON_ACCESS_BOXED 0x00400000
|
2008-06-10 16:21:00 +00:00
|
|
|
#define ZFCP_STATUS_COMMON_NOESC 0x00200000
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* adapter status */
|
2011-08-15 12:40:32 +00:00
|
|
|
#define ZFCP_STATUS_ADAPTER_MB_ACT 0x00000001
|
2005-04-16 22:20:36 +00:00
|
|
|
#define ZFCP_STATUS_ADAPTER_QDIOUP 0x00000002
|
2010-07-16 13:37:43 +00:00
|
|
|
#define ZFCP_STATUS_ADAPTER_SIOSL_ISSUED 0x00000004
|
2005-04-16 22:20:36 +00:00
|
|
|
#define ZFCP_STATUS_ADAPTER_XCONFIG_OK 0x00000008
|
|
|
|
#define ZFCP_STATUS_ADAPTER_HOST_CON_INIT 0x00000010
|
|
|
|
#define ZFCP_STATUS_ADAPTER_ERP_PENDING 0x00000100
|
|
|
|
#define ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED 0x00000200
|
2010-07-16 13:37:41 +00:00
|
|
|
#define ZFCP_STATUS_ADAPTER_DATA_DIV_ENABLED 0x00000400
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* remote port status */
|
|
|
|
#define ZFCP_STATUS_PORT_PHYS_OPEN 0x00000001
|
2009-08-18 13:43:11 +00:00
|
|
|
#define ZFCP_STATUS_PORT_LINK_TEST 0x00000002
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* FSF request status (this does not have a common part) */
|
|
|
|
#define ZFCP_STATUS_FSFREQ_ERROR 0x00000008
|
|
|
|
#define ZFCP_STATUS_FSFREQ_CLEANUP 0x00000010
|
|
|
|
#define ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED 0x00000040
|
|
|
|
#define ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED 0x00000080
|
|
|
|
#define ZFCP_STATUS_FSFREQ_TMFUNCFAILED 0x00000200
|
|
|
|
#define ZFCP_STATUS_FSFREQ_DISMISSED 0x00001000
|
2019-10-25 16:12:43 +00:00
|
|
|
#define ZFCP_STATUS_FSFREQ_XDATAINCOMPLETE 0x00020000
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/************************* STRUCTURE DEFINITIONS *****************************/
|
|
|
|
|
2018-11-08 14:44:50 +00:00
|
|
|
/**
|
|
|
|
* enum zfcp_erp_act_type - Type of ERP action object.
|
|
|
|
* @ZFCP_ERP_ACTION_REOPEN_LUN: LUN recovery.
|
|
|
|
* @ZFCP_ERP_ACTION_REOPEN_PORT: Port recovery.
|
|
|
|
* @ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: Forced port recovery.
|
|
|
|
* @ZFCP_ERP_ACTION_REOPEN_ADAPTER: Adapter recovery.
|
|
|
|
*
|
|
|
|
* Values must fit into u8 because of code dependencies:
|
|
|
|
* zfcp_dbf_rec_trig(), &zfcp_dbf_rec_trigger.want, &zfcp_dbf_rec_trigger.need;
|
|
|
|
* zfcp_dbf_rec_run_lvl(), zfcp_dbf_rec_run(), &zfcp_dbf_rec_running.rec_action.
|
|
|
|
*/
|
|
|
|
enum zfcp_erp_act_type {
|
|
|
|
ZFCP_ERP_ACTION_REOPEN_LUN = 1,
|
|
|
|
ZFCP_ERP_ACTION_REOPEN_PORT = 2,
|
|
|
|
ZFCP_ERP_ACTION_REOPEN_PORT_FORCED = 3,
|
|
|
|
ZFCP_ERP_ACTION_REOPEN_ADAPTER = 4,
|
|
|
|
};
|
|
|
|
|
2018-11-08 14:44:51 +00:00
|
|
|
/*
|
|
|
|
* Values must fit into u16 because of code dependencies:
|
|
|
|
* zfcp_dbf_rec_run_lvl(), zfcp_dbf_rec_run(), zfcp_dbf_rec_run_wka(),
|
|
|
|
* &zfcp_dbf_rec_running.rec_step.
|
|
|
|
*/
|
|
|
|
enum zfcp_erp_steps {
|
|
|
|
ZFCP_ERP_STEP_UNINITIALIZED = 0x0000,
|
|
|
|
ZFCP_ERP_STEP_PHYS_PORT_CLOSING = 0x0010,
|
|
|
|
ZFCP_ERP_STEP_PORT_CLOSING = 0x0100,
|
|
|
|
ZFCP_ERP_STEP_PORT_OPENING = 0x0800,
|
|
|
|
ZFCP_ERP_STEP_LUN_CLOSING = 0x1000,
|
|
|
|
ZFCP_ERP_STEP_LUN_OPENING = 0x2000,
|
|
|
|
};
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
struct zfcp_erp_action {
|
|
|
|
struct list_head list;
|
2018-11-08 14:44:50 +00:00
|
|
|
enum zfcp_erp_act_type type; /* requested action code */
|
2005-04-16 22:20:36 +00:00
|
|
|
struct zfcp_adapter *adapter; /* device which should be recovered */
|
|
|
|
struct zfcp_port *port;
|
2010-09-08 12:39:55 +00:00
|
|
|
struct scsi_device *sdev;
|
2008-10-01 10:42:16 +00:00
|
|
|
u32 status; /* recovery status */
|
2018-11-08 14:44:51 +00:00
|
|
|
enum zfcp_erp_steps step; /* active step of this erp action */
|
2010-02-17 10:18:49 +00:00
|
|
|
unsigned long fsf_req_id;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct timer_list timer;
|
|
|
|
};
|
|
|
|
|
2018-11-08 14:44:43 +00:00
|
|
|
/* holds various memory pools of an adapter */
|
|
|
|
struct zfcp_adapter_mempool {
|
|
|
|
mempool_t *erp_req;
|
|
|
|
mempool_t *gid_pn_req;
|
|
|
|
mempool_t *scsi_req;
|
|
|
|
mempool_t *scsi_abort;
|
|
|
|
mempool_t *status_read_req;
|
|
|
|
mempool_t *sr_data;
|
|
|
|
mempool_t *gid_pn;
|
|
|
|
mempool_t *qtcb_pool;
|
2008-05-06 09:00:05 +00:00
|
|
|
};
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
struct zfcp_adapter {
|
2009-11-24 15:53:59 +00:00
|
|
|
struct kref ref;
|
2008-10-01 10:42:18 +00:00
|
|
|
u64 peer_wwnn; /* P2P peer WWNN */
|
|
|
|
u64 peer_wwpn; /* P2P peer WWPN */
|
2005-09-19 14:56:17 +00:00
|
|
|
u32 peer_d_id; /* P2P peer D_ID */
|
2005-04-16 22:20:36 +00:00
|
|
|
struct ccw_device *ccw_device; /* S/390 ccw device */
|
2009-08-18 13:43:19 +00:00
|
|
|
struct zfcp_qdio *qdio;
|
2005-04-16 22:20:36 +00:00
|
|
|
u32 hydra_version; /* Hydra version */
|
|
|
|
u32 fsf_lic_version;
|
2005-09-13 19:51:16 +00:00
|
|
|
u32 adapter_features; /* FCP channel features */
|
|
|
|
u32 connection_features; /* host connection features */
|
2005-04-16 22:20:36 +00:00
|
|
|
u32 hardware_version; /* of FCP channel */
|
2020-03-12 17:45:01 +00:00
|
|
|
u32 fc_security_algorithms; /* of FCP channel */
|
2020-03-12 17:45:03 +00:00
|
|
|
u32 fc_security_algorithms_old; /* of FCP channel */
|
2008-05-06 09:00:05 +00:00
|
|
|
u16 timer_ticks; /* time int for a tick */
|
2005-04-16 22:20:36 +00:00
|
|
|
struct Scsi_Host *scsi_host; /* Pointer to mid-layer */
|
2009-11-24 15:53:58 +00:00
|
|
|
struct list_head port_list; /* remote port list */
|
|
|
|
rwlock_t port_list_lock; /* port list lock */
|
2006-08-02 09:05:16 +00:00
|
|
|
unsigned long req_no; /* unique FSF req number */
|
2010-02-17 10:18:50 +00:00
|
|
|
struct zfcp_reqlist *req_list;
|
2005-04-16 22:20:36 +00:00
|
|
|
u32 fsf_req_seq_no; /* FSF cmnd seq number */
|
|
|
|
rwlock_t abort_lock; /* Protects against SCSI
|
|
|
|
stack abort/command
|
|
|
|
completion races */
|
2008-05-19 10:17:37 +00:00
|
|
|
atomic_t stat_miss; /* # missing status reads*/
|
2010-04-30 16:09:36 +00:00
|
|
|
unsigned int stat_read_buf_num;
|
2008-05-19 10:17:37 +00:00
|
|
|
struct work_struct stat_work;
|
2005-04-16 22:20:36 +00:00
|
|
|
atomic_t status; /* status of this adapter */
|
|
|
|
struct list_head erp_ready_head; /* error recovery for this
|
|
|
|
adapter/devices */
|
2009-08-18 13:43:25 +00:00
|
|
|
wait_queue_head_t erp_ready_wq;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct list_head erp_running_head;
|
|
|
|
rwlock_t erp_lock;
|
|
|
|
wait_queue_head_t erp_done_wqh;
|
|
|
|
struct zfcp_erp_action erp_action; /* pending error recovery */
|
|
|
|
atomic_t erp_counter;
|
|
|
|
u32 erp_total_count; /* total nr of enqueued erp
|
|
|
|
actions */
|
|
|
|
u32 erp_low_mem_count; /* nr of erp actions waiting
|
|
|
|
for memory */
|
2009-08-18 13:43:25 +00:00
|
|
|
struct task_struct *erp_thread;
|
2009-11-24 15:54:11 +00:00
|
|
|
struct zfcp_fc_wka_ports *gs; /* generic services */
|
2009-08-18 13:43:07 +00:00
|
|
|
struct zfcp_dbf *dbf; /* debug traces */
|
2005-04-16 22:20:36 +00:00
|
|
|
struct zfcp_adapter_mempool pool; /* Adapter memory pools */
|
2006-01-05 08:59:34 +00:00
|
|
|
struct fc_host_statistics *fc_stats;
|
|
|
|
struct fsf_qtcb_bottom_port *stats_reset_data;
|
|
|
|
unsigned long stats_reset;
|
zfcp: auto port scan resiliency
This patch improves the Fibre Channel port scan behaviour of the zfcp lldd.
Without it the zfcp device driver may churn up the storage area network by
excessive scanning and scan bursts, particularly in big virtual server
environments, potentially resulting in interference of virtual servers and
reduced availability of storage connectivity.
The two main issues as to the zfcp device drivers automatic port scan in
virtual server environments are frequency and simultaneity.
On the one hand, there is no point in allowing lots of ports scans
in a row. It makes sense, though, to make sure that a scan is conducted
eventually if there has been any indication for potential SAN changes.
On the other hand, lots of virtual servers receiving the same indication
for a SAN change had better not attempt to conduct a scan instantly,
that is, at the same time.
Hence this patch has a two-fold approach for better port scanning:
the introduction of a rate limit to amend frequency issues, and the
introduction of a short random backoff to amend simultaneity issues.
Both approaches boil down to deferred port scans, with delays
comprising parts for both approaches.
The new port scan behaviour is summarised best by:
NEW: NEW:
no_auto_port_rescan random rate flush
backoff limit =wait
adapter resume/thaw yes yes no yes*
adapter online (user) no yes no yes*
port rescan (user) no no no yes
adapter recovery (user) yes yes yes no
adapter recovery (other) yes yes yes no
incoming ELS yes yes yes no
incoming ELS lost yes yes yes no
Implementation is straight-forward by converting an existing worker to
a delayed worker. But care is needed whenever that worker is going to be
flushed (in order to make sure work has been completed), since a flush
operation cancels the timer set up for deferred execution (see * above).
There is a small race window whenever a port scan work starts
running up to the point in time of storing the time stamp for that port
scan. The impact is negligible. Closing that gap isn't trivial, though, and
would the destroy the beauty of a simple work-to-delayed-work conversion.
Signed-off-by: Martin Peschke <mpeschke@linux.vnet.ibm.com>
Signed-off-by: Steffen Maier <maier@linux.vnet.ibm.com>
Reviewed-by: Hannes Reinecke <hare@suse.de>
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-11-13 13:59:48 +00:00
|
|
|
struct delayed_work scan_work;
|
2011-02-22 18:54:48 +00:00
|
|
|
struct work_struct ns_up_work;
|
2008-12-25 12:38:50 +00:00
|
|
|
struct service_level service_level;
|
2009-08-18 13:43:17 +00:00
|
|
|
struct workqueue_struct *work_queue;
|
2010-04-30 16:09:33 +00:00
|
|
|
struct device_dma_parameters dma_parms;
|
2010-07-16 13:37:39 +00:00
|
|
|
struct zfcp_fc_events events;
|
zfcp: auto port scan resiliency
This patch improves the Fibre Channel port scan behaviour of the zfcp lldd.
Without it the zfcp device driver may churn up the storage area network by
excessive scanning and scan bursts, particularly in big virtual server
environments, potentially resulting in interference of virtual servers and
reduced availability of storage connectivity.
The two main issues as to the zfcp device drivers automatic port scan in
virtual server environments are frequency and simultaneity.
On the one hand, there is no point in allowing lots of ports scans
in a row. It makes sense, though, to make sure that a scan is conducted
eventually if there has been any indication for potential SAN changes.
On the other hand, lots of virtual servers receiving the same indication
for a SAN change had better not attempt to conduct a scan instantly,
that is, at the same time.
Hence this patch has a two-fold approach for better port scanning:
the introduction of a rate limit to amend frequency issues, and the
introduction of a short random backoff to amend simultaneity issues.
Both approaches boil down to deferred port scans, with delays
comprising parts for both approaches.
The new port scan behaviour is summarised best by:
NEW: NEW:
no_auto_port_rescan random rate flush
backoff limit =wait
adapter resume/thaw yes yes no yes*
adapter online (user) no yes no yes*
port rescan (user) no no no yes
adapter recovery (user) yes yes yes no
adapter recovery (other) yes yes yes no
incoming ELS yes yes yes no
incoming ELS lost yes yes yes no
Implementation is straight-forward by converting an existing worker to
a delayed worker. But care is needed whenever that worker is going to be
flushed (in order to make sure work has been completed), since a flush
operation cancels the timer set up for deferred execution (see * above).
There is a small race window whenever a port scan work starts
running up to the point in time of storing the time stamp for that port
scan. The impact is negligible. Closing that gap isn't trivial, though, and
would the destroy the beauty of a simple work-to-delayed-work conversion.
Signed-off-by: Martin Peschke <mpeschke@linux.vnet.ibm.com>
Signed-off-by: Steffen Maier <maier@linux.vnet.ibm.com>
Reviewed-by: Hannes Reinecke <hare@suse.de>
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-11-13 13:59:48 +00:00
|
|
|
unsigned long next_port_scan;
|
2019-10-25 16:12:44 +00:00
|
|
|
struct zfcp_diag_adapter *diagnostics;
|
2020-10-28 18:30:52 +00:00
|
|
|
struct work_struct version_change_lost_work;
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct zfcp_port {
|
2010-02-17 10:18:56 +00:00
|
|
|
struct device dev;
|
2005-08-27 18:07:54 +00:00
|
|
|
struct fc_rport *rport; /* rport of fc transport class */
|
2005-04-16 22:20:36 +00:00
|
|
|
struct list_head list; /* list of remote ports */
|
|
|
|
struct zfcp_adapter *adapter; /* adapter used to access port */
|
2009-11-24 15:53:58 +00:00
|
|
|
struct list_head unit_list; /* head of logical unit list */
|
|
|
|
rwlock_t unit_list_lock; /* unit list lock */
|
2012-09-04 13:23:34 +00:00
|
|
|
atomic_t units; /* zfcp_unit count */
|
2005-04-16 22:20:36 +00:00
|
|
|
atomic_t status; /* status of this remote port */
|
2008-10-01 10:42:18 +00:00
|
|
|
u64 wwnn; /* WWNN if known */
|
|
|
|
u64 wwpn; /* WWPN */
|
2005-09-19 14:56:17 +00:00
|
|
|
u32 d_id; /* D_ID */
|
2005-04-16 22:20:36 +00:00
|
|
|
u32 handle; /* handle assigned by FSF */
|
|
|
|
struct zfcp_erp_action erp_action; /* pending error recovery */
|
|
|
|
atomic_t erp_counter;
|
2006-05-22 16:24:33 +00:00
|
|
|
u32 maxframe_size;
|
|
|
|
u32 supported_classes;
|
2020-03-12 17:45:01 +00:00
|
|
|
u32 connection_info;
|
2020-03-12 17:45:02 +00:00
|
|
|
u32 connection_info_old;
|
2008-10-01 10:42:17 +00:00
|
|
|
struct work_struct gid_pn_work;
|
2009-03-02 12:09:01 +00:00
|
|
|
struct work_struct test_link_work;
|
2009-03-02 12:09:08 +00:00
|
|
|
struct work_struct rport_work;
|
|
|
|
enum { RPORT_NONE, RPORT_ADD, RPORT_DEL } rport_task;
|
2010-07-16 13:37:35 +00:00
|
|
|
unsigned int starget_id;
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2018-11-08 14:44:43 +00:00
|
|
|
struct zfcp_latency_record {
|
|
|
|
u32 min;
|
|
|
|
u32 max;
|
|
|
|
u64 sum;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct zfcp_latency_cont {
|
|
|
|
struct zfcp_latency_record channel;
|
|
|
|
struct zfcp_latency_record fabric;
|
|
|
|
u64 counter;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct zfcp_latencies {
|
|
|
|
struct zfcp_latency_cont read;
|
|
|
|
struct zfcp_latency_cont write;
|
|
|
|
struct zfcp_latency_cont cmd;
|
|
|
|
spinlock_t lock;
|
|
|
|
};
|
|
|
|
|
2010-09-08 12:39:55 +00:00
|
|
|
/**
|
|
|
|
* struct zfcp_unit - LUN configured via zfcp sysfs
|
|
|
|
* @dev: struct device for sysfs representation and reference counting
|
|
|
|
* @list: entry in LUN/unit list per zfcp_port
|
|
|
|
* @port: reference to zfcp_port where this LUN is configured
|
|
|
|
* @fcp_lun: 64 bit LUN value
|
|
|
|
* @scsi_work: for running scsi_scan_target
|
|
|
|
*
|
|
|
|
* This is the representation of a LUN that has been configured for
|
|
|
|
* usage. The main data here is the 64 bit LUN value, data for
|
|
|
|
* running I/O and recovery is in struct zfcp_scsi_dev.
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
struct zfcp_unit {
|
2010-09-08 12:39:55 +00:00
|
|
|
struct device dev;
|
|
|
|
struct list_head list;
|
|
|
|
struct zfcp_port *port;
|
|
|
|
u64 fcp_lun;
|
2009-04-17 13:08:04 +00:00
|
|
|
struct work_struct scsi_work;
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2010-09-08 12:39:51 +00:00
|
|
|
/**
|
|
|
|
* struct zfcp_scsi_dev - zfcp data per SCSI device
|
|
|
|
* @status: zfcp internal status flags
|
|
|
|
* @lun_handle: handle from "open lun" for issuing FSF requests
|
|
|
|
* @erp_action: zfcp erp data for opening and recovering this LUN
|
|
|
|
* @erp_counter: zfcp erp counter for this LUN
|
|
|
|
* @latencies: FSF channel and fabric latencies
|
|
|
|
* @port: zfcp_port where this LUN belongs to
|
|
|
|
*/
|
|
|
|
struct zfcp_scsi_dev {
|
|
|
|
atomic_t status;
|
|
|
|
u32 lun_handle;
|
|
|
|
struct zfcp_erp_action erp_action;
|
|
|
|
atomic_t erp_counter;
|
|
|
|
struct zfcp_latencies latencies;
|
|
|
|
struct zfcp_port *port;
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* sdev_to_zfcp - Access zfcp LUN data for SCSI device
|
|
|
|
* @sdev: scsi_device where to get the zfcp_scsi_dev pointer
|
|
|
|
*/
|
|
|
|
static inline struct zfcp_scsi_dev *sdev_to_zfcp(struct scsi_device *sdev)
|
|
|
|
{
|
|
|
|
return scsi_transport_device_data(sdev);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* zfcp_scsi_dev_lun - Return SCSI device LUN as 64 bit FCP LUN
|
|
|
|
* @sdev: SCSI device where to get the LUN from
|
|
|
|
*/
|
|
|
|
static inline u64 zfcp_scsi_dev_lun(struct scsi_device *sdev)
|
|
|
|
{
|
|
|
|
u64 fcp_lun;
|
|
|
|
|
|
|
|
int_to_scsilun(sdev->lun, (struct scsi_lun *)&fcp_lun);
|
|
|
|
return fcp_lun;
|
|
|
|
}
|
|
|
|
|
2009-08-18 13:43:18 +00:00
|
|
|
/**
|
|
|
|
* struct zfcp_fsf_req - basic FSF request structure
|
|
|
|
* @list: list of FSF requests
|
|
|
|
* @req_id: unique request ID
|
|
|
|
* @adapter: adapter this request belongs to
|
2010-02-17 10:18:59 +00:00
|
|
|
* @qdio_req: qdio queue related values
|
2009-08-18 13:43:18 +00:00
|
|
|
* @completion: used to signal the completion of the request
|
|
|
|
* @status: status of the request
|
|
|
|
* @qtcb: associated QTCB
|
|
|
|
* @data: private data
|
|
|
|
* @timer: timer data of this request
|
|
|
|
* @erp_action: reference to erp action if request issued on behalf of ERP
|
|
|
|
* @pool: reference to memory pool if used for this request
|
|
|
|
* @issued: time when request was send (STCK)
|
|
|
|
* @handler: handler which should be called to process response
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
struct zfcp_fsf_req {
|
2009-08-18 13:43:18 +00:00
|
|
|
struct list_head list;
|
|
|
|
unsigned long req_id;
|
|
|
|
struct zfcp_adapter *adapter;
|
2010-02-17 10:18:59 +00:00
|
|
|
struct zfcp_qdio_req qdio_req;
|
2009-08-18 13:43:18 +00:00
|
|
|
struct completion completion;
|
|
|
|
u32 status;
|
|
|
|
struct fsf_qtcb *qtcb;
|
|
|
|
void *data;
|
|
|
|
struct timer_list timer;
|
|
|
|
struct zfcp_erp_action *erp_action;
|
|
|
|
mempool_t *pool;
|
|
|
|
unsigned long long issued;
|
2008-07-02 08:56:39 +00:00
|
|
|
void (*handler)(struct zfcp_fsf_req *);
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2011-08-15 12:40:32 +00:00
|
|
|
static inline
|
|
|
|
int zfcp_adapter_multi_buffer_active(struct zfcp_adapter *adapter)
|
|
|
|
{
|
|
|
|
return atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_MB_ACT;
|
|
|
|
}
|
|
|
|
|
2018-11-08 14:44:45 +00:00
|
|
|
static inline bool zfcp_fsf_req_is_status_read_buffer(struct zfcp_fsf_req *req)
|
|
|
|
{
|
|
|
|
return req->qtcb == NULL;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif /* ZFCP_DEF_H */
|