2005-04-18 05:05:31 +08:00
|
|
|
/*******************************************************************
|
|
|
|
|
* This file is part of the Emulex Linux Device Driver for *
|
2005-06-25 22:34:39 +08:00
|
|
|
* Fibre Channel Host Bus Adapters. *
|
2024-06-12 13:13:20 +08:00
|
|
|
* Copyright (C) 2017-2019 Broadcom. All Rights Reserved. The term *
|
|
|
|
|
* “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. *
|
2016-04-01 05:12:34 +08:00
|
|
|
* Copyright (C) 2004-2016 Emulex. All rights reserved. *
|
2005-06-25 22:34:39 +08:00
|
|
|
* EMULEX and SLI are trademarks of Emulex. *
|
2017-02-13 05:52:39 +08:00
|
|
|
* www.broadcom.com *
|
2005-06-25 22:34:39 +08:00
|
|
|
* Portions Copyright (C) 2004-2005 Christoph Hellwig *
|
2005-04-18 05:05:31 +08:00
|
|
|
* *
|
|
|
|
|
* This program is free software; you can redistribute it and/or *
|
2005-06-25 22:34:39 +08:00
|
|
|
* modify it under the terms of version 2 of the GNU General *
|
|
|
|
|
* Public License as published by the Free Software Foundation. *
|
|
|
|
|
* This program is distributed in the hope that it will be useful. *
|
|
|
|
|
* ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND *
|
|
|
|
|
* WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, *
|
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE *
|
|
|
|
|
* DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
|
|
|
|
|
* TO BE LEGALLY INVALID. See the GNU General Public License for *
|
|
|
|
|
* more details, a copy of which can be found in the file COPYING *
|
|
|
|
|
* included with this package. *
|
2005-04-18 05:05:31 +08:00
|
|
|
*******************************************************************/
|
|
|
|
|
|
|
|
|
|
#include <linux/ctype.h>
|
2007-04-25 21:51:45 +08:00
|
|
|
#include <linux/delay.h>
|
2005-04-18 05:05:31 +08:00
|
|
|
#include <linux/pci.h>
|
|
|
|
|
#include <linux/interrupt.h>
|
2011-05-27 21:47:43 +08:00
|
|
|
#include <linux/module.h>
|
2009-10-03 03:16:56 +08:00
|
|
|
#include <linux/aer.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 16:04:11 +08:00
|
|
|
#include <linux/gfp.h>
|
2024-06-12 13:13:20 +08:00
|
|
|
#include <linux/kernel.h>
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2005-08-11 03:03:09 +08:00
|
|
|
#include <scsi/scsi.h>
|
2005-04-18 05:05:31 +08:00
|
|
|
#include <scsi/scsi_device.h>
|
|
|
|
|
#include <scsi/scsi_host.h>
|
|
|
|
|
#include <scsi/scsi_tcq.h>
|
|
|
|
|
#include <scsi/scsi_transport_fc.h>
|
2009-10-03 03:16:51 +08:00
|
|
|
#include <scsi/fc/fc_fs.h>
|
2024-06-12 13:13:20 +08:00
|
|
|
|
2017-02-13 05:52:30 +08:00
|
|
|
#include <linux/nvme-fc-driver.h>
|
|
|
|
|
|
2009-05-23 02:51:39 +08:00
|
|
|
#include "lpfc_hw4.h"
|
2005-04-18 05:05:31 +08:00
|
|
|
#include "lpfc_hw.h"
|
|
|
|
|
#include "lpfc_sli.h"
|
2009-05-23 02:51:39 +08:00
|
|
|
#include "lpfc_sli4.h"
|
2008-09-07 23:52:10 +08:00
|
|
|
#include "lpfc_nl.h"
|
2005-04-18 05:05:31 +08:00
|
|
|
#include "lpfc_disc.h"
|
|
|
|
|
#include "lpfc.h"
|
2017-02-13 05:52:30 +08:00
|
|
|
#include "lpfc_scsi.h"
|
|
|
|
|
#include "lpfc_nvme.h"
|
2017-02-13 05:52:34 +08:00
|
|
|
#include "lpfc_nvmet.h"
|
2005-04-18 05:05:31 +08:00
|
|
|
#include "lpfc_logmsg.h"
|
|
|
|
|
#include "lpfc_version.h"
|
|
|
|
|
#include "lpfc_compat.h"
|
|
|
|
|
#include "lpfc_crtn.h"
|
2007-06-18 08:56:38 +08:00
|
|
|
#include "lpfc_vport.h"
|
2016-07-07 03:36:10 +08:00
|
|
|
#include "lpfc_attr.h"
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2017-02-13 05:52:27 +08:00
|
|
|
#define LPFC_DEF_DEVLOSS_TMO 30
|
|
|
|
|
#define LPFC_MIN_DEVLOSS_TMO 1
|
|
|
|
|
#define LPFC_MAX_DEVLOSS_TMO 255
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
#define LPFC_DEF_MRQ_POST 512
|
|
|
|
|
#define LPFC_MIN_MRQ_POST 512
|
|
|
|
|
#define LPFC_MAX_MRQ_POST 2048
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2011-08-22 09:49:16 +08:00
|
|
|
/*
|
|
|
|
|
* Write key size should be multiple of 4. If write key is changed
|
|
|
|
|
* make sure that library write key is also changed.
|
|
|
|
|
*/
|
|
|
|
|
#define LPFC_REG_WRITE_KEY_SIZE 4
|
|
|
|
|
#define LPFC_REG_WRITE_KEY "EMLX"
|
|
|
|
|
|
2019-03-29 02:06:19 +08:00
|
|
|
const char *const trunk_errmsg[] = { /* map errcode */
|
|
|
|
|
"", /* There is no such error code at index 0*/
|
|
|
|
|
"link negotiated speed does not match existing"
|
|
|
|
|
" trunk - link was \"low\" speed",
|
|
|
|
|
"link negotiated speed does not match"
|
|
|
|
|
" existing trunk - link was \"middle\" speed",
|
|
|
|
|
"link negotiated speed does not match existing"
|
|
|
|
|
" trunk - link was \"high\" speed",
|
|
|
|
|
"Attached to non-trunking port - F_Port",
|
|
|
|
|
"Attached to non-trunking port - N_Port",
|
|
|
|
|
"FLOGI response timeout",
|
|
|
|
|
"non-FLOGI frame received",
|
|
|
|
|
"Invalid FLOGI response",
|
|
|
|
|
"Trunking initialization protocol",
|
|
|
|
|
"Trunk peer device mismatch",
|
|
|
|
|
};
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_jedec_to_ascii - Hex to ascii convertor according to JEDEC rules
|
2008-08-25 09:49:00 +08:00
|
|
|
* @incr: integer to convert.
|
|
|
|
|
* @hdw: ascii string holding converted integer plus a string terminator.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* JEDEC Joint Electron Device Engineering Council.
|
|
|
|
|
* Convert a 32 bit integer composed of 8 nibbles into an 8 byte ascii
|
|
|
|
|
* character string. The string is then terminated with a NULL in byte 9.
|
|
|
|
|
* Hex 0-9 becomes ascii '0' to '9'.
|
|
|
|
|
* Hex a-f becomes ascii '=' to 'B' capital B.
|
|
|
|
|
*
|
|
|
|
|
* Notes:
|
|
|
|
|
* Coded for 32 bit integers only.
|
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static void
|
|
|
|
|
lpfc_jedec_to_ascii(int incr, char hdw[])
|
|
|
|
|
{
|
|
|
|
|
int i, j;
|
|
|
|
|
for (i = 0; i < 8; i++) {
|
|
|
|
|
j = (incr & 0xf);
|
|
|
|
|
if (j <= 9)
|
|
|
|
|
hdw[7 - i] = 0x30 + j;
|
|
|
|
|
else
|
|
|
|
|
hdw[7 - i] = 0x61 + j - 10;
|
|
|
|
|
incr = (incr >> 4);
|
|
|
|
|
}
|
|
|
|
|
hdw[8] = 0;
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_drvr_version_show - Return the Emulex driver string with version number
|
2008-08-25 09:49:00 +08:00
|
|
|
* @dev: class unused variable.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: on return contains the module description text.
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_drvr_version_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, LPFC_MODULE_DESC "\n");
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
|
2009-10-03 03:17:02 +08:00
|
|
|
/**
|
|
|
|
|
* lpfc_enable_fip_show - Return the fip mode of the HBA
|
|
|
|
|
* @dev: class unused variable.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: on return contains the module description text.
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_enable_fip_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
|
|
|
|
|
if (phba->hba_flag & HBA_FIP_SUPPORT)
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "1\n");
|
2009-10-03 03:17:02 +08:00
|
|
|
else
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "0\n");
|
2009-10-03 03:17:02 +08:00
|
|
|
}
|
|
|
|
|
|
2017-02-13 05:52:30 +08:00
|
|
|
static ssize_t
|
|
|
|
|
lpfc_nvme_info_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_vport *vport = shost_priv(shost);
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
2017-02-13 05:52:34 +08:00
|
|
|
struct lpfc_nvmet_tgtport *tgtp;
|
2017-02-13 05:52:30 +08:00
|
|
|
struct nvme_fc_local_port *localport;
|
2017-12-09 09:18:10 +08:00
|
|
|
struct lpfc_nvme_lport *lport;
|
2018-04-10 05:24:27 +08:00
|
|
|
struct lpfc_nvme_rport *rport;
|
2017-06-02 12:06:56 +08:00
|
|
|
struct lpfc_nodelist *ndlp;
|
2017-02-13 05:52:30 +08:00
|
|
|
struct nvme_fc_remote_port *nrport;
|
2019-01-29 03:14:25 +08:00
|
|
|
struct lpfc_fc4_ctrl_stat *cstat;
|
2018-04-10 05:24:23 +08:00
|
|
|
uint64_t data1, data2, data3;
|
|
|
|
|
uint64_t totin, totout, tot;
|
2017-02-13 05:52:30 +08:00
|
|
|
char *statep;
|
2018-04-10 05:24:23 +08:00
|
|
|
int i;
|
2024-06-12 13:13:20 +08:00
|
|
|
int len = 0;
|
|
|
|
|
char tmp[LPFC_MAX_NVME_INFO_TMP_LEN] = {0};
|
2017-02-13 05:52:30 +08:00
|
|
|
|
2019-01-29 03:14:38 +08:00
|
|
|
if (!(vport->cfg_enable_fc4_type & LPFC_ENABLE_NVME)) {
|
2018-06-26 23:24:22 +08:00
|
|
|
len = scnprintf(buf, PAGE_SIZE, "NVME Disabled\n");
|
2017-02-13 05:52:30 +08:00
|
|
|
return len;
|
|
|
|
|
}
|
2017-02-13 05:52:34 +08:00
|
|
|
if (phba->nvmet_support) {
|
|
|
|
|
if (!phba->targetport) {
|
2018-06-26 23:24:22 +08:00
|
|
|
len = scnprintf(buf, PAGE_SIZE,
|
2017-02-13 05:52:34 +08:00
|
|
|
"NVME Target: x%llx is not allocated\n",
|
|
|
|
|
wwn_to_u64(vport->fc_portname.u.wwn));
|
|
|
|
|
return len;
|
|
|
|
|
}
|
|
|
|
|
/* Port state is only one of two values for now. */
|
|
|
|
|
if (phba->targetport->port_id)
|
|
|
|
|
statep = "REGISTERED";
|
|
|
|
|
else
|
|
|
|
|
statep = "INIT";
|
2018-06-26 23:24:22 +08:00
|
|
|
scnprintf(tmp, sizeof(tmp),
|
|
|
|
|
"NVME Target Enabled State %s\n",
|
|
|
|
|
statep);
|
|
|
|
|
if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
|
|
|
|
|
goto buffer_done;
|
|
|
|
|
|
|
|
|
|
scnprintf(tmp, sizeof(tmp),
|
|
|
|
|
"%s%d WWPN x%llx WWNN x%llx DID x%06x\n",
|
|
|
|
|
"NVME Target: lpfc",
|
|
|
|
|
phba->brd_no,
|
|
|
|
|
wwn_to_u64(vport->fc_portname.u.wwn),
|
|
|
|
|
wwn_to_u64(vport->fc_nodename.u.wwn),
|
|
|
|
|
phba->targetport->port_id);
|
|
|
|
|
if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
|
|
|
|
|
goto buffer_done;
|
|
|
|
|
|
|
|
|
|
if (strlcat(buf, "\nNVME Target: Statistics\n", PAGE_SIZE)
|
|
|
|
|
>= PAGE_SIZE)
|
|
|
|
|
goto buffer_done;
|
|
|
|
|
|
2017-02-13 05:52:34 +08:00
|
|
|
tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private;
|
2018-06-26 23:24:22 +08:00
|
|
|
scnprintf(tmp, sizeof(tmp),
|
|
|
|
|
"LS: Rcv %08x Drop %08x Abort %08x\n",
|
|
|
|
|
atomic_read(&tgtp->rcv_ls_req_in),
|
|
|
|
|
atomic_read(&tgtp->rcv_ls_req_drop),
|
|
|
|
|
atomic_read(&tgtp->xmt_ls_abort));
|
|
|
|
|
if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
|
|
|
|
|
goto buffer_done;
|
|
|
|
|
|
2017-02-13 05:52:34 +08:00
|
|
|
if (atomic_read(&tgtp->rcv_ls_req_in) !=
|
|
|
|
|
atomic_read(&tgtp->rcv_ls_req_out)) {
|
2018-06-26 23:24:22 +08:00
|
|
|
scnprintf(tmp, sizeof(tmp),
|
|
|
|
|
"Rcv LS: in %08x != out %08x\n",
|
|
|
|
|
atomic_read(&tgtp->rcv_ls_req_in),
|
|
|
|
|
atomic_read(&tgtp->rcv_ls_req_out));
|
|
|
|
|
if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
|
|
|
|
|
goto buffer_done;
|
2017-02-13 05:52:34 +08:00
|
|
|
}
|
|
|
|
|
|
2018-06-26 23:24:22 +08:00
|
|
|
scnprintf(tmp, sizeof(tmp),
|
|
|
|
|
"LS: Xmt %08x Drop %08x Cmpl %08x\n",
|
|
|
|
|
atomic_read(&tgtp->xmt_ls_rsp),
|
|
|
|
|
atomic_read(&tgtp->xmt_ls_drop),
|
|
|
|
|
atomic_read(&tgtp->xmt_ls_rsp_cmpl));
|
|
|
|
|
if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
|
|
|
|
|
goto buffer_done;
|
|
|
|
|
|
|
|
|
|
scnprintf(tmp, sizeof(tmp),
|
|
|
|
|
"LS: RSP Abort %08x xb %08x Err %08x\n",
|
|
|
|
|
atomic_read(&tgtp->xmt_ls_rsp_aborted),
|
|
|
|
|
atomic_read(&tgtp->xmt_ls_rsp_xb_set),
|
|
|
|
|
atomic_read(&tgtp->xmt_ls_rsp_error));
|
|
|
|
|
if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
|
|
|
|
|
goto buffer_done;
|
|
|
|
|
|
|
|
|
|
scnprintf(tmp, sizeof(tmp),
|
|
|
|
|
"FCP: Rcv %08x Defer %08x Release %08x "
|
|
|
|
|
"Drop %08x\n",
|
|
|
|
|
atomic_read(&tgtp->rcv_fcp_cmd_in),
|
|
|
|
|
atomic_read(&tgtp->rcv_fcp_cmd_defer),
|
|
|
|
|
atomic_read(&tgtp->xmt_fcp_release),
|
|
|
|
|
atomic_read(&tgtp->rcv_fcp_cmd_drop));
|
|
|
|
|
if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
|
|
|
|
|
goto buffer_done;
|
2017-02-13 05:52:34 +08:00
|
|
|
|
|
|
|
|
if (atomic_read(&tgtp->rcv_fcp_cmd_in) !=
|
|
|
|
|
atomic_read(&tgtp->rcv_fcp_cmd_out)) {
|
2018-06-26 23:24:22 +08:00
|
|
|
scnprintf(tmp, sizeof(tmp),
|
|
|
|
|
"Rcv FCP: in %08x != out %08x\n",
|
|
|
|
|
atomic_read(&tgtp->rcv_fcp_cmd_in),
|
|
|
|
|
atomic_read(&tgtp->rcv_fcp_cmd_out));
|
|
|
|
|
if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
|
|
|
|
|
goto buffer_done;
|
2017-02-13 05:52:34 +08:00
|
|
|
}
|
|
|
|
|
|
2018-06-26 23:24:22 +08:00
|
|
|
scnprintf(tmp, sizeof(tmp),
|
|
|
|
|
"FCP Rsp: RD %08x rsp %08x WR %08x rsp %08x "
|
|
|
|
|
"drop %08x\n",
|
|
|
|
|
atomic_read(&tgtp->xmt_fcp_read),
|
|
|
|
|
atomic_read(&tgtp->xmt_fcp_read_rsp),
|
|
|
|
|
atomic_read(&tgtp->xmt_fcp_write),
|
|
|
|
|
atomic_read(&tgtp->xmt_fcp_rsp),
|
|
|
|
|
atomic_read(&tgtp->xmt_fcp_drop));
|
|
|
|
|
if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
|
|
|
|
|
goto buffer_done;
|
|
|
|
|
|
|
|
|
|
scnprintf(tmp, sizeof(tmp),
|
|
|
|
|
"FCP Rsp Cmpl: %08x err %08x drop %08x\n",
|
|
|
|
|
atomic_read(&tgtp->xmt_fcp_rsp_cmpl),
|
|
|
|
|
atomic_read(&tgtp->xmt_fcp_rsp_error),
|
|
|
|
|
atomic_read(&tgtp->xmt_fcp_rsp_drop));
|
|
|
|
|
if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
|
|
|
|
|
goto buffer_done;
|
|
|
|
|
|
|
|
|
|
scnprintf(tmp, sizeof(tmp),
|
|
|
|
|
"FCP Rsp Abort: %08x xb %08x xricqe %08x\n",
|
|
|
|
|
atomic_read(&tgtp->xmt_fcp_rsp_aborted),
|
|
|
|
|
atomic_read(&tgtp->xmt_fcp_rsp_xb_set),
|
|
|
|
|
atomic_read(&tgtp->xmt_fcp_xri_abort_cqe));
|
|
|
|
|
if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
|
|
|
|
|
goto buffer_done;
|
|
|
|
|
|
|
|
|
|
scnprintf(tmp, sizeof(tmp),
|
|
|
|
|
"ABORT: Xmt %08x Cmpl %08x\n",
|
|
|
|
|
atomic_read(&tgtp->xmt_fcp_abort),
|
|
|
|
|
atomic_read(&tgtp->xmt_fcp_abort_cmpl));
|
|
|
|
|
if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
|
|
|
|
|
goto buffer_done;
|
|
|
|
|
|
|
|
|
|
scnprintf(tmp, sizeof(tmp),
|
|
|
|
|
"ABORT: Sol %08x Usol %08x Err %08x Cmpl %08x\n",
|
|
|
|
|
atomic_read(&tgtp->xmt_abort_sol),
|
|
|
|
|
atomic_read(&tgtp->xmt_abort_unsol),
|
|
|
|
|
atomic_read(&tgtp->xmt_abort_rsp),
|
|
|
|
|
atomic_read(&tgtp->xmt_abort_rsp_error));
|
|
|
|
|
if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
|
|
|
|
|
goto buffer_done;
|
|
|
|
|
|
|
|
|
|
scnprintf(tmp, sizeof(tmp),
|
|
|
|
|
"DELAY: ctx %08x fod %08x wqfull %08x\n",
|
|
|
|
|
atomic_read(&tgtp->defer_ctx),
|
|
|
|
|
atomic_read(&tgtp->defer_fod),
|
|
|
|
|
atomic_read(&tgtp->defer_wqfull));
|
|
|
|
|
if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
|
|
|
|
|
goto buffer_done;
|
2018-01-31 07:58:52 +08:00
|
|
|
|
2017-08-24 07:55:42 +08:00
|
|
|
/* Calculate outstanding IOs */
|
|
|
|
|
tot = atomic_read(&tgtp->rcv_fcp_cmd_drop);
|
|
|
|
|
tot += atomic_read(&tgtp->xmt_fcp_release);
|
|
|
|
|
tot = atomic_read(&tgtp->rcv_fcp_cmd_in) - tot;
|
2017-06-02 12:07:02 +08:00
|
|
|
|
2018-06-26 23:24:22 +08:00
|
|
|
scnprintf(tmp, sizeof(tmp),
|
|
|
|
|
"IO_CTX: %08x WAIT: cur %08x tot %08x\n"
|
|
|
|
|
"CTX Outstanding %08llx\n\n",
|
|
|
|
|
phba->sli4_hba.nvmet_xri_cnt,
|
|
|
|
|
phba->sli4_hba.nvmet_io_wait_cnt,
|
|
|
|
|
phba->sli4_hba.nvmet_io_wait_total,
|
|
|
|
|
tot);
|
|
|
|
|
strlcat(buf, tmp, PAGE_SIZE);
|
|
|
|
|
goto buffer_done;
|
2017-02-13 05:52:34 +08:00
|
|
|
}
|
2017-02-13 05:52:30 +08:00
|
|
|
|
|
|
|
|
localport = vport->localport;
|
|
|
|
|
if (!localport) {
|
2018-06-26 23:24:22 +08:00
|
|
|
len = scnprintf(buf, PAGE_SIZE,
|
2017-02-13 05:52:30 +08:00
|
|
|
"NVME Initiator x%llx is not allocated\n",
|
|
|
|
|
wwn_to_u64(vport->fc_portname.u.wwn));
|
|
|
|
|
return len;
|
|
|
|
|
}
|
2017-12-22 08:28:52 +08:00
|
|
|
lport = (struct lpfc_nvme_lport *)localport->private;
|
2018-06-26 23:24:22 +08:00
|
|
|
if (strlcat(buf, "\nNVME Initiator Enabled\n", PAGE_SIZE) >= PAGE_SIZE)
|
|
|
|
|
goto buffer_done;
|
|
|
|
|
|
|
|
|
|
scnprintf(tmp, sizeof(tmp),
|
2019-01-29 03:14:19 +08:00
|
|
|
"XRI Dist lpfc%d Total %d IO %d ELS %d\n",
|
2018-06-26 23:24:22 +08:00
|
|
|
phba->brd_no,
|
|
|
|
|
phba->sli4_hba.max_cfg_param.max_xri,
|
2019-01-29 03:14:22 +08:00
|
|
|
phba->sli4_hba.io_xri_max,
|
2018-06-26 23:24:22 +08:00
|
|
|
lpfc_sli4_get_els_iocb_cnt(phba));
|
|
|
|
|
if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
|
2024-06-11 20:26:44 +08:00
|
|
|
goto buffer_done;
|
2017-02-13 05:52:30 +08:00
|
|
|
|
|
|
|
|
/* Port state is only one of two values for now. */
|
|
|
|
|
if (localport->port_id)
|
|
|
|
|
statep = "ONLINE";
|
|
|
|
|
else
|
|
|
|
|
statep = "UNKNOWN ";
|
|
|
|
|
|
2018-06-26 23:24:22 +08:00
|
|
|
scnprintf(tmp, sizeof(tmp),
|
|
|
|
|
"%s%d WWPN x%llx WWNN x%llx DID x%06x %s\n",
|
|
|
|
|
"NVME LPORT lpfc",
|
|
|
|
|
phba->brd_no,
|
|
|
|
|
wwn_to_u64(vport->fc_portname.u.wwn),
|
|
|
|
|
wwn_to_u64(vport->fc_nodename.u.wwn),
|
|
|
|
|
localport->port_id, statep);
|
|
|
|
|
if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
|
2024-06-11 20:26:44 +08:00
|
|
|
goto buffer_done;
|
|
|
|
|
|
|
|
|
|
spin_lock_irq(shost->host_lock);
|
2017-02-13 05:52:30 +08:00
|
|
|
|
2017-06-02 12:06:56 +08:00
|
|
|
list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
|
2018-09-14 06:41:10 +08:00
|
|
|
nrport = NULL;
|
2024-06-11 20:26:44 +08:00
|
|
|
spin_lock(&vport->phba->hbalock);
|
2018-04-10 05:24:27 +08:00
|
|
|
rport = lpfc_ndlp_get_nrport(ndlp);
|
2018-09-14 06:41:10 +08:00
|
|
|
if (rport)
|
|
|
|
|
nrport = rport->remoteport;
|
2024-06-11 20:26:44 +08:00
|
|
|
spin_unlock(&vport->phba->hbalock);
|
2018-04-10 05:24:27 +08:00
|
|
|
if (!nrport)
|
|
|
|
|
continue;
|
2017-02-13 05:52:30 +08:00
|
|
|
|
|
|
|
|
/* Port state is only one of two values for now. */
|
|
|
|
|
switch (nrport->port_state) {
|
|
|
|
|
case FC_OBJSTATE_ONLINE:
|
|
|
|
|
statep = "ONLINE";
|
|
|
|
|
break;
|
|
|
|
|
case FC_OBJSTATE_UNKNOWN:
|
|
|
|
|
statep = "UNKNOWN ";
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
statep = "UNSUPPORTED";
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Tab in to show lport ownership. */
|
2018-06-26 23:24:22 +08:00
|
|
|
if (strlcat(buf, "NVME RPORT ", PAGE_SIZE) >= PAGE_SIZE)
|
2024-06-11 20:26:44 +08:00
|
|
|
goto unlock_buf_done;
|
2018-06-26 23:24:22 +08:00
|
|
|
if (phba->brd_no >= 10) {
|
|
|
|
|
if (strlcat(buf, " ", PAGE_SIZE) >= PAGE_SIZE)
|
2024-06-11 20:26:44 +08:00
|
|
|
goto unlock_buf_done;
|
2018-06-26 23:24:22 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
scnprintf(tmp, sizeof(tmp), "WWPN x%llx ",
|
|
|
|
|
nrport->port_name);
|
|
|
|
|
if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
|
2024-06-11 20:26:44 +08:00
|
|
|
goto unlock_buf_done;
|
2018-06-26 23:24:22 +08:00
|
|
|
|
|
|
|
|
scnprintf(tmp, sizeof(tmp), "WWNN x%llx ",
|
|
|
|
|
nrport->node_name);
|
|
|
|
|
if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
|
2024-06-11 20:26:44 +08:00
|
|
|
goto unlock_buf_done;
|
2018-06-26 23:24:22 +08:00
|
|
|
|
|
|
|
|
scnprintf(tmp, sizeof(tmp), "DID x%06x ",
|
|
|
|
|
nrport->port_id);
|
|
|
|
|
if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
|
2024-06-11 20:26:44 +08:00
|
|
|
goto unlock_buf_done;
|
2017-02-13 05:52:30 +08:00
|
|
|
|
2017-06-02 12:06:57 +08:00
|
|
|
/* An NVME rport can have multiple roles. */
|
2018-06-26 23:24:22 +08:00
|
|
|
if (nrport->port_role & FC_PORT_ROLE_NVME_INITIATOR) {
|
|
|
|
|
if (strlcat(buf, "INITIATOR ", PAGE_SIZE) >= PAGE_SIZE)
|
2024-06-11 20:26:44 +08:00
|
|
|
goto unlock_buf_done;
|
2018-06-26 23:24:22 +08:00
|
|
|
}
|
|
|
|
|
if (nrport->port_role & FC_PORT_ROLE_NVME_TARGET) {
|
|
|
|
|
if (strlcat(buf, "TARGET ", PAGE_SIZE) >= PAGE_SIZE)
|
2024-06-11 20:26:44 +08:00
|
|
|
goto unlock_buf_done;
|
2018-06-26 23:24:22 +08:00
|
|
|
}
|
|
|
|
|
if (nrport->port_role & FC_PORT_ROLE_NVME_DISCOVERY) {
|
|
|
|
|
if (strlcat(buf, "DISCSRVC ", PAGE_SIZE) >= PAGE_SIZE)
|
2024-06-11 20:26:44 +08:00
|
|
|
goto unlock_buf_done;
|
2018-06-26 23:24:22 +08:00
|
|
|
}
|
2017-06-02 12:06:57 +08:00
|
|
|
if (nrport->port_role & ~(FC_PORT_ROLE_NVME_INITIATOR |
|
|
|
|
|
FC_PORT_ROLE_NVME_TARGET |
|
2018-06-26 23:24:22 +08:00
|
|
|
FC_PORT_ROLE_NVME_DISCOVERY)) {
|
|
|
|
|
scnprintf(tmp, sizeof(tmp), "UNKNOWN ROLE x%x",
|
|
|
|
|
nrport->port_role);
|
|
|
|
|
if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
|
2024-06-11 20:26:44 +08:00
|
|
|
goto unlock_buf_done;
|
2018-06-26 23:24:22 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
scnprintf(tmp, sizeof(tmp), "%s\n", statep);
|
|
|
|
|
if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
|
2024-06-11 20:26:44 +08:00
|
|
|
goto unlock_buf_done;
|
2017-02-13 05:52:30 +08:00
|
|
|
}
|
2024-06-11 20:26:44 +08:00
|
|
|
spin_unlock_irq(shost->host_lock);
|
2017-02-13 05:52:30 +08:00
|
|
|
|
2018-04-10 05:24:23 +08:00
|
|
|
if (!lport)
|
2018-06-26 23:24:22 +08:00
|
|
|
goto buffer_done;
|
|
|
|
|
|
|
|
|
|
if (strlcat(buf, "\nNVME Statistics\n", PAGE_SIZE) >= PAGE_SIZE)
|
|
|
|
|
goto buffer_done;
|
|
|
|
|
|
|
|
|
|
scnprintf(tmp, sizeof(tmp),
|
|
|
|
|
"LS: Xmt %010x Cmpl %010x Abort %08x\n",
|
|
|
|
|
atomic_read(&lport->fc4NvmeLsRequests),
|
|
|
|
|
atomic_read(&lport->fc4NvmeLsCmpls),
|
|
|
|
|
atomic_read(&lport->xmt_ls_abort));
|
|
|
|
|
if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
|
|
|
|
|
goto buffer_done;
|
|
|
|
|
|
|
|
|
|
scnprintf(tmp, sizeof(tmp),
|
|
|
|
|
"LS XMIT: Err %08x CMPL: xb %08x Err %08x\n",
|
|
|
|
|
atomic_read(&lport->xmt_ls_err),
|
|
|
|
|
atomic_read(&lport->cmpl_ls_xb),
|
|
|
|
|
atomic_read(&lport->cmpl_ls_err));
|
|
|
|
|
if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
|
|
|
|
|
goto buffer_done;
|
2017-06-02 12:07:02 +08:00
|
|
|
|
2018-04-10 05:24:23 +08:00
|
|
|
totin = 0;
|
|
|
|
|
totout = 0;
|
scsi: lpfc: Replace io_channels for nvme and fcp with general hdw_queues per cpu
Currently, both nvme and fcp each have their own concept of an io_channel,
which is a combination wq/cq and associated msix. Different cpus would
share an io_channel.
The driver is now moving to per-cpu wq/cq pairs and msix vectors. The
driver will still use separate wq/cq pairs per protocol on each cpu, but
the protocols will share the msix vector.
Given the elimination of the nvme and fcp io channels, the module
parameters will be removed. A new parameter, lpfc_hdw_queue is added which
allows the wq/cq pair allocation per cpu to be overridden and allocated to
lesser value. If lpfc_hdw_queue is zero, the number of pairs allocated will
be based on the number of cpus. If non-zero, the parameter specifies the
number of queues to allocate. At this time, the maximum non-zero value is
64.
To manage this new paradigm, a new hardware queue structure is created to
track queue activity and relationships.
As MSIX vector allocation must be known before setting up the
relationships, msix allocation now occurs before queue datastructures are
allocated. If the number of vectors allocated is less than the desired
hardware queues, the hardware queue counts will be reduced to the number of
vectors
Signed-off-by: Dick Kennedy <dick.kennedy@broadcom.com>
Signed-off-by: James Smart <jsmart2021@gmail.com>
Reviewed-by: Hannes Reinecke <hare@suse.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-01-29 03:14:21 +08:00
|
|
|
for (i = 0; i < phba->cfg_hdw_queue; i++) {
|
2019-01-29 03:14:25 +08:00
|
|
|
cstat = &phba->sli4_hba.hdwq[i].nvme_cstat;
|
|
|
|
|
tot = cstat->io_cmpls;
|
2018-04-10 05:24:23 +08:00
|
|
|
totin += tot;
|
2019-01-29 03:14:25 +08:00
|
|
|
data1 = cstat->input_requests;
|
|
|
|
|
data2 = cstat->output_requests;
|
|
|
|
|
data3 = cstat->control_requests;
|
2018-04-10 05:24:23 +08:00
|
|
|
totout += (data1 + data2 + data3);
|
|
|
|
|
}
|
2018-06-26 23:24:22 +08:00
|
|
|
scnprintf(tmp, sizeof(tmp),
|
|
|
|
|
"Total FCP Cmpl %016llx Issue %016llx "
|
|
|
|
|
"OutIO %016llx\n",
|
|
|
|
|
totin, totout, totout - totin);
|
|
|
|
|
if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
|
|
|
|
|
goto buffer_done;
|
|
|
|
|
|
|
|
|
|
scnprintf(tmp, sizeof(tmp),
|
|
|
|
|
"\tabort %08x noxri %08x nondlp %08x qdepth %08x "
|
|
|
|
|
"wqerr %08x err %08x\n",
|
|
|
|
|
atomic_read(&lport->xmt_fcp_abort),
|
|
|
|
|
atomic_read(&lport->xmt_fcp_noxri),
|
|
|
|
|
atomic_read(&lport->xmt_fcp_bad_ndlp),
|
|
|
|
|
atomic_read(&lport->xmt_fcp_qdepth),
|
|
|
|
|
atomic_read(&lport->xmt_fcp_err),
|
|
|
|
|
atomic_read(&lport->xmt_fcp_wqerr));
|
|
|
|
|
if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
|
|
|
|
|
goto buffer_done;
|
|
|
|
|
|
|
|
|
|
scnprintf(tmp, sizeof(tmp),
|
|
|
|
|
"FCP CMPL: xb %08x Err %08x\n",
|
|
|
|
|
atomic_read(&lport->cmpl_fcp_xb),
|
|
|
|
|
atomic_read(&lport->cmpl_fcp_err));
|
|
|
|
|
strlcat(buf, tmp, PAGE_SIZE);
|
|
|
|
|
|
2024-06-11 20:26:44 +08:00
|
|
|
/* host_lock is already unlocked. */
|
2019-05-07 08:26:48 +08:00
|
|
|
goto buffer_done;
|
|
|
|
|
|
2024-06-11 20:26:44 +08:00
|
|
|
unlock_buf_done:
|
|
|
|
|
spin_unlock_irq(shost->host_lock);
|
2019-05-07 08:26:48 +08:00
|
|
|
|
|
|
|
|
buffer_done:
|
2018-06-26 23:24:22 +08:00
|
|
|
len = strnlen(buf, PAGE_SIZE);
|
|
|
|
|
|
|
|
|
|
if (unlikely(len >= (PAGE_SIZE - 1))) {
|
|
|
|
|
lpfc_printf_log(phba, KERN_INFO, LOG_NVME,
|
|
|
|
|
"6314 Catching potential buffer "
|
|
|
|
|
"overflow > PAGE_SIZE = %lu bytes\n",
|
|
|
|
|
PAGE_SIZE);
|
|
|
|
|
strlcpy(buf + PAGE_SIZE - 1 -
|
2024-06-12 13:13:20 +08:00
|
|
|
strnlen(LPFC_NVME_INFO_MORE_STR, PAGE_SIZE - 1),
|
|
|
|
|
LPFC_NVME_INFO_MORE_STR,
|
|
|
|
|
strnlen(LPFC_NVME_INFO_MORE_STR, PAGE_SIZE - 1)
|
2018-06-26 23:24:22 +08:00
|
|
|
+ 1);
|
|
|
|
|
}
|
|
|
|
|
|
2017-02-13 05:52:30 +08:00
|
|
|
return len;
|
|
|
|
|
}
|
|
|
|
|
|
2019-01-29 03:14:25 +08:00
|
|
|
static ssize_t
|
|
|
|
|
lpfc_scsi_stat_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_vport *vport = shost_priv(shost);
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
int len;
|
|
|
|
|
struct lpfc_fc4_ctrl_stat *cstat;
|
|
|
|
|
u64 data1, data2, data3;
|
|
|
|
|
u64 tot, totin, totout;
|
|
|
|
|
int i;
|
|
|
|
|
char tmp[LPFC_MAX_SCSI_INFO_TMP_LEN] = {0};
|
|
|
|
|
|
2019-01-29 03:14:38 +08:00
|
|
|
if (!(vport->cfg_enable_fc4_type & LPFC_ENABLE_FCP) ||
|
2019-01-29 03:14:25 +08:00
|
|
|
(phba->sli_rev != LPFC_SLI_REV4))
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
scnprintf(buf, PAGE_SIZE, "SCSI HDWQ Statistics\n");
|
|
|
|
|
|
|
|
|
|
totin = 0;
|
|
|
|
|
totout = 0;
|
|
|
|
|
for (i = 0; i < phba->cfg_hdw_queue; i++) {
|
|
|
|
|
cstat = &phba->sli4_hba.hdwq[i].scsi_cstat;
|
|
|
|
|
tot = cstat->io_cmpls;
|
|
|
|
|
totin += tot;
|
|
|
|
|
data1 = cstat->input_requests;
|
|
|
|
|
data2 = cstat->output_requests;
|
|
|
|
|
data3 = cstat->control_requests;
|
|
|
|
|
totout += (data1 + data2 + data3);
|
|
|
|
|
|
|
|
|
|
scnprintf(tmp, sizeof(tmp), "HDWQ (%d): Rd %016llx Wr %016llx "
|
|
|
|
|
"IO %016llx ", i, data1, data2, data3);
|
|
|
|
|
if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
|
|
|
|
|
goto buffer_done;
|
|
|
|
|
|
|
|
|
|
scnprintf(tmp, sizeof(tmp), "Cmpl %016llx OutIO %016llx\n",
|
|
|
|
|
tot, ((data1 + data2 + data3) - tot));
|
|
|
|
|
if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
|
|
|
|
|
goto buffer_done;
|
|
|
|
|
}
|
|
|
|
|
scnprintf(tmp, sizeof(tmp), "Total FCP Cmpl %016llx Issue %016llx "
|
|
|
|
|
"OutIO %016llx\n", totin, totout, totout - totin);
|
|
|
|
|
strlcat(buf, tmp, PAGE_SIZE);
|
|
|
|
|
|
|
|
|
|
buffer_done:
|
|
|
|
|
len = strnlen(buf, PAGE_SIZE);
|
|
|
|
|
|
|
|
|
|
return len;
|
|
|
|
|
}
|
|
|
|
|
|
2008-12-05 11:39:46 +08:00
|
|
|
static ssize_t
|
|
|
|
|
lpfc_bg_info_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
if (phba->cfg_enable_bg) {
|
2008-12-05 11:39:46 +08:00
|
|
|
if (phba->sli3_options & LPFC_SLI3_BG_ENABLED)
|
2024-06-12 13:13:20 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE,
|
|
|
|
|
"BlockGuard Enabled\n");
|
2008-12-05 11:39:46 +08:00
|
|
|
else
|
2024-06-12 13:13:20 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE,
|
2008-12-05 11:39:46 +08:00
|
|
|
"BlockGuard Not Supported\n");
|
2024-06-12 13:13:20 +08:00
|
|
|
} else
|
|
|
|
|
return scnprintf(buf, PAGE_SIZE,
|
2008-12-05 11:39:46 +08:00
|
|
|
"BlockGuard Disabled\n");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_bg_guard_err_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%llu\n",
|
2008-12-16 23:34:09 +08:00
|
|
|
(unsigned long long)phba->bg_guard_err_cnt);
|
2008-12-05 11:39:46 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_bg_apptag_err_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%llu\n",
|
2008-12-16 23:34:09 +08:00
|
|
|
(unsigned long long)phba->bg_apptag_err_cnt);
|
2008-12-05 11:39:46 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_bg_reftag_err_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%llu\n",
|
2008-12-16 23:34:09 +08:00
|
|
|
(unsigned long long)phba->bg_reftag_err_cnt);
|
2008-12-05 11:39:46 +08:00
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_info_show - Return some pci info about the host in ascii
|
2008-08-25 09:49:00 +08:00
|
|
|
* @dev: class converted to a Scsi_host structure.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: on return contains the formatted text from lpfc_info().
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_info_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *host = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%s\n", lpfc_info(host));
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_serialnum_show - Return the hba serial number in ascii
|
2008-08-25 09:49:00 +08:00
|
|
|
* @dev: class converted to a Scsi_host structure.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: on return contains the formatted text serial number.
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_serialnum_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%s\n", phba->SerialNumber);
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_temp_sensor_show - Return the temperature sensor level
|
2008-08-25 09:49:00 +08:00
|
|
|
* @dev: class converted to a Scsi_host structure.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: on return contains the formatted support level.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* Returns a number indicating the temperature sensor level currently
|
|
|
|
|
* supported, zero or one in ascii.
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
2007-10-28 01:37:05 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_temp_sensor_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
2007-10-28 01:37:05 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-10-28 01:37:05 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
2024-06-12 13:13:20 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", phba->temp_sensor_support);
|
2007-10-28 01:37:05 +08:00
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_modeldesc_show - Return the model description of the hba
|
2008-08-25 09:49:00 +08:00
|
|
|
* @dev: class converted to a Scsi_host structure.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: on return contains the scsi vpd model description.
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_modeldesc_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%s\n", phba->ModelDesc);
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_modelname_show - Return the model name of the hba
|
2008-08-25 09:49:00 +08:00
|
|
|
* @dev: class converted to a Scsi_host structure.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: on return contains the scsi vpd model name.
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_modelname_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%s\n", phba->ModelName);
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_programtype_show - Return the program type of the hba
|
2008-08-25 09:49:00 +08:00
|
|
|
* @dev: class converted to a Scsi_host structure.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: on return contains the scsi vpd program type.
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_programtype_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%s\n", phba->ProgramType);
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:50:06 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_mlomgmt_show - Return the Menlo Maintenance sli flag
|
2008-08-25 09:50:06 +08:00
|
|
|
* @dev: class converted to a Scsi_host structure.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: on return contains the Menlo Maintenance sli flag.
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_mlomgmt_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n",
|
2008-08-25 09:50:06 +08:00
|
|
|
(phba->sli.sli_flag & LPFC_MENLO_MAINT));
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_vportnum_show - Return the port number in ascii of the hba
|
2008-08-25 09:49:00 +08:00
|
|
|
* @dev: class converted to a Scsi_host structure.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: on return contains scsi vpd program type.
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_vportnum_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%s\n", phba->Port);
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_fwrev_show - Return the firmware rev running in the hba
|
2008-08-25 09:49:00 +08:00
|
|
|
* @dev: class converted to a Scsi_host structure.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: on return contains the scsi vpd program type.
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_fwrev_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
2011-12-14 02:20:45 +08:00
|
|
|
uint32_t if_type;
|
|
|
|
|
uint8_t sli_family;
|
2012-01-19 05:24:06 +08:00
|
|
|
char fwrev[FW_REV_STR_SIZE];
|
2011-12-14 02:20:45 +08:00
|
|
|
int len;
|
2007-06-18 08:56:36 +08:00
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
lpfc_decode_firmware_rev(phba, fwrev, 1);
|
2011-12-14 02:20:45 +08:00
|
|
|
if_type = phba->sli4_hba.pc_sli4_params.if_type;
|
|
|
|
|
sli_family = phba->sli4_hba.pc_sli4_params.sli_family;
|
|
|
|
|
|
|
|
|
|
if (phba->sli_rev < LPFC_SLI_REV4)
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
len = scnprintf(buf, PAGE_SIZE, "%s, sli-%d\n",
|
2011-12-14 02:20:45 +08:00
|
|
|
fwrev, phba->sli_rev);
|
|
|
|
|
else
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
len = scnprintf(buf, PAGE_SIZE, "%s, sli-%d:%d:%x\n",
|
2011-12-14 02:20:45 +08:00
|
|
|
fwrev, phba->sli_rev, if_type, sli_family);
|
|
|
|
|
|
|
|
|
|
return len;
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_hdw_show - Return the jedec information about the hba
|
2008-08-25 09:49:00 +08:00
|
|
|
* @dev: class converted to a Scsi_host structure.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: on return contains the scsi vpd program type.
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_hdw_show(struct device *dev, struct device_attribute *attr, char *buf)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
|
|
|
|
char hdw[9];
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
2005-04-18 05:05:31 +08:00
|
|
|
lpfc_vpd_t *vp = &phba->vpd;
|
2007-06-18 08:56:36 +08:00
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
lpfc_jedec_to_ascii(vp->rev.biuRev, hdw);
|
2019-08-15 07:57:07 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%s %08x %08x\n", hdw,
|
|
|
|
|
vp->rev.smRev, vp->rev.smFwRev);
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
2008-08-25 09:49:00 +08:00
|
|
|
|
|
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_option_rom_version_show - Return the adapter ROM FCode version
|
2008-08-25 09:49:00 +08:00
|
|
|
* @dev: class converted to a Scsi_host structure.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: on return contains the ROM and FCode ascii strings.
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_option_rom_version_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
2015-04-08 03:07:16 +08:00
|
|
|
char fwrev[FW_REV_STR_SIZE];
|
|
|
|
|
|
|
|
|
|
if (phba->sli_rev < LPFC_SLI_REV4)
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%s\n",
|
2024-06-12 13:13:20 +08:00
|
|
|
phba->OptionROMVersion);
|
2007-06-18 08:56:36 +08:00
|
|
|
|
2015-04-08 03:07:16 +08:00
|
|
|
lpfc_decode_firmware_rev(phba, fwrev, 1);
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%s\n", fwrev);
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
2008-08-25 09:49:00 +08:00
|
|
|
|
|
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_state_show - Return the link state of the port
|
2008-08-25 09:49:00 +08:00
|
|
|
* @dev: class converted to a Scsi_host structure.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: on return contains text describing the state of the link.
|
|
|
|
|
*
|
|
|
|
|
* Notes:
|
|
|
|
|
* The switch statement has no default so zero will be returned.
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static ssize_t
|
2008-03-18 21:32:28 +08:00
|
|
|
lpfc_link_state_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
int len = 0;
|
|
|
|
|
|
|
|
|
|
switch (phba->link_state) {
|
|
|
|
|
case LPFC_LINK_UNKNOWN:
|
2006-03-01 08:25:27 +08:00
|
|
|
case LPFC_WARM_START:
|
2005-04-18 05:05:31 +08:00
|
|
|
case LPFC_INIT_START:
|
|
|
|
|
case LPFC_INIT_MBX_CMDS:
|
|
|
|
|
case LPFC_LINK_DOWN:
|
2007-06-18 08:56:36 +08:00
|
|
|
case LPFC_HBA_ERROR:
|
2009-07-19 22:01:10 +08:00
|
|
|
if (phba->hba_flag & LINK_DISABLED)
|
2024-06-12 13:13:20 +08:00
|
|
|
len += scnprintf(buf + len, PAGE_SIZE-len,
|
2009-07-19 22:01:10 +08:00
|
|
|
"Link Down - User disabled\n");
|
|
|
|
|
else
|
2024-06-12 13:13:20 +08:00
|
|
|
len += scnprintf(buf + len, PAGE_SIZE-len,
|
2009-07-19 22:01:10 +08:00
|
|
|
"Link Down\n");
|
2005-04-18 05:05:31 +08:00
|
|
|
break;
|
|
|
|
|
case LPFC_LINK_UP:
|
|
|
|
|
case LPFC_CLEAR_LA:
|
|
|
|
|
case LPFC_HBA_READY:
|
2024-06-12 13:13:20 +08:00
|
|
|
len += scnprintf(buf + len, PAGE_SIZE-len, "Link Up - ");
|
2007-06-18 08:56:36 +08:00
|
|
|
|
|
|
|
|
switch (vport->port_state) {
|
|
|
|
|
case LPFC_LOCAL_CFG_LINK:
|
2024-06-12 13:13:20 +08:00
|
|
|
len += scnprintf(buf + len, PAGE_SIZE-len,
|
2007-06-18 08:56:38 +08:00
|
|
|
"Configuring Link\n");
|
2007-06-18 08:56:36 +08:00
|
|
|
break;
|
2007-06-18 08:56:38 +08:00
|
|
|
case LPFC_FDISC:
|
2007-06-18 08:56:36 +08:00
|
|
|
case LPFC_FLOGI:
|
|
|
|
|
case LPFC_FABRIC_CFG_LINK:
|
|
|
|
|
case LPFC_NS_REG:
|
|
|
|
|
case LPFC_NS_QRY:
|
|
|
|
|
case LPFC_BUILD_DISC_LIST:
|
|
|
|
|
case LPFC_DISC_AUTH:
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
len += scnprintf(buf + len, PAGE_SIZE - len,
|
2007-06-18 08:56:36 +08:00
|
|
|
"Discovery\n");
|
|
|
|
|
break;
|
|
|
|
|
case LPFC_VPORT_READY:
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
len += scnprintf(buf + len, PAGE_SIZE - len,
|
2024-06-12 13:13:20 +08:00
|
|
|
"Ready\n");
|
2007-06-18 08:56:36 +08:00
|
|
|
break;
|
|
|
|
|
|
2007-06-18 08:56:38 +08:00
|
|
|
case LPFC_VPORT_FAILED:
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
len += scnprintf(buf + len, PAGE_SIZE - len,
|
2024-06-12 13:13:20 +08:00
|
|
|
"Failed\n");
|
2007-06-18 08:56:38 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case LPFC_VPORT_UNKNOWN:
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
len += scnprintf(buf + len, PAGE_SIZE - len,
|
2007-06-18 08:56:36 +08:00
|
|
|
"Unknown\n");
|
|
|
|
|
break;
|
|
|
|
|
}
|
2008-08-25 09:50:06 +08:00
|
|
|
if (phba->sli.sli_flag & LPFC_MENLO_MAINT)
|
2024-06-12 13:13:20 +08:00
|
|
|
len += scnprintf(buf + len, PAGE_SIZE-len,
|
2008-08-25 09:50:06 +08:00
|
|
|
" Menlo Maint Mode\n");
|
2010-11-21 12:11:48 +08:00
|
|
|
else if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
|
2007-06-18 08:56:36 +08:00
|
|
|
if (vport->fc_flag & FC_PUBLIC_LOOP)
|
2024-06-12 13:13:20 +08:00
|
|
|
len += scnprintf(buf + len, PAGE_SIZE-len,
|
2005-04-18 05:05:31 +08:00
|
|
|
" Public Loop\n");
|
|
|
|
|
else
|
2024-06-12 13:13:20 +08:00
|
|
|
len += scnprintf(buf + len, PAGE_SIZE-len,
|
2005-04-18 05:05:31 +08:00
|
|
|
" Private Loop\n");
|
|
|
|
|
} else {
|
2007-06-18 08:56:36 +08:00
|
|
|
if (vport->fc_flag & FC_FABRIC)
|
2024-06-12 13:13:20 +08:00
|
|
|
len += scnprintf(buf + len, PAGE_SIZE-len,
|
2005-04-18 05:05:31 +08:00
|
|
|
" Fabric\n");
|
|
|
|
|
else
|
2024-06-12 13:13:20 +08:00
|
|
|
len += scnprintf(buf + len, PAGE_SIZE-len,
|
2005-04-18 05:05:31 +08:00
|
|
|
" Point-2-Point\n");
|
|
|
|
|
}
|
|
|
|
|
}
|
2007-06-18 08:56:36 +08:00
|
|
|
|
2018-10-24 04:41:11 +08:00
|
|
|
if ((phba->sli_rev == LPFC_SLI_REV4) &&
|
|
|
|
|
((bf_get(lpfc_sli_intf_if_type,
|
|
|
|
|
&phba->sli4_hba.sli_intf) ==
|
|
|
|
|
LPFC_SLI_INTF_IF_TYPE_6))) {
|
|
|
|
|
struct lpfc_trunk_link link = phba->trunk_link;
|
|
|
|
|
|
|
|
|
|
if (bf_get(lpfc_conf_trunk_port0, &phba->sli4_hba))
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
len += scnprintf(buf + len, PAGE_SIZE - len,
|
2018-10-24 04:41:11 +08:00
|
|
|
"Trunk port 0: Link %s %s\n",
|
|
|
|
|
(link.link0.state == LPFC_LINK_UP) ?
|
|
|
|
|
"Up" : "Down. ",
|
|
|
|
|
trunk_errmsg[link.link0.fault]);
|
|
|
|
|
|
|
|
|
|
if (bf_get(lpfc_conf_trunk_port1, &phba->sli4_hba))
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
len += scnprintf(buf + len, PAGE_SIZE - len,
|
2018-10-24 04:41:11 +08:00
|
|
|
"Trunk port 1: Link %s %s\n",
|
|
|
|
|
(link.link1.state == LPFC_LINK_UP) ?
|
|
|
|
|
"Up" : "Down. ",
|
|
|
|
|
trunk_errmsg[link.link1.fault]);
|
|
|
|
|
|
|
|
|
|
if (bf_get(lpfc_conf_trunk_port2, &phba->sli4_hba))
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
len += scnprintf(buf + len, PAGE_SIZE - len,
|
2018-10-24 04:41:11 +08:00
|
|
|
"Trunk port 2: Link %s %s\n",
|
|
|
|
|
(link.link2.state == LPFC_LINK_UP) ?
|
|
|
|
|
"Up" : "Down. ",
|
|
|
|
|
trunk_errmsg[link.link2.fault]);
|
|
|
|
|
|
|
|
|
|
if (bf_get(lpfc_conf_trunk_port3, &phba->sli4_hba))
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
len += scnprintf(buf + len, PAGE_SIZE - len,
|
2018-10-24 04:41:11 +08:00
|
|
|
"Trunk port 3: Link %s %s\n",
|
|
|
|
|
(link.link3.state == LPFC_LINK_UP) ?
|
|
|
|
|
"Up" : "Down. ",
|
|
|
|
|
trunk_errmsg[link.link3.fault]);
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
return len;
|
|
|
|
|
}
|
|
|
|
|
|
2011-12-14 02:20:45 +08:00
|
|
|
/**
|
|
|
|
|
* lpfc_sli4_protocol_show - Return the fip mode of the HBA
|
|
|
|
|
* @dev: class unused variable.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: on return contains the module description text.
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_sli4_protocol_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
|
|
|
|
|
if (phba->sli_rev < LPFC_SLI_REV4)
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "fc\n");
|
2011-12-14 02:20:45 +08:00
|
|
|
|
|
|
|
|
if (phba->sli4_hba.lnk_info.lnk_dv == LPFC_LNK_DAT_VAL) {
|
|
|
|
|
if (phba->sli4_hba.lnk_info.lnk_tp == LPFC_LNK_TYPE_GE)
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "fcoe\n");
|
2011-12-14 02:20:45 +08:00
|
|
|
if (phba->sli4_hba.lnk_info.lnk_tp == LPFC_LNK_TYPE_FC)
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "fc\n");
|
2011-12-14 02:20:45 +08:00
|
|
|
}
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "unknown\n");
|
2011-12-14 02:20:45 +08:00
|
|
|
}
|
|
|
|
|
|
2014-02-20 22:56:45 +08:00
|
|
|
/**
|
|
|
|
|
* lpfc_oas_supported_show - Return whether or not Optimized Access Storage
|
|
|
|
|
* (OAS) is supported.
|
|
|
|
|
* @dev: class unused variable.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: on return contains the module description text.
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_oas_supported_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n",
|
2014-02-20 22:56:45 +08:00
|
|
|
phba->sli4_hba.pc_sli4_params.oas_supported);
|
|
|
|
|
}
|
|
|
|
|
|
2010-02-13 03:42:33 +08:00
|
|
|
/**
|
|
|
|
|
* lpfc_link_state_store - Transition the link_state on an HBA port
|
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: one or more lpfc_polling_flags values.
|
|
|
|
|
* @count: not used.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* -EINVAL if the buffer is not "up" or "down"
|
|
|
|
|
* return from link state change function if non-zero
|
|
|
|
|
* length of the buf on success
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_link_state_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
const char *buf, size_t count)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
|
|
|
|
|
int status = -EINVAL;
|
|
|
|
|
|
|
|
|
|
if ((strncmp(buf, "up", sizeof("up") - 1) == 0) &&
|
|
|
|
|
(phba->link_state == LPFC_LINK_DOWN))
|
2024-06-12 13:13:20 +08:00
|
|
|
status = phba->lpfc_hba_init_link(phba, MBX_NOWAIT);
|
2010-02-13 03:42:33 +08:00
|
|
|
else if ((strncmp(buf, "down", sizeof("down") - 1) == 0) &&
|
|
|
|
|
(phba->link_state >= LPFC_LINK_UP))
|
2024-06-12 13:13:20 +08:00
|
|
|
status = phba->lpfc_hba_down_link(phba, MBX_NOWAIT);
|
2010-02-13 03:42:33 +08:00
|
|
|
|
|
|
|
|
if (status == 0)
|
|
|
|
|
return strlen(buf);
|
|
|
|
|
else
|
|
|
|
|
return status;
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_num_discovered_ports_show - Return sum of mapped and unmapped vports
|
2008-08-25 09:49:00 +08:00
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: on return contains the sum of fc mapped and unmapped.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* Returns the ascii text number of the sum of the fc mapped and unmapped
|
|
|
|
|
* vport counts.
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_num_discovered_ports_show(struct device *dev,
|
|
|
|
|
struct device_attribute *attr, char *buf)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n",
|
2007-06-18 08:56:36 +08:00
|
|
|
vport->fc_map_cnt + vport->fc_unmap_cnt);
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_issue_lip - Misnomer, name carried over from long ago
|
2008-08-25 09:49:00 +08:00
|
|
|
* @shost: Scsi_Host pointer.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* Bring the link down gracefully then re-init the link. The firmware will
|
|
|
|
|
* re-init the fiber channel interface as required. Does not issue a LIP.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* -EPERM port offline or management commands are being blocked
|
|
|
|
|
* -ENOMEM cannot allocate memory for the mailbox command
|
|
|
|
|
* -EIO error sending the mailbox command
|
|
|
|
|
* zero for success
|
|
|
|
|
**/
|
2024-06-12 13:13:20 +08:00
|
|
|
static int
|
2007-06-18 08:56:36 +08:00
|
|
|
lpfc_issue_lip(struct Scsi_Host *shost)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
2005-04-18 05:05:31 +08:00
|
|
|
LPFC_MBOXQ_t *pmboxq;
|
|
|
|
|
int mbxstatus = MBXERR_ERROR;
|
|
|
|
|
|
2018-01-31 07:58:55 +08:00
|
|
|
/*
|
|
|
|
|
* If the link is offline, disabled or BLOCK_MGMT_IO
|
|
|
|
|
* it doesn't make any sense to allow issue_lip
|
|
|
|
|
*/
|
2007-06-18 08:56:36 +08:00
|
|
|
if ((vport->fc_flag & FC_OFFLINE_MODE) ||
|
2018-01-31 07:58:55 +08:00
|
|
|
(phba->hba_flag & LINK_DISABLED) ||
|
2008-01-11 14:53:09 +08:00
|
|
|
(phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO))
|
2005-04-18 05:05:31 +08:00
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
|
|
pmboxq = mempool_alloc(phba->mbox_mem_pool,GFP_KERNEL);
|
|
|
|
|
|
|
|
|
|
if (!pmboxq)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
memset((void *)pmboxq, 0, sizeof (LPFC_MBOXQ_t));
|
2009-05-23 02:52:52 +08:00
|
|
|
pmboxq->u.mb.mbxCommand = MBX_DOWN_LINK;
|
|
|
|
|
pmboxq->u.mb.mbxOwner = OWN_HOST;
|
2006-07-07 03:49:49 +08:00
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
if ((vport->fc_flag & FC_PT2PT) && (vport->fc_flag & FC_PT2PT_NO_NVME))
|
|
|
|
|
vport->fc_flag &= ~FC_PT2PT_NO_NVME;
|
|
|
|
|
|
2006-08-17 23:57:58 +08:00
|
|
|
mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq, LPFC_MBOX_TMO * 2);
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2009-05-23 02:52:52 +08:00
|
|
|
if ((mbxstatus == MBX_SUCCESS) &&
|
|
|
|
|
(pmboxq->u.mb.mbxStatus == 0 ||
|
|
|
|
|
pmboxq->u.mb.mbxStatus == MBXERR_LINK_DOWN)) {
|
2006-07-07 03:49:49 +08:00
|
|
|
memset((void *)pmboxq, 0, sizeof (LPFC_MBOXQ_t));
|
|
|
|
|
lpfc_init_link(phba, pmboxq, phba->cfg_topology,
|
|
|
|
|
phba->cfg_link_speed);
|
|
|
|
|
mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq,
|
|
|
|
|
phba->fc_ratov * 2);
|
2010-09-29 23:18:53 +08:00
|
|
|
if ((mbxstatus == MBX_SUCCESS) &&
|
|
|
|
|
(pmboxq->u.mb.mbxStatus == MBXERR_SEC_NO_PERMISSION))
|
|
|
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
|
|
|
|
|
"2859 SLI authentication is required "
|
|
|
|
|
"for INIT_LINK but has not done yet\n");
|
2006-07-07 03:49:49 +08:00
|
|
|
}
|
|
|
|
|
|
2007-04-25 21:52:49 +08:00
|
|
|
lpfc_set_loopback_flag(phba);
|
2007-06-18 08:56:39 +08:00
|
|
|
if (mbxstatus != MBX_TIMEOUT)
|
2005-10-29 08:28:56 +08:00
|
|
|
mempool_free(pmboxq, phba->mbox_mem_pool);
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
|
if (mbxstatus == MBXERR_ERROR)
|
|
|
|
|
return -EIO;
|
|
|
|
|
|
2005-10-28 07:03:37 +08:00
|
|
|
return 0;
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
|
2017-02-13 05:52:30 +08:00
|
|
|
int
|
|
|
|
|
lpfc_emptyq_wait(struct lpfc_hba *phba, struct list_head *q, spinlock_t *lock)
|
|
|
|
|
{
|
|
|
|
|
int cnt = 0;
|
|
|
|
|
|
|
|
|
|
spin_lock_irq(lock);
|
|
|
|
|
while (!list_empty(q)) {
|
|
|
|
|
spin_unlock_irq(lock);
|
|
|
|
|
msleep(20);
|
|
|
|
|
if (cnt++ > 250) { /* 5 secs */
|
|
|
|
|
lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
|
|
|
|
|
"0466 %s %s\n",
|
|
|
|
|
"Outstanding IO when ",
|
2024-06-12 13:13:20 +08:00
|
|
|
"bringing Adapter offline\n");
|
2017-02-13 05:52:30 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
spin_lock_irq(lock);
|
|
|
|
|
}
|
|
|
|
|
spin_unlock_irq(lock);
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_do_offline - Issues a mailbox command to bring the link down
|
2008-08-25 09:49:00 +08:00
|
|
|
* @phba: lpfc_hba pointer.
|
|
|
|
|
* @type: LPFC_EVT_OFFLINE, LPFC_EVT_WARM_START, LPFC_EVT_KILL.
|
|
|
|
|
*
|
|
|
|
|
* Notes:
|
|
|
|
|
* Assumes any error from lpfc_do_offline() will be negative.
|
|
|
|
|
* Can wait up to 5 seconds for the port ring buffers count
|
|
|
|
|
* to reach zero, prints a warning if it is not zero and continues.
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_workq_post_event() returns a non-zero return code if call fails.
|
2008-08-25 09:49:00 +08:00
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* -EIO error posting the event
|
|
|
|
|
* zero for success
|
|
|
|
|
**/
|
2006-07-07 03:50:22 +08:00
|
|
|
static int
|
2007-04-25 21:51:45 +08:00
|
|
|
lpfc_do_offline(struct lpfc_hba *phba, uint32_t type)
|
2006-07-07 03:50:22 +08:00
|
|
|
{
|
|
|
|
|
struct completion online_compl;
|
2017-02-13 05:52:30 +08:00
|
|
|
struct lpfc_queue *qp = NULL;
|
2007-04-25 21:51:45 +08:00
|
|
|
struct lpfc_sli_ring *pring;
|
|
|
|
|
struct lpfc_sli *psli;
|
2006-07-07 03:50:22 +08:00
|
|
|
int status = 0;
|
2007-04-25 21:51:45 +08:00
|
|
|
int i;
|
2011-02-17 01:39:24 +08:00
|
|
|
int rc;
|
2006-07-07 03:50:22 +08:00
|
|
|
|
|
|
|
|
init_completion(&online_compl);
|
2011-02-17 01:39:24 +08:00
|
|
|
rc = lpfc_workq_post_event(phba, &status, &online_compl,
|
2007-04-25 21:51:45 +08:00
|
|
|
LPFC_EVT_OFFLINE_PREP);
|
2011-02-17 01:39:24 +08:00
|
|
|
if (rc == 0)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
2007-04-25 21:51:45 +08:00
|
|
|
wait_for_completion(&online_compl);
|
|
|
|
|
|
|
|
|
|
if (status != 0)
|
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
|
|
psli = &phba->sli;
|
|
|
|
|
|
scsi: lpfc: Coordinate adapter error handling with offline handling
The driver periodically checks for adapter error in a background thread. If
the thread detects an error, the adapter will be reset including the
deletion and reallocation of workqueues on the adapter. Simultaneously,
there may be a user-space request to offline the adapter which may try to
do many of the same steps, in parallel, on a different thread. As memory
was deallocated while unexpected, the parallel offline request hit a bad
pointer.
Add coordination between the two threads. The error recovery thread has
precedence. So, when an error is detected, a flag is set on the adapter to
indicate the error thread is terminating the adapter. But, before doing
that work, it will look for a flag that is set by the offline flow, and if
set, will wait for it to complete before then processing the error handling
path. Similarly, in the offline thread, it first checks for whether the
error thread is resetting the adapter, and if so, will then wait for the
error thread to finish. Only after it has finished, will it set its flag
and offline the adapter.
Signed-off-by: Dick Kennedy <dick.kennedy@broadcom.com>
Signed-off-by: James Smart <jsmart2021@gmail.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-13 07:30:14 +08:00
|
|
|
/*
|
|
|
|
|
* If freeing the queues have already started, don't access them.
|
|
|
|
|
* Otherwise set FREE_WAIT to indicate that queues are being used
|
|
|
|
|
* to hold the freeing process until we finish.
|
|
|
|
|
*/
|
|
|
|
|
spin_lock_irq(&phba->hbalock);
|
|
|
|
|
if (!(psli->sli_flag & LPFC_QUEUE_FREE_INIT)) {
|
|
|
|
|
psli->sli_flag |= LPFC_QUEUE_FREE_WAIT;
|
|
|
|
|
} else {
|
|
|
|
|
spin_unlock_irq(&phba->hbalock);
|
|
|
|
|
goto skip_wait;
|
|
|
|
|
}
|
|
|
|
|
spin_unlock_irq(&phba->hbalock);
|
|
|
|
|
|
2008-01-11 14:52:54 +08:00
|
|
|
/* Wait a little for things to settle down, but not
|
|
|
|
|
* long enough for dev loss timeout to expire.
|
|
|
|
|
*/
|
2017-02-13 05:52:30 +08:00
|
|
|
if (phba->sli_rev != LPFC_SLI_REV4) {
|
|
|
|
|
for (i = 0; i < psli->num_rings; i++) {
|
|
|
|
|
pring = &psli->sli3_ring[i];
|
|
|
|
|
if (!lpfc_emptyq_wait(phba, &pring->txcmplq,
|
|
|
|
|
&phba->hbalock))
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
list_for_each_entry(qp, &phba->sli4_hba.lpfc_wq_list, wq_list) {
|
|
|
|
|
pring = qp->pring;
|
|
|
|
|
if (!pring)
|
|
|
|
|
continue;
|
|
|
|
|
if (!lpfc_emptyq_wait(phba, &pring->txcmplq,
|
|
|
|
|
&pring->ring_lock))
|
|
|
|
|
goto out;
|
2007-04-25 21:51:45 +08:00
|
|
|
}
|
|
|
|
|
}
|
2017-02-13 05:52:30 +08:00
|
|
|
out:
|
scsi: lpfc: Coordinate adapter error handling with offline handling
The driver periodically checks for adapter error in a background thread. If
the thread detects an error, the adapter will be reset including the
deletion and reallocation of workqueues on the adapter. Simultaneously,
there may be a user-space request to offline the adapter which may try to
do many of the same steps, in parallel, on a different thread. As memory
was deallocated while unexpected, the parallel offline request hit a bad
pointer.
Add coordination between the two threads. The error recovery thread has
precedence. So, when an error is detected, a flag is set on the adapter to
indicate the error thread is terminating the adapter. But, before doing
that work, it will look for a flag that is set by the offline flow, and if
set, will wait for it to complete before then processing the error handling
path. Similarly, in the offline thread, it first checks for whether the
error thread is resetting the adapter, and if so, will then wait for the
error thread to finish. Only after it has finished, will it set its flag
and offline the adapter.
Signed-off-by: Dick Kennedy <dick.kennedy@broadcom.com>
Signed-off-by: James Smart <jsmart2021@gmail.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-13 07:30:14 +08:00
|
|
|
spin_lock_irq(&phba->hbalock);
|
|
|
|
|
psli->sli_flag &= ~LPFC_QUEUE_FREE_WAIT;
|
|
|
|
|
spin_unlock_irq(&phba->hbalock);
|
|
|
|
|
|
|
|
|
|
skip_wait:
|
2007-04-25 21:51:45 +08:00
|
|
|
init_completion(&online_compl);
|
2011-02-17 01:39:24 +08:00
|
|
|
rc = lpfc_workq_post_event(phba, &status, &online_compl, type);
|
|
|
|
|
if (rc == 0)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
2006-07-07 03:50:22 +08:00
|
|
|
wait_for_completion(&online_compl);
|
|
|
|
|
|
|
|
|
|
if (status != 0)
|
|
|
|
|
return -EIO;
|
|
|
|
|
|
2007-04-25 21:51:45 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2018-12-14 07:17:57 +08:00
|
|
|
/**
|
|
|
|
|
* lpfc_reset_pci_bus - resets PCI bridge controller's secondary bus of an HBA
|
|
|
|
|
* @phba: lpfc_hba pointer.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* Issues a PCI secondary bus reset for the phba->pcidev.
|
|
|
|
|
*
|
|
|
|
|
* Notes:
|
|
|
|
|
* First walks the bus_list to ensure only PCI devices with Emulex
|
|
|
|
|
* vendor id, device ids that support hot reset, only one occurrence
|
|
|
|
|
* of function 0, and all ports on the bus are in offline mode to ensure the
|
|
|
|
|
* hot reset only affects one valid HBA.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* -ENOTSUPP, cfg_enable_hba_reset must be of value 2
|
|
|
|
|
* -ENODEV, NULL ptr to pcidev
|
|
|
|
|
* -EBADSLT, detected invalid device
|
|
|
|
|
* -EBUSY, port is not in offline state
|
|
|
|
|
* 0, successful
|
|
|
|
|
*/
|
2019-03-29 02:06:16 +08:00
|
|
|
static int
|
2018-12-14 07:17:57 +08:00
|
|
|
lpfc_reset_pci_bus(struct lpfc_hba *phba)
|
|
|
|
|
{
|
|
|
|
|
struct pci_dev *pdev = phba->pcidev;
|
|
|
|
|
struct Scsi_Host *shost = NULL;
|
|
|
|
|
struct lpfc_hba *phba_other = NULL;
|
|
|
|
|
struct pci_dev *ptr = NULL;
|
|
|
|
|
int res;
|
|
|
|
|
|
|
|
|
|
if (phba->cfg_enable_hba_reset != 2)
|
|
|
|
|
return -ENOTSUPP;
|
|
|
|
|
|
|
|
|
|
if (!pdev) {
|
|
|
|
|
lpfc_printf_log(phba, KERN_INFO, LOG_INIT, "8345 pdev NULL!\n");
|
|
|
|
|
return -ENODEV;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
res = lpfc_check_pci_resettable(phba);
|
|
|
|
|
if (res)
|
|
|
|
|
return res;
|
|
|
|
|
|
|
|
|
|
/* Walk the list of devices on the pci_dev's bus */
|
|
|
|
|
list_for_each_entry(ptr, &pdev->bus->devices, bus_list) {
|
|
|
|
|
/* Check port is offline */
|
|
|
|
|
shost = pci_get_drvdata(ptr);
|
|
|
|
|
if (shost) {
|
|
|
|
|
phba_other =
|
|
|
|
|
((struct lpfc_vport *)shost->hostdata)->phba;
|
|
|
|
|
if (!(phba_other->pport->fc_flag & FC_OFFLINE_MODE)) {
|
|
|
|
|
lpfc_printf_log(phba_other, KERN_INFO, LOG_INIT,
|
|
|
|
|
"8349 WWPN = 0x%02x%02x%02x%02x"
|
|
|
|
|
"%02x%02x%02x%02x is not "
|
|
|
|
|
"offline!\n",
|
|
|
|
|
phba_other->wwpn[0],
|
|
|
|
|
phba_other->wwpn[1],
|
|
|
|
|
phba_other->wwpn[2],
|
|
|
|
|
phba_other->wwpn[3],
|
|
|
|
|
phba_other->wwpn[4],
|
|
|
|
|
phba_other->wwpn[5],
|
|
|
|
|
phba_other->wwpn[6],
|
|
|
|
|
phba_other->wwpn[7]);
|
|
|
|
|
return -EBUSY;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Issue PCI bus reset */
|
|
|
|
|
res = pci_reset_bus(pdev);
|
|
|
|
|
if (res) {
|
|
|
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
|
|
|
|
|
"8350 PCI reset bus failed: %d\n", res);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return res;
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_selective_reset - Offline then onlines the port
|
2008-08-25 09:49:00 +08:00
|
|
|
* @phba: lpfc_hba pointer.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* If the port is configured to allow a reset then the hba is brought
|
|
|
|
|
* offline then online.
|
|
|
|
|
*
|
|
|
|
|
* Notes:
|
|
|
|
|
* Assumes any error from lpfc_do_offline() will be negative.
|
2011-02-17 01:39:57 +08:00
|
|
|
* Do not make this function static.
|
2008-08-25 09:49:00 +08:00
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* lpfc_do_offline() return code if not zero
|
|
|
|
|
* -EIO reset not configured or error posting the event
|
|
|
|
|
* zero for success
|
|
|
|
|
**/
|
2011-03-12 05:05:52 +08:00
|
|
|
int
|
2007-04-25 21:51:45 +08:00
|
|
|
lpfc_selective_reset(struct lpfc_hba *phba)
|
|
|
|
|
{
|
|
|
|
|
struct completion online_compl;
|
|
|
|
|
int status = 0;
|
2011-02-17 01:39:24 +08:00
|
|
|
int rc;
|
2007-04-25 21:51:45 +08:00
|
|
|
|
2013-07-16 06:34:36 +08:00
|
|
|
if (!phba->cfg_enable_hba_reset)
|
2011-08-22 09:49:16 +08:00
|
|
|
return -EACCES;
|
2008-01-11 14:52:48 +08:00
|
|
|
|
2013-07-16 06:34:36 +08:00
|
|
|
if (!(phba->pport->fc_flag & FC_OFFLINE_MODE)) {
|
|
|
|
|
status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
|
2007-04-25 21:51:45 +08:00
|
|
|
|
2013-07-16 06:34:36 +08:00
|
|
|
if (status != 0)
|
|
|
|
|
return status;
|
|
|
|
|
}
|
2007-04-25 21:51:45 +08:00
|
|
|
|
2006-07-07 03:50:22 +08:00
|
|
|
init_completion(&online_compl);
|
2011-02-17 01:39:24 +08:00
|
|
|
rc = lpfc_workq_post_event(phba, &status, &online_compl,
|
2006-07-07 03:50:22 +08:00
|
|
|
LPFC_EVT_ONLINE);
|
2011-02-17 01:39:24 +08:00
|
|
|
if (rc == 0)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
2006-07-07 03:50:22 +08:00
|
|
|
wait_for_completion(&online_compl);
|
|
|
|
|
|
|
|
|
|
if (status != 0)
|
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_issue_reset - Selectively resets an adapter
|
2008-08-25 09:49:00 +08:00
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: containing the string "selective".
|
|
|
|
|
* @count: unused variable.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* If the buf contains the string "selective" then lpfc_selective_reset()
|
|
|
|
|
* is called to perform the reset.
|
|
|
|
|
*
|
|
|
|
|
* Notes:
|
|
|
|
|
* Assumes any error from lpfc_selective_reset() will be negative.
|
|
|
|
|
* If lpfc_selective_reset() returns zero then the length of the buffer
|
tree-wide: fix assorted typos all over the place
That is "success", "unknown", "through", "performance", "[re|un]mapping"
, "access", "default", "reasonable", "[con]currently", "temperature"
, "channel", "[un]used", "application", "example","hierarchy", "therefore"
, "[over|under]flow", "contiguous", "threshold", "enough" and others.
Signed-off-by: André Goddard Rosa <andre.goddard@gmail.com>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2009-11-14 23:09:05 +08:00
|
|
|
* is returned which indicates success
|
2008-08-25 09:49:00 +08:00
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* -EINVAL if the buffer does not contain the string "selective"
|
|
|
|
|
* length of buf if lpfc-selective_reset() if the call succeeds
|
|
|
|
|
* return value of lpfc_selective_reset() if the call fails
|
|
|
|
|
**/
|
2006-07-07 03:50:22 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_issue_reset(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
const char *buf, size_t count)
|
2006-07-07 03:50:22 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
2006-07-07 03:50:22 +08:00
|
|
|
int status = -EINVAL;
|
|
|
|
|
|
2011-10-11 09:32:10 +08:00
|
|
|
if (!phba->cfg_enable_hba_reset)
|
|
|
|
|
return -EACCES;
|
|
|
|
|
|
2006-07-07 03:50:22 +08:00
|
|
|
if (strncmp(buf, "selective", sizeof("selective") - 1) == 0)
|
2011-03-12 05:05:52 +08:00
|
|
|
status = phba->lpfc_selective_reset(phba);
|
2006-07-07 03:50:22 +08:00
|
|
|
|
|
|
|
|
if (status == 0)
|
|
|
|
|
return strlen(buf);
|
|
|
|
|
else
|
|
|
|
|
return status;
|
|
|
|
|
}
|
|
|
|
|
|
2011-07-23 06:36:33 +08:00
|
|
|
/**
|
|
|
|
|
* lpfc_sli4_pdev_status_reg_wait - Wait for pdev status register for readyness
|
|
|
|
|
* @phba: lpfc_hba pointer.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* SLI4 interface type-2 device to wait on the sliport status register for
|
|
|
|
|
* the readyness after performing a firmware reset.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
2013-07-17 03:37:44 +08:00
|
|
|
* zero for success, -EPERM when port does not have privilege to perform the
|
2011-12-14 02:20:45 +08:00
|
|
|
* reset, -EIO when port timeout from recovering from the reset.
|
|
|
|
|
*
|
|
|
|
|
* Note:
|
|
|
|
|
* As the caller will interpret the return code by value, be careful in making
|
|
|
|
|
* change or addition to return codes.
|
2011-07-23 06:36:33 +08:00
|
|
|
**/
|
2011-10-11 09:32:10 +08:00
|
|
|
int
|
2011-07-23 06:36:33 +08:00
|
|
|
lpfc_sli4_pdev_status_reg_wait(struct lpfc_hba *phba)
|
|
|
|
|
{
|
2011-08-22 09:49:16 +08:00
|
|
|
struct lpfc_register portstat_reg = {0};
|
2011-07-23 06:36:33 +08:00
|
|
|
int i;
|
|
|
|
|
|
2011-08-22 09:49:16 +08:00
|
|
|
msleep(100);
|
2024-06-12 13:13:20 +08:00
|
|
|
lpfc_readl(phba->sli4_hba.u.if_type2.STATUSregaddr,
|
|
|
|
|
&portstat_reg.word0);
|
2011-07-23 06:36:33 +08:00
|
|
|
|
2013-07-17 03:37:44 +08:00
|
|
|
/* verify if privileged for the request operation */
|
2011-08-22 09:49:16 +08:00
|
|
|
if (!bf_get(lpfc_sliport_status_rn, &portstat_reg) &&
|
|
|
|
|
!bf_get(lpfc_sliport_status_err, &portstat_reg))
|
|
|
|
|
return -EPERM;
|
|
|
|
|
|
2011-07-23 06:36:33 +08:00
|
|
|
/* wait for the SLI port firmware ready after firmware reset */
|
|
|
|
|
for (i = 0; i < LPFC_FW_RESET_MAXIMUM_WAIT_10MS_CNT; i++) {
|
|
|
|
|
msleep(10);
|
2024-06-12 13:13:20 +08:00
|
|
|
lpfc_readl(phba->sli4_hba.u.if_type2.STATUSregaddr,
|
|
|
|
|
&portstat_reg.word0);
|
2011-07-23 06:36:33 +08:00
|
|
|
if (!bf_get(lpfc_sliport_status_err, &portstat_reg))
|
|
|
|
|
continue;
|
|
|
|
|
if (!bf_get(lpfc_sliport_status_rn, &portstat_reg))
|
|
|
|
|
continue;
|
|
|
|
|
if (!bf_get(lpfc_sliport_status_rdy, &portstat_reg))
|
|
|
|
|
continue;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (i < LPFC_FW_RESET_MAXIMUM_WAIT_10MS_CNT)
|
|
|
|
|
return 0;
|
|
|
|
|
else
|
|
|
|
|
return -EIO;
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-24 23:41:34 +08:00
|
|
|
/**
|
2011-05-24 23:42:45 +08:00
|
|
|
* lpfc_sli4_pdev_reg_request - Request physical dev to perform a register acc
|
2011-05-24 23:41:34 +08:00
|
|
|
* @phba: lpfc_hba pointer.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
2011-05-24 23:42:45 +08:00
|
|
|
* Request SLI4 interface type-2 device to perform a physical register set
|
|
|
|
|
* access.
|
2011-05-24 23:41:34 +08:00
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* zero for success
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
2011-05-24 23:42:45 +08:00
|
|
|
lpfc_sli4_pdev_reg_request(struct lpfc_hba *phba, uint32_t opcode)
|
2011-05-24 23:41:34 +08:00
|
|
|
{
|
|
|
|
|
struct completion online_compl;
|
2011-07-23 06:37:42 +08:00
|
|
|
struct pci_dev *pdev = phba->pcidev;
|
2011-12-14 02:20:45 +08:00
|
|
|
uint32_t before_fc_flag;
|
|
|
|
|
uint32_t sriov_nr_virtfn;
|
2011-05-24 23:41:34 +08:00
|
|
|
uint32_t reg_val;
|
2011-12-14 02:20:45 +08:00
|
|
|
int status = 0, rc = 0;
|
|
|
|
|
int job_posted = 1, sriov_err;
|
2011-05-24 23:41:34 +08:00
|
|
|
|
|
|
|
|
if (!phba->cfg_enable_hba_reset)
|
2011-08-22 09:49:16 +08:00
|
|
|
return -EACCES;
|
2011-05-24 23:41:34 +08:00
|
|
|
|
2011-05-24 23:42:45 +08:00
|
|
|
if ((phba->sli_rev < LPFC_SLI_REV4) ||
|
2018-12-11 11:37:01 +08:00
|
|
|
(bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) <
|
2011-05-24 23:42:45 +08:00
|
|
|
LPFC_SLI_INTF_IF_TYPE_2))
|
|
|
|
|
return -EPERM;
|
|
|
|
|
|
2011-12-14 02:20:45 +08:00
|
|
|
/* Keep state if we need to restore back */
|
|
|
|
|
before_fc_flag = phba->pport->fc_flag;
|
|
|
|
|
sriov_nr_virtfn = phba->cfg_sriov_nr_virtfn;
|
|
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
if (opcode == LPFC_FW_DUMP) {
|
|
|
|
|
init_completion(&online_compl);
|
|
|
|
|
phba->fw_dump_cmpl = &online_compl;
|
|
|
|
|
} else {
|
|
|
|
|
/* Disable SR-IOV virtual functions if enabled */
|
|
|
|
|
if (phba->cfg_sriov_nr_virtfn) {
|
|
|
|
|
pci_disable_sriov(pdev);
|
|
|
|
|
phba->cfg_sriov_nr_virtfn = 0;
|
|
|
|
|
}
|
2013-04-18 08:16:51 +08:00
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
|
2014-04-05 01:52:12 +08:00
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
if (status != 0)
|
|
|
|
|
return status;
|
2011-05-24 23:41:34 +08:00
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
/* wait for the device to be quiesced before firmware reset */
|
|
|
|
|
msleep(100);
|
2014-04-05 01:52:12 +08:00
|
|
|
}
|
2011-05-24 23:41:34 +08:00
|
|
|
|
|
|
|
|
reg_val = readl(phba->sli4_hba.conf_regs_memmap_p +
|
|
|
|
|
LPFC_CTL_PDEV_CTL_OFFSET);
|
2011-05-24 23:42:45 +08:00
|
|
|
|
|
|
|
|
if (opcode == LPFC_FW_DUMP)
|
|
|
|
|
reg_val |= LPFC_FW_DUMP_REQUEST;
|
|
|
|
|
else if (opcode == LPFC_FW_RESET)
|
|
|
|
|
reg_val |= LPFC_CTL_PDEV_CTL_FRST;
|
|
|
|
|
else if (opcode == LPFC_DV_RESET)
|
|
|
|
|
reg_val |= LPFC_CTL_PDEV_CTL_DRST;
|
|
|
|
|
|
2011-05-24 23:41:34 +08:00
|
|
|
writel(reg_val, phba->sli4_hba.conf_regs_memmap_p +
|
|
|
|
|
LPFC_CTL_PDEV_CTL_OFFSET);
|
|
|
|
|
/* flush */
|
|
|
|
|
readl(phba->sli4_hba.conf_regs_memmap_p + LPFC_CTL_PDEV_CTL_OFFSET);
|
|
|
|
|
|
|
|
|
|
/* delay driver action following IF_TYPE_2 reset */
|
2011-07-23 06:36:33 +08:00
|
|
|
rc = lpfc_sli4_pdev_status_reg_wait(phba);
|
|
|
|
|
|
2011-12-14 02:20:45 +08:00
|
|
|
if (rc == -EPERM) {
|
2013-07-17 03:37:44 +08:00
|
|
|
/* no privilege for reset */
|
2012-01-19 05:24:06 +08:00
|
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
|
2013-07-17 03:37:44 +08:00
|
|
|
"3150 No privilege to perform the requested "
|
2012-01-19 05:24:06 +08:00
|
|
|
"access: x%x\n", reg_val);
|
2011-12-14 02:20:45 +08:00
|
|
|
} else if (rc == -EIO) {
|
|
|
|
|
/* reset failed, there is nothing more we can do */
|
2012-01-19 05:24:06 +08:00
|
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
|
|
|
|
|
"3153 Fail to perform the requested "
|
|
|
|
|
"access: x%x\n", reg_val);
|
2024-06-12 13:13:20 +08:00
|
|
|
if (phba->fw_dump_cmpl)
|
|
|
|
|
phba->fw_dump_cmpl = NULL;
|
2011-08-22 09:49:16 +08:00
|
|
|
return rc;
|
2011-12-14 02:20:45 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* keep the original port state */
|
2024-06-12 13:13:20 +08:00
|
|
|
if (before_fc_flag & FC_OFFLINE_MODE) {
|
|
|
|
|
if (phba->fw_dump_cmpl)
|
|
|
|
|
phba->fw_dump_cmpl = NULL;
|
2011-12-14 02:20:45 +08:00
|
|
|
goto out;
|
2024-06-12 13:13:20 +08:00
|
|
|
}
|
2011-05-24 23:41:34 +08:00
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
/* Firmware dump will trigger an HA_ERATT event, and
|
|
|
|
|
* lpfc_handle_eratt_s4 routine already handles bringing the port back
|
|
|
|
|
* online.
|
|
|
|
|
*/
|
|
|
|
|
if (opcode == LPFC_FW_DUMP) {
|
|
|
|
|
wait_for_completion(phba->fw_dump_cmpl);
|
|
|
|
|
} else {
|
|
|
|
|
init_completion(&online_compl);
|
|
|
|
|
job_posted = lpfc_workq_post_event(phba, &status, &online_compl,
|
|
|
|
|
LPFC_EVT_ONLINE);
|
|
|
|
|
if (!job_posted)
|
|
|
|
|
goto out;
|
2011-05-24 23:41:34 +08:00
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
wait_for_completion(&online_compl);
|
|
|
|
|
}
|
2011-12-14 02:20:45 +08:00
|
|
|
out:
|
|
|
|
|
/* in any case, restore the virtual functions enabled as before */
|
|
|
|
|
if (sriov_nr_virtfn) {
|
2024-06-12 13:13:20 +08:00
|
|
|
/* If fw_dump was performed, first disable to clean up */
|
|
|
|
|
if (opcode == LPFC_FW_DUMP) {
|
|
|
|
|
pci_disable_sriov(pdev);
|
|
|
|
|
phba->cfg_sriov_nr_virtfn = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
sriov_err =
|
2011-12-14 02:20:45 +08:00
|
|
|
lpfc_sli_probe_sriov_nr_virtfn(phba, sriov_nr_virtfn);
|
|
|
|
|
if (!sriov_err)
|
|
|
|
|
phba->cfg_sriov_nr_virtfn = sriov_nr_virtfn;
|
|
|
|
|
}
|
2011-05-24 23:41:34 +08:00
|
|
|
|
2011-12-14 02:20:45 +08:00
|
|
|
/* return proper error code */
|
|
|
|
|
if (!rc) {
|
|
|
|
|
if (!job_posted)
|
|
|
|
|
rc = -ENOMEM;
|
|
|
|
|
else if (status)
|
|
|
|
|
rc = -EIO;
|
|
|
|
|
}
|
|
|
|
|
return rc;
|
2011-05-24 23:41:34 +08:00
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_nport_evt_cnt_show - Return the number of nport events
|
2008-08-25 09:49:00 +08:00
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: on return contains the ascii number of nport events.
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_nport_evt_cnt_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", phba->nport_event_cnt);
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
|
2019-03-29 02:06:16 +08:00
|
|
|
static int
|
2018-10-24 04:41:11 +08:00
|
|
|
lpfc_set_trunking(struct lpfc_hba *phba, char *buff_out)
|
|
|
|
|
{
|
|
|
|
|
LPFC_MBOXQ_t *mbox = NULL;
|
|
|
|
|
unsigned long val = 0;
|
|
|
|
|
char *pval = 0;
|
|
|
|
|
int rc = 0;
|
|
|
|
|
|
|
|
|
|
if (!strncmp("enable", buff_out,
|
|
|
|
|
strlen("enable"))) {
|
|
|
|
|
pval = buff_out + strlen("enable") + 1;
|
|
|
|
|
rc = kstrtoul(pval, 0, &val);
|
|
|
|
|
if (rc)
|
|
|
|
|
return rc; /* Invalid number */
|
|
|
|
|
} else if (!strncmp("disable", buff_out,
|
|
|
|
|
strlen("disable"))) {
|
|
|
|
|
val = 0;
|
|
|
|
|
} else {
|
|
|
|
|
return -EINVAL; /* Invalid command */
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
switch (val) {
|
|
|
|
|
case 0:
|
|
|
|
|
val = 0x0; /* Disable */
|
|
|
|
|
break;
|
|
|
|
|
case 2:
|
|
|
|
|
val = 0x1; /* Enable two port trunk */
|
|
|
|
|
break;
|
|
|
|
|
case 4:
|
|
|
|
|
val = 0x2; /* Enable four port trunk */
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
|
|
|
|
|
"0070 Set trunk mode with val %ld ", val);
|
|
|
|
|
|
|
|
|
|
mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
|
|
|
|
|
if (!mbox)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_FCOE,
|
|
|
|
|
LPFC_MBOX_OPCODE_FCOE_FC_SET_TRUNK_MODE,
|
|
|
|
|
12, LPFC_SLI4_MBX_EMBED);
|
|
|
|
|
|
|
|
|
|
bf_set(lpfc_mbx_set_trunk_mode,
|
|
|
|
|
&mbox->u.mqe.un.set_trunk_mode,
|
|
|
|
|
val);
|
|
|
|
|
rc = lpfc_sli_issue_mbox(phba, mbox, MBX_POLL);
|
|
|
|
|
if (rc)
|
|
|
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
|
|
|
|
|
"0071 Set trunk mode failed with status: %d",
|
|
|
|
|
rc);
|
2024-06-12 13:13:20 +08:00
|
|
|
mempool_free(mbox, phba->mbox_mem_pool);
|
2018-10-24 04:41:11 +08:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_board_mode_show - Return the state of the board
|
2008-08-25 09:49:00 +08:00
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: on return contains the state of the adapter.
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
2006-03-01 08:25:27 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_board_mode_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
2006-03-01 08:25:27 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
2006-03-01 08:25:27 +08:00
|
|
|
char * state;
|
|
|
|
|
|
2007-06-18 08:56:36 +08:00
|
|
|
if (phba->link_state == LPFC_HBA_ERROR)
|
2006-03-01 08:25:27 +08:00
|
|
|
state = "error";
|
2007-06-18 08:56:36 +08:00
|
|
|
else if (phba->link_state == LPFC_WARM_START)
|
2006-03-01 08:25:27 +08:00
|
|
|
state = "warm start";
|
2007-06-18 08:56:36 +08:00
|
|
|
else if (phba->link_state == LPFC_INIT_START)
|
2006-03-01 08:25:27 +08:00
|
|
|
state = "offline";
|
|
|
|
|
else
|
|
|
|
|
state = "online";
|
|
|
|
|
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%s\n", state);
|
2006-03-01 08:25:27 +08:00
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_board_mode_store - Puts the hba in online, offline, warm or error state
|
2008-08-25 09:49:00 +08:00
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: containing one of the strings "online", "offline", "warm" or "error".
|
|
|
|
|
* @count: unused variable.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* -EACCES if enable hba reset not enabled
|
|
|
|
|
* -EINVAL if the buffer does not contain a valid string (see above)
|
|
|
|
|
* -EIO if lpfc_workq_post_event() or lpfc_do_offline() fails
|
|
|
|
|
* buf length greater than zero indicates success
|
|
|
|
|
**/
|
2006-03-01 08:25:27 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_board_mode_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
const char *buf, size_t count)
|
2006-03-01 08:25:27 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
2006-03-01 08:25:27 +08:00
|
|
|
struct completion online_compl;
|
2011-12-14 02:20:45 +08:00
|
|
|
char *board_mode_str = NULL;
|
|
|
|
|
int status = 0;
|
2011-02-17 01:39:24 +08:00
|
|
|
int rc;
|
2006-03-01 08:25:27 +08:00
|
|
|
|
2011-12-14 02:20:45 +08:00
|
|
|
if (!phba->cfg_enable_hba_reset) {
|
|
|
|
|
status = -EACCES;
|
|
|
|
|
goto board_mode_out;
|
|
|
|
|
}
|
2011-07-23 06:36:33 +08:00
|
|
|
|
|
|
|
|
lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
|
2011-12-14 02:20:45 +08:00
|
|
|
"3050 lpfc_board_mode set to %s\n", buf);
|
2011-07-23 06:36:33 +08:00
|
|
|
|
2006-03-01 08:25:27 +08:00
|
|
|
init_completion(&online_compl);
|
|
|
|
|
|
2007-04-25 21:51:45 +08:00
|
|
|
if(strncmp(buf, "online", sizeof("online") - 1) == 0) {
|
2011-02-17 01:39:24 +08:00
|
|
|
rc = lpfc_workq_post_event(phba, &status, &online_compl,
|
2006-03-01 08:25:27 +08:00
|
|
|
LPFC_EVT_ONLINE);
|
2011-12-14 02:20:45 +08:00
|
|
|
if (rc == 0) {
|
|
|
|
|
status = -ENOMEM;
|
|
|
|
|
goto board_mode_out;
|
|
|
|
|
}
|
2007-04-25 21:51:45 +08:00
|
|
|
wait_for_completion(&online_compl);
|
2017-06-02 12:07:03 +08:00
|
|
|
if (status)
|
|
|
|
|
status = -EIO;
|
2007-04-25 21:51:45 +08:00
|
|
|
} else if (strncmp(buf, "offline", sizeof("offline") - 1) == 0)
|
|
|
|
|
status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
|
2006-03-01 08:25:27 +08:00
|
|
|
else if (strncmp(buf, "warm", sizeof("warm") - 1) == 0)
|
2009-10-03 03:16:51 +08:00
|
|
|
if (phba->sli_rev == LPFC_SLI_REV4)
|
2011-12-14 02:20:45 +08:00
|
|
|
status = -EINVAL;
|
2009-10-03 03:16:51 +08:00
|
|
|
else
|
|
|
|
|
status = lpfc_do_offline(phba, LPFC_EVT_WARM_START);
|
2007-04-25 21:51:45 +08:00
|
|
|
else if (strncmp(buf, "error", sizeof("error") - 1) == 0)
|
2009-10-03 03:16:51 +08:00
|
|
|
if (phba->sli_rev == LPFC_SLI_REV4)
|
2011-12-14 02:20:45 +08:00
|
|
|
status = -EINVAL;
|
2009-10-03 03:16:51 +08:00
|
|
|
else
|
|
|
|
|
status = lpfc_do_offline(phba, LPFC_EVT_KILL);
|
2011-05-24 23:41:34 +08:00
|
|
|
else if (strncmp(buf, "dump", sizeof("dump") - 1) == 0)
|
2011-05-24 23:42:45 +08:00
|
|
|
status = lpfc_sli4_pdev_reg_request(phba, LPFC_FW_DUMP);
|
|
|
|
|
else if (strncmp(buf, "fw_reset", sizeof("fw_reset") - 1) == 0)
|
|
|
|
|
status = lpfc_sli4_pdev_reg_request(phba, LPFC_FW_RESET);
|
|
|
|
|
else if (strncmp(buf, "dv_reset", sizeof("dv_reset") - 1) == 0)
|
|
|
|
|
status = lpfc_sli4_pdev_reg_request(phba, LPFC_DV_RESET);
|
2018-12-14 07:17:57 +08:00
|
|
|
else if (strncmp(buf, "pci_bus_reset", sizeof("pci_bus_reset") - 1)
|
|
|
|
|
== 0)
|
|
|
|
|
status = lpfc_reset_pci_bus(phba);
|
2018-10-24 04:41:11 +08:00
|
|
|
else if (strncmp(buf, "trunk", sizeof("trunk") - 1) == 0)
|
|
|
|
|
status = lpfc_set_trunking(phba, (char *)buf + sizeof("trunk"));
|
2006-03-01 08:25:27 +08:00
|
|
|
else
|
2011-12-14 02:20:45 +08:00
|
|
|
status = -EINVAL;
|
2006-03-01 08:25:27 +08:00
|
|
|
|
2011-12-14 02:20:45 +08:00
|
|
|
board_mode_out:
|
2006-03-01 08:25:27 +08:00
|
|
|
if (!status)
|
|
|
|
|
return strlen(buf);
|
2011-12-14 02:20:45 +08:00
|
|
|
else {
|
|
|
|
|
board_mode_str = strchr(buf, '\n');
|
|
|
|
|
if (board_mode_str)
|
|
|
|
|
*board_mode_str = '\0';
|
|
|
|
|
lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
|
|
|
|
|
"3097 Failed \"%s\", status(%d), "
|
|
|
|
|
"fc_flag(x%x)\n",
|
|
|
|
|
buf, status, phba->pport->fc_flag);
|
2011-08-22 09:49:16 +08:00
|
|
|
return status;
|
2011-12-14 02:20:45 +08:00
|
|
|
}
|
2006-03-01 08:25:27 +08:00
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_get_hba_info - Return various bits of informaton about the adapter
|
2008-08-25 09:49:00 +08:00
|
|
|
* @phba: pointer to the adapter structure.
|
2009-04-07 06:47:14 +08:00
|
|
|
* @mxri: max xri count.
|
|
|
|
|
* @axri: available xri count.
|
|
|
|
|
* @mrpi: max rpi count.
|
|
|
|
|
* @arpi: available rpi count.
|
|
|
|
|
* @mvpi: max vpi count.
|
|
|
|
|
* @avpi: available vpi count.
|
2008-08-25 09:49:00 +08:00
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* If an integer pointer for an count is not null then the value for the
|
|
|
|
|
* count is returned.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* zero on error
|
|
|
|
|
* one for success
|
|
|
|
|
**/
|
2007-08-02 23:10:37 +08:00
|
|
|
static int
|
2007-06-18 08:56:39 +08:00
|
|
|
lpfc_get_hba_info(struct lpfc_hba *phba,
|
|
|
|
|
uint32_t *mxri, uint32_t *axri,
|
|
|
|
|
uint32_t *mrpi, uint32_t *arpi,
|
|
|
|
|
uint32_t *mvpi, uint32_t *avpi)
|
2007-06-18 08:56:38 +08:00
|
|
|
{
|
2009-05-23 02:52:52 +08:00
|
|
|
struct lpfc_mbx_read_config *rd_config;
|
2007-06-18 08:56:38 +08:00
|
|
|
LPFC_MBOXQ_t *pmboxq;
|
|
|
|
|
MAILBOX_t *pmb;
|
|
|
|
|
int rc = 0;
|
2010-04-07 02:49:03 +08:00
|
|
|
uint32_t max_vpi;
|
2007-06-18 08:56:38 +08:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* prevent udev from issuing mailbox commands until the port is
|
|
|
|
|
* configured.
|
|
|
|
|
*/
|
|
|
|
|
if (phba->link_state < LPFC_LINK_DOWN ||
|
|
|
|
|
!phba->mbox_mem_pool ||
|
2009-05-23 02:53:12 +08:00
|
|
|
(phba->sli.sli_flag & LPFC_SLI_ACTIVE) == 0)
|
2007-06-18 08:56:38 +08:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
|
|
|
|
|
if (!pmboxq)
|
|
|
|
|
return 0;
|
|
|
|
|
memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
|
|
|
|
|
|
2009-05-23 02:52:52 +08:00
|
|
|
pmb = &pmboxq->u.mb;
|
2007-06-18 08:56:38 +08:00
|
|
|
pmb->mbxCommand = MBX_READ_CONFIG;
|
|
|
|
|
pmb->mbxOwner = OWN_HOST;
|
2018-11-30 08:09:29 +08:00
|
|
|
pmboxq->ctx_buf = NULL;
|
2007-06-18 08:56:38 +08:00
|
|
|
|
2010-06-09 06:31:21 +08:00
|
|
|
if (phba->pport->fc_flag & FC_OFFLINE_MODE)
|
2007-06-18 08:56:38 +08:00
|
|
|
rc = MBX_NOT_FINISHED;
|
|
|
|
|
else
|
|
|
|
|
rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
|
|
|
|
|
|
|
|
|
|
if (rc != MBX_SUCCESS) {
|
2007-06-18 08:56:39 +08:00
|
|
|
if (rc != MBX_TIMEOUT)
|
2007-06-18 08:56:38 +08:00
|
|
|
mempool_free(pmboxq, phba->mbox_mem_pool);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2009-05-23 02:51:39 +08:00
|
|
|
if (phba->sli_rev == LPFC_SLI_REV4) {
|
|
|
|
|
rd_config = &pmboxq->u.mqe.un.rd_config;
|
|
|
|
|
if (mrpi)
|
|
|
|
|
*mrpi = bf_get(lpfc_mbx_rd_conf_rpi_count, rd_config);
|
|
|
|
|
if (arpi)
|
|
|
|
|
*arpi = bf_get(lpfc_mbx_rd_conf_rpi_count, rd_config) -
|
|
|
|
|
phba->sli4_hba.max_cfg_param.rpi_used;
|
|
|
|
|
if (mxri)
|
|
|
|
|
*mxri = bf_get(lpfc_mbx_rd_conf_xri_count, rd_config);
|
|
|
|
|
if (axri)
|
|
|
|
|
*axri = bf_get(lpfc_mbx_rd_conf_xri_count, rd_config) -
|
|
|
|
|
phba->sli4_hba.max_cfg_param.xri_used;
|
2010-04-07 02:49:03 +08:00
|
|
|
|
|
|
|
|
/* Account for differences with SLI-3. Get vpi count from
|
|
|
|
|
* mailbox data and subtract one for max vpi value.
|
|
|
|
|
*/
|
|
|
|
|
max_vpi = (bf_get(lpfc_mbx_rd_conf_vpi_count, rd_config) > 0) ?
|
|
|
|
|
(bf_get(lpfc_mbx_rd_conf_vpi_count, rd_config) - 1) : 0;
|
|
|
|
|
|
2018-11-30 08:09:33 +08:00
|
|
|
/* Limit the max we support */
|
|
|
|
|
if (max_vpi > LPFC_MAX_VPI)
|
|
|
|
|
max_vpi = LPFC_MAX_VPI;
|
2009-05-23 02:51:39 +08:00
|
|
|
if (mvpi)
|
2010-04-07 02:49:03 +08:00
|
|
|
*mvpi = max_vpi;
|
2009-05-23 02:51:39 +08:00
|
|
|
if (avpi)
|
2010-04-07 02:49:03 +08:00
|
|
|
*avpi = max_vpi - phba->sli4_hba.max_cfg_param.vpi_used;
|
2009-05-23 02:51:39 +08:00
|
|
|
} else {
|
|
|
|
|
if (mrpi)
|
|
|
|
|
*mrpi = pmb->un.varRdConfig.max_rpi;
|
|
|
|
|
if (arpi)
|
|
|
|
|
*arpi = pmb->un.varRdConfig.avail_rpi;
|
|
|
|
|
if (mxri)
|
|
|
|
|
*mxri = pmb->un.varRdConfig.max_xri;
|
|
|
|
|
if (axri)
|
|
|
|
|
*axri = pmb->un.varRdConfig.avail_xri;
|
|
|
|
|
if (mvpi)
|
|
|
|
|
*mvpi = pmb->un.varRdConfig.max_vpi;
|
2018-11-30 08:09:33 +08:00
|
|
|
if (avpi) {
|
|
|
|
|
/* avail_vpi is only valid if link is up and ready */
|
|
|
|
|
if (phba->link_state == LPFC_HBA_READY)
|
|
|
|
|
*avpi = pmb->un.varRdConfig.avail_vpi;
|
|
|
|
|
else
|
|
|
|
|
*avpi = pmb->un.varRdConfig.max_vpi;
|
|
|
|
|
}
|
2009-05-23 02:51:39 +08:00
|
|
|
}
|
2007-06-18 08:56:38 +08:00
|
|
|
|
|
|
|
|
mempool_free(pmboxq, phba->mbox_mem_pool);
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_max_rpi_show - Return maximum rpi
|
2008-08-25 09:49:00 +08:00
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: on return contains the maximum rpi count in decimal or "Unknown".
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* Calls lpfc_get_hba_info() asking for just the mrpi count.
|
|
|
|
|
* If lpfc_get_hba_info() returns zero (failure) the buffer text is set
|
|
|
|
|
* to "Unknown" and the buffer length is returned, therefore the caller
|
|
|
|
|
* must check for "Unknown" in the buffer to detect a failure.
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
2007-06-18 08:56:38 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_max_rpi_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
2007-06-18 08:56:38 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:38 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
uint32_t cnt;
|
|
|
|
|
|
2007-06-18 08:56:39 +08:00
|
|
|
if (lpfc_get_hba_info(phba, NULL, NULL, &cnt, NULL, NULL, NULL))
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", cnt);
|
|
|
|
|
return scnprintf(buf, PAGE_SIZE, "Unknown\n");
|
2007-06-18 08:56:38 +08:00
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_used_rpi_show - Return maximum rpi minus available rpi
|
2008-08-25 09:49:00 +08:00
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: containing the used rpi count in decimal or "Unknown".
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* Calls lpfc_get_hba_info() asking for just the mrpi and arpi counts.
|
|
|
|
|
* If lpfc_get_hba_info() returns zero (failure) the buffer text is set
|
|
|
|
|
* to "Unknown" and the buffer length is returned, therefore the caller
|
|
|
|
|
* must check for "Unknown" in the buffer to detect a failure.
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
2007-06-18 08:56:38 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_used_rpi_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
2007-06-18 08:56:38 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:38 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
uint32_t cnt, acnt;
|
|
|
|
|
|
2007-06-18 08:56:39 +08:00
|
|
|
if (lpfc_get_hba_info(phba, NULL, NULL, &cnt, &acnt, NULL, NULL))
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
|
|
|
|
|
return scnprintf(buf, PAGE_SIZE, "Unknown\n");
|
2007-06-18 08:56:38 +08:00
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_max_xri_show - Return maximum xri
|
2008-08-25 09:49:00 +08:00
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: on return contains the maximum xri count in decimal or "Unknown".
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* Calls lpfc_get_hba_info() asking for just the mrpi count.
|
|
|
|
|
* If lpfc_get_hba_info() returns zero (failure) the buffer text is set
|
|
|
|
|
* to "Unknown" and the buffer length is returned, therefore the caller
|
|
|
|
|
* must check for "Unknown" in the buffer to detect a failure.
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
2007-06-18 08:56:38 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_max_xri_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
2007-06-18 08:56:38 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:38 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
uint32_t cnt;
|
|
|
|
|
|
2007-06-18 08:56:39 +08:00
|
|
|
if (lpfc_get_hba_info(phba, &cnt, NULL, NULL, NULL, NULL, NULL))
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", cnt);
|
|
|
|
|
return scnprintf(buf, PAGE_SIZE, "Unknown\n");
|
2007-06-18 08:56:38 +08:00
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_used_xri_show - Return maximum xpi minus the available xpi
|
2008-08-25 09:49:00 +08:00
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: on return contains the used xri count in decimal or "Unknown".
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* Calls lpfc_get_hba_info() asking for just the mxri and axri counts.
|
|
|
|
|
* If lpfc_get_hba_info() returns zero (failure) the buffer text is set
|
|
|
|
|
* to "Unknown" and the buffer length is returned, therefore the caller
|
|
|
|
|
* must check for "Unknown" in the buffer to detect a failure.
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
2007-06-18 08:56:38 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_used_xri_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
2007-06-18 08:56:38 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:38 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
uint32_t cnt, acnt;
|
|
|
|
|
|
2007-06-18 08:56:39 +08:00
|
|
|
if (lpfc_get_hba_info(phba, &cnt, &acnt, NULL, NULL, NULL, NULL))
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
|
|
|
|
|
return scnprintf(buf, PAGE_SIZE, "Unknown\n");
|
2007-06-18 08:56:39 +08:00
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_max_vpi_show - Return maximum vpi
|
2008-08-25 09:49:00 +08:00
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: on return contains the maximum vpi count in decimal or "Unknown".
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* Calls lpfc_get_hba_info() asking for just the mvpi count.
|
|
|
|
|
* If lpfc_get_hba_info() returns zero (failure) the buffer text is set
|
|
|
|
|
* to "Unknown" and the buffer length is returned, therefore the caller
|
|
|
|
|
* must check for "Unknown" in the buffer to detect a failure.
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
2007-06-18 08:56:39 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_max_vpi_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
2007-06-18 08:56:39 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:39 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
uint32_t cnt;
|
|
|
|
|
|
|
|
|
|
if (lpfc_get_hba_info(phba, NULL, NULL, NULL, NULL, &cnt, NULL))
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", cnt);
|
|
|
|
|
return scnprintf(buf, PAGE_SIZE, "Unknown\n");
|
2007-06-18 08:56:39 +08:00
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_used_vpi_show - Return maximum vpi minus the available vpi
|
2008-08-25 09:49:00 +08:00
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: on return contains the used vpi count in decimal or "Unknown".
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* Calls lpfc_get_hba_info() asking for just the mvpi and avpi counts.
|
|
|
|
|
* If lpfc_get_hba_info() returns zero (failure) the buffer text is set
|
|
|
|
|
* to "Unknown" and the buffer length is returned, therefore the caller
|
|
|
|
|
* must check for "Unknown" in the buffer to detect a failure.
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
2007-06-18 08:56:39 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_used_vpi_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
2007-06-18 08:56:39 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:39 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
uint32_t cnt, acnt;
|
|
|
|
|
|
|
|
|
|
if (lpfc_get_hba_info(phba, NULL, NULL, NULL, NULL, &cnt, &acnt))
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
|
|
|
|
|
return scnprintf(buf, PAGE_SIZE, "Unknown\n");
|
2007-06-18 08:56:38 +08:00
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_npiv_info_show - Return text about NPIV support for the adapter
|
2008-08-25 09:49:00 +08:00
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: text that must be interpreted to determine if npiv is supported.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* Buffer will contain text indicating npiv is not suppoerted on the port,
|
|
|
|
|
* the port is an NPIV physical port, or it is an npiv virtual port with
|
|
|
|
|
* the id of the vport.
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
2007-06-18 08:56:38 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_npiv_info_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
2007-06-18 08:56:38 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:38 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
|
|
|
|
|
if (!(phba->max_vpi))
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "NPIV Not Supported\n");
|
2007-06-18 08:56:38 +08:00
|
|
|
if (vport->port_type == LPFC_PHYSICAL_PORT)
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "NPIV Physical\n");
|
|
|
|
|
return scnprintf(buf, PAGE_SIZE, "NPIV Virtual (VPI %d)\n", vport->vpi);
|
2007-06-18 08:56:38 +08:00
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_poll_show - Return text about poll support for the adapter
|
2008-08-25 09:49:00 +08:00
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: on return contains the cfg_poll in hex.
|
|
|
|
|
*
|
|
|
|
|
* Notes:
|
|
|
|
|
* cfg_poll should be a lpfc_polling_flags type.
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
[SCSI] lpfc 8.1.1 : Add polled-mode support
- Add functionality to run in polled mode only. Includes run time
attribute to enable mode.
- Enable runtime writable hba settings for coallescing and delay parameters
Customers have requested a mode in the driver to run strictly polled.
This is generally to support an environment where the server is extremely
loaded and is looking to reclaim some cpu cycles from adapter interrupt
handling.
This patch adds a new "poll" attribute, and the following behavior:
if value is 0 (default):
The driver uses the normal method for i/o completion. It uses the
firmware feature of interrupt coalesing. The firmware allows a
minimum number of i/o completions before an interrupt, or a maximum
time delay between interrupts. By default, the driver sets these
to no delay (disabled) or 1 i/o - meaning coalescing is disabled.
Attributes were provided to change the coalescing values, but it was
a module-load time only and global across all adapters.
This patch allows them to be writable on a per-adapter basis.
if value is 1 :
Interrupts are left enabled, expecting that the user has tuned the
interrupt coalescing values. When this setting is enabled, the driver
will attempt to service completed i/o whenever new i/o is submitted
to the adapter. If the coalescing values are large, and the i/o
generation rate steady, an interrupt will be avoided by servicing
completed i/o prior to the coalescing thresholds kicking in. However,
if the i/o completion load is high enough or i/o generation slow, the
coalescion values will ensure that completed i/o is serviced in a timely
fashion.
if value is 3 :
Turns off FCP i/o interrupts altogether. The coalescing values now have
no effect. A new attribute "poll_tmo" (default 10ms) exists to set
the polling interval for i/o completion. When this setting is enabled,
the driver will attempt to service completed i/o and restart the
interval timer whenever new i/o is submitted. This behavior allows for
servicing of completed i/o sooner than the interval timer, but ensures
that if no i/o is being issued, then the interval timer will kick in
to service the outstanding i/o.
Signed-off-by: James Smart <James.Smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-11-30 05:32:13 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_poll_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
[SCSI] lpfc 8.1.1 : Add polled-mode support
- Add functionality to run in polled mode only. Includes run time
attribute to enable mode.
- Enable runtime writable hba settings for coallescing and delay parameters
Customers have requested a mode in the driver to run strictly polled.
This is generally to support an environment where the server is extremely
loaded and is looking to reclaim some cpu cycles from adapter interrupt
handling.
This patch adds a new "poll" attribute, and the following behavior:
if value is 0 (default):
The driver uses the normal method for i/o completion. It uses the
firmware feature of interrupt coalesing. The firmware allows a
minimum number of i/o completions before an interrupt, or a maximum
time delay between interrupts. By default, the driver sets these
to no delay (disabled) or 1 i/o - meaning coalescing is disabled.
Attributes were provided to change the coalescing values, but it was
a module-load time only and global across all adapters.
This patch allows them to be writable on a per-adapter basis.
if value is 1 :
Interrupts are left enabled, expecting that the user has tuned the
interrupt coalescing values. When this setting is enabled, the driver
will attempt to service completed i/o whenever new i/o is submitted
to the adapter. If the coalescing values are large, and the i/o
generation rate steady, an interrupt will be avoided by servicing
completed i/o prior to the coalescing thresholds kicking in. However,
if the i/o completion load is high enough or i/o generation slow, the
coalescion values will ensure that completed i/o is serviced in a timely
fashion.
if value is 3 :
Turns off FCP i/o interrupts altogether. The coalescing values now have
no effect. A new attribute "poll_tmo" (default 10ms) exists to set
the polling interval for i/o completion. When this setting is enabled,
the driver will attempt to service completed i/o and restart the
interval timer whenever new i/o is submitted. This behavior allows for
servicing of completed i/o sooner than the interval timer, but ensures
that if no i/o is being issued, then the interval timer will kick in
to service the outstanding i/o.
Signed-off-by: James Smart <James.Smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-11-30 05:32:13 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
[SCSI] lpfc 8.1.1 : Add polled-mode support
- Add functionality to run in polled mode only. Includes run time
attribute to enable mode.
- Enable runtime writable hba settings for coallescing and delay parameters
Customers have requested a mode in the driver to run strictly polled.
This is generally to support an environment where the server is extremely
loaded and is looking to reclaim some cpu cycles from adapter interrupt
handling.
This patch adds a new "poll" attribute, and the following behavior:
if value is 0 (default):
The driver uses the normal method for i/o completion. It uses the
firmware feature of interrupt coalesing. The firmware allows a
minimum number of i/o completions before an interrupt, or a maximum
time delay between interrupts. By default, the driver sets these
to no delay (disabled) or 1 i/o - meaning coalescing is disabled.
Attributes were provided to change the coalescing values, but it was
a module-load time only and global across all adapters.
This patch allows them to be writable on a per-adapter basis.
if value is 1 :
Interrupts are left enabled, expecting that the user has tuned the
interrupt coalescing values. When this setting is enabled, the driver
will attempt to service completed i/o whenever new i/o is submitted
to the adapter. If the coalescing values are large, and the i/o
generation rate steady, an interrupt will be avoided by servicing
completed i/o prior to the coalescing thresholds kicking in. However,
if the i/o completion load is high enough or i/o generation slow, the
coalescion values will ensure that completed i/o is serviced in a timely
fashion.
if value is 3 :
Turns off FCP i/o interrupts altogether. The coalescing values now have
no effect. A new attribute "poll_tmo" (default 10ms) exists to set
the polling interval for i/o completion. When this setting is enabled,
the driver will attempt to service completed i/o and restart the
interval timer whenever new i/o is submitted. This behavior allows for
servicing of completed i/o sooner than the interval timer, but ensures
that if no i/o is being issued, then the interval timer will kick in
to service the outstanding i/o.
Signed-off-by: James Smart <James.Smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-11-30 05:32:13 +08:00
|
|
|
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%#x\n", phba->cfg_poll);
|
[SCSI] lpfc 8.1.1 : Add polled-mode support
- Add functionality to run in polled mode only. Includes run time
attribute to enable mode.
- Enable runtime writable hba settings for coallescing and delay parameters
Customers have requested a mode in the driver to run strictly polled.
This is generally to support an environment where the server is extremely
loaded and is looking to reclaim some cpu cycles from adapter interrupt
handling.
This patch adds a new "poll" attribute, and the following behavior:
if value is 0 (default):
The driver uses the normal method for i/o completion. It uses the
firmware feature of interrupt coalesing. The firmware allows a
minimum number of i/o completions before an interrupt, or a maximum
time delay between interrupts. By default, the driver sets these
to no delay (disabled) or 1 i/o - meaning coalescing is disabled.
Attributes were provided to change the coalescing values, but it was
a module-load time only and global across all adapters.
This patch allows them to be writable on a per-adapter basis.
if value is 1 :
Interrupts are left enabled, expecting that the user has tuned the
interrupt coalescing values. When this setting is enabled, the driver
will attempt to service completed i/o whenever new i/o is submitted
to the adapter. If the coalescing values are large, and the i/o
generation rate steady, an interrupt will be avoided by servicing
completed i/o prior to the coalescing thresholds kicking in. However,
if the i/o completion load is high enough or i/o generation slow, the
coalescion values will ensure that completed i/o is serviced in a timely
fashion.
if value is 3 :
Turns off FCP i/o interrupts altogether. The coalescing values now have
no effect. A new attribute "poll_tmo" (default 10ms) exists to set
the polling interval for i/o completion. When this setting is enabled,
the driver will attempt to service completed i/o and restart the
interval timer whenever new i/o is submitted. This behavior allows for
servicing of completed i/o sooner than the interval timer, but ensures
that if no i/o is being issued, then the interval timer will kick in
to service the outstanding i/o.
Signed-off-by: James Smart <James.Smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-11-30 05:32:13 +08:00
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_poll_store - Set the value of cfg_poll for the adapter
|
2008-08-25 09:49:00 +08:00
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: one or more lpfc_polling_flags values.
|
|
|
|
|
* @count: not used.
|
|
|
|
|
*
|
|
|
|
|
* Notes:
|
|
|
|
|
* buf contents converted to integer and checked for a valid value.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* -EINVAL if the buffer connot be converted or is out of range
|
|
|
|
|
* length of the buf on success
|
|
|
|
|
**/
|
[SCSI] lpfc 8.1.1 : Add polled-mode support
- Add functionality to run in polled mode only. Includes run time
attribute to enable mode.
- Enable runtime writable hba settings for coallescing and delay parameters
Customers have requested a mode in the driver to run strictly polled.
This is generally to support an environment where the server is extremely
loaded and is looking to reclaim some cpu cycles from adapter interrupt
handling.
This patch adds a new "poll" attribute, and the following behavior:
if value is 0 (default):
The driver uses the normal method for i/o completion. It uses the
firmware feature of interrupt coalesing. The firmware allows a
minimum number of i/o completions before an interrupt, or a maximum
time delay between interrupts. By default, the driver sets these
to no delay (disabled) or 1 i/o - meaning coalescing is disabled.
Attributes were provided to change the coalescing values, but it was
a module-load time only and global across all adapters.
This patch allows them to be writable on a per-adapter basis.
if value is 1 :
Interrupts are left enabled, expecting that the user has tuned the
interrupt coalescing values. When this setting is enabled, the driver
will attempt to service completed i/o whenever new i/o is submitted
to the adapter. If the coalescing values are large, and the i/o
generation rate steady, an interrupt will be avoided by servicing
completed i/o prior to the coalescing thresholds kicking in. However,
if the i/o completion load is high enough or i/o generation slow, the
coalescion values will ensure that completed i/o is serviced in a timely
fashion.
if value is 3 :
Turns off FCP i/o interrupts altogether. The coalescing values now have
no effect. A new attribute "poll_tmo" (default 10ms) exists to set
the polling interval for i/o completion. When this setting is enabled,
the driver will attempt to service completed i/o and restart the
interval timer whenever new i/o is submitted. This behavior allows for
servicing of completed i/o sooner than the interval timer, but ensures
that if no i/o is being issued, then the interval timer will kick in
to service the outstanding i/o.
Signed-off-by: James Smart <James.Smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-11-30 05:32:13 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_poll_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
const char *buf, size_t count)
|
[SCSI] lpfc 8.1.1 : Add polled-mode support
- Add functionality to run in polled mode only. Includes run time
attribute to enable mode.
- Enable runtime writable hba settings for coallescing and delay parameters
Customers have requested a mode in the driver to run strictly polled.
This is generally to support an environment where the server is extremely
loaded and is looking to reclaim some cpu cycles from adapter interrupt
handling.
This patch adds a new "poll" attribute, and the following behavior:
if value is 0 (default):
The driver uses the normal method for i/o completion. It uses the
firmware feature of interrupt coalesing. The firmware allows a
minimum number of i/o completions before an interrupt, or a maximum
time delay between interrupts. By default, the driver sets these
to no delay (disabled) or 1 i/o - meaning coalescing is disabled.
Attributes were provided to change the coalescing values, but it was
a module-load time only and global across all adapters.
This patch allows them to be writable on a per-adapter basis.
if value is 1 :
Interrupts are left enabled, expecting that the user has tuned the
interrupt coalescing values. When this setting is enabled, the driver
will attempt to service completed i/o whenever new i/o is submitted
to the adapter. If the coalescing values are large, and the i/o
generation rate steady, an interrupt will be avoided by servicing
completed i/o prior to the coalescing thresholds kicking in. However,
if the i/o completion load is high enough or i/o generation slow, the
coalescion values will ensure that completed i/o is serviced in a timely
fashion.
if value is 3 :
Turns off FCP i/o interrupts altogether. The coalescing values now have
no effect. A new attribute "poll_tmo" (default 10ms) exists to set
the polling interval for i/o completion. When this setting is enabled,
the driver will attempt to service completed i/o and restart the
interval timer whenever new i/o is submitted. This behavior allows for
servicing of completed i/o sooner than the interval timer, but ensures
that if no i/o is being issued, then the interval timer will kick in
to service the outstanding i/o.
Signed-off-by: James Smart <James.Smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-11-30 05:32:13 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
[SCSI] lpfc 8.1.1 : Add polled-mode support
- Add functionality to run in polled mode only. Includes run time
attribute to enable mode.
- Enable runtime writable hba settings for coallescing and delay parameters
Customers have requested a mode in the driver to run strictly polled.
This is generally to support an environment where the server is extremely
loaded and is looking to reclaim some cpu cycles from adapter interrupt
handling.
This patch adds a new "poll" attribute, and the following behavior:
if value is 0 (default):
The driver uses the normal method for i/o completion. It uses the
firmware feature of interrupt coalesing. The firmware allows a
minimum number of i/o completions before an interrupt, or a maximum
time delay between interrupts. By default, the driver sets these
to no delay (disabled) or 1 i/o - meaning coalescing is disabled.
Attributes were provided to change the coalescing values, but it was
a module-load time only and global across all adapters.
This patch allows them to be writable on a per-adapter basis.
if value is 1 :
Interrupts are left enabled, expecting that the user has tuned the
interrupt coalescing values. When this setting is enabled, the driver
will attempt to service completed i/o whenever new i/o is submitted
to the adapter. If the coalescing values are large, and the i/o
generation rate steady, an interrupt will be avoided by servicing
completed i/o prior to the coalescing thresholds kicking in. However,
if the i/o completion load is high enough or i/o generation slow, the
coalescion values will ensure that completed i/o is serviced in a timely
fashion.
if value is 3 :
Turns off FCP i/o interrupts altogether. The coalescing values now have
no effect. A new attribute "poll_tmo" (default 10ms) exists to set
the polling interval for i/o completion. When this setting is enabled,
the driver will attempt to service completed i/o and restart the
interval timer whenever new i/o is submitted. This behavior allows for
servicing of completed i/o sooner than the interval timer, but ensures
that if no i/o is being issued, then the interval timer will kick in
to service the outstanding i/o.
Signed-off-by: James Smart <James.Smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-11-30 05:32:13 +08:00
|
|
|
uint32_t creg_val;
|
|
|
|
|
uint32_t old_val;
|
|
|
|
|
int val=0;
|
|
|
|
|
|
|
|
|
|
if (!isdigit(buf[0]))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
if (sscanf(buf, "%i", &val) != 1)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
if ((val & 0x3) != val)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2009-10-03 03:17:02 +08:00
|
|
|
if (phba->sli_rev == LPFC_SLI_REV4)
|
|
|
|
|
val = 0;
|
|
|
|
|
|
2011-07-23 06:36:33 +08:00
|
|
|
lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
|
|
|
|
|
"3051 lpfc_poll changed from %d to %d\n",
|
|
|
|
|
phba->cfg_poll, val);
|
|
|
|
|
|
2007-06-18 08:56:36 +08:00
|
|
|
spin_lock_irq(&phba->hbalock);
|
[SCSI] lpfc 8.1.1 : Add polled-mode support
- Add functionality to run in polled mode only. Includes run time
attribute to enable mode.
- Enable runtime writable hba settings for coallescing and delay parameters
Customers have requested a mode in the driver to run strictly polled.
This is generally to support an environment where the server is extremely
loaded and is looking to reclaim some cpu cycles from adapter interrupt
handling.
This patch adds a new "poll" attribute, and the following behavior:
if value is 0 (default):
The driver uses the normal method for i/o completion. It uses the
firmware feature of interrupt coalesing. The firmware allows a
minimum number of i/o completions before an interrupt, or a maximum
time delay between interrupts. By default, the driver sets these
to no delay (disabled) or 1 i/o - meaning coalescing is disabled.
Attributes were provided to change the coalescing values, but it was
a module-load time only and global across all adapters.
This patch allows them to be writable on a per-adapter basis.
if value is 1 :
Interrupts are left enabled, expecting that the user has tuned the
interrupt coalescing values. When this setting is enabled, the driver
will attempt to service completed i/o whenever new i/o is submitted
to the adapter. If the coalescing values are large, and the i/o
generation rate steady, an interrupt will be avoided by servicing
completed i/o prior to the coalescing thresholds kicking in. However,
if the i/o completion load is high enough or i/o generation slow, the
coalescion values will ensure that completed i/o is serviced in a timely
fashion.
if value is 3 :
Turns off FCP i/o interrupts altogether. The coalescing values now have
no effect. A new attribute "poll_tmo" (default 10ms) exists to set
the polling interval for i/o completion. When this setting is enabled,
the driver will attempt to service completed i/o and restart the
interval timer whenever new i/o is submitted. This behavior allows for
servicing of completed i/o sooner than the interval timer, but ensures
that if no i/o is being issued, then the interval timer will kick in
to service the outstanding i/o.
Signed-off-by: James Smart <James.Smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-11-30 05:32:13 +08:00
|
|
|
|
|
|
|
|
old_val = phba->cfg_poll;
|
|
|
|
|
|
|
|
|
|
if (val & ENABLE_FCP_RING_POLLING) {
|
|
|
|
|
if ((val & DISABLE_FCP_RING_INT) &&
|
|
|
|
|
!(old_val & DISABLE_FCP_RING_INT)) {
|
2011-03-12 05:06:12 +08:00
|
|
|
if (lpfc_readl(phba->HCregaddr, &creg_val)) {
|
|
|
|
|
spin_unlock_irq(&phba->hbalock);
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
[SCSI] lpfc 8.1.1 : Add polled-mode support
- Add functionality to run in polled mode only. Includes run time
attribute to enable mode.
- Enable runtime writable hba settings for coallescing and delay parameters
Customers have requested a mode in the driver to run strictly polled.
This is generally to support an environment where the server is extremely
loaded and is looking to reclaim some cpu cycles from adapter interrupt
handling.
This patch adds a new "poll" attribute, and the following behavior:
if value is 0 (default):
The driver uses the normal method for i/o completion. It uses the
firmware feature of interrupt coalesing. The firmware allows a
minimum number of i/o completions before an interrupt, or a maximum
time delay between interrupts. By default, the driver sets these
to no delay (disabled) or 1 i/o - meaning coalescing is disabled.
Attributes were provided to change the coalescing values, but it was
a module-load time only and global across all adapters.
This patch allows them to be writable on a per-adapter basis.
if value is 1 :
Interrupts are left enabled, expecting that the user has tuned the
interrupt coalescing values. When this setting is enabled, the driver
will attempt to service completed i/o whenever new i/o is submitted
to the adapter. If the coalescing values are large, and the i/o
generation rate steady, an interrupt will be avoided by servicing
completed i/o prior to the coalescing thresholds kicking in. However,
if the i/o completion load is high enough or i/o generation slow, the
coalescion values will ensure that completed i/o is serviced in a timely
fashion.
if value is 3 :
Turns off FCP i/o interrupts altogether. The coalescing values now have
no effect. A new attribute "poll_tmo" (default 10ms) exists to set
the polling interval for i/o completion. When this setting is enabled,
the driver will attempt to service completed i/o and restart the
interval timer whenever new i/o is submitted. This behavior allows for
servicing of completed i/o sooner than the interval timer, but ensures
that if no i/o is being issued, then the interval timer will kick in
to service the outstanding i/o.
Signed-off-by: James Smart <James.Smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-11-30 05:32:13 +08:00
|
|
|
creg_val &= ~(HC_R0INT_ENA << LPFC_FCP_RING);
|
|
|
|
|
writel(creg_val, phba->HCregaddr);
|
|
|
|
|
readl(phba->HCregaddr); /* flush */
|
|
|
|
|
|
|
|
|
|
lpfc_poll_start_timer(phba);
|
|
|
|
|
}
|
|
|
|
|
} else if (val != 0x0) {
|
2007-06-18 08:56:36 +08:00
|
|
|
spin_unlock_irq(&phba->hbalock);
|
[SCSI] lpfc 8.1.1 : Add polled-mode support
- Add functionality to run in polled mode only. Includes run time
attribute to enable mode.
- Enable runtime writable hba settings for coallescing and delay parameters
Customers have requested a mode in the driver to run strictly polled.
This is generally to support an environment where the server is extremely
loaded and is looking to reclaim some cpu cycles from adapter interrupt
handling.
This patch adds a new "poll" attribute, and the following behavior:
if value is 0 (default):
The driver uses the normal method for i/o completion. It uses the
firmware feature of interrupt coalesing. The firmware allows a
minimum number of i/o completions before an interrupt, or a maximum
time delay between interrupts. By default, the driver sets these
to no delay (disabled) or 1 i/o - meaning coalescing is disabled.
Attributes were provided to change the coalescing values, but it was
a module-load time only and global across all adapters.
This patch allows them to be writable on a per-adapter basis.
if value is 1 :
Interrupts are left enabled, expecting that the user has tuned the
interrupt coalescing values. When this setting is enabled, the driver
will attempt to service completed i/o whenever new i/o is submitted
to the adapter. If the coalescing values are large, and the i/o
generation rate steady, an interrupt will be avoided by servicing
completed i/o prior to the coalescing thresholds kicking in. However,
if the i/o completion load is high enough or i/o generation slow, the
coalescion values will ensure that completed i/o is serviced in a timely
fashion.
if value is 3 :
Turns off FCP i/o interrupts altogether. The coalescing values now have
no effect. A new attribute "poll_tmo" (default 10ms) exists to set
the polling interval for i/o completion. When this setting is enabled,
the driver will attempt to service completed i/o and restart the
interval timer whenever new i/o is submitted. This behavior allows for
servicing of completed i/o sooner than the interval timer, but ensures
that if no i/o is being issued, then the interval timer will kick in
to service the outstanding i/o.
Signed-off-by: James Smart <James.Smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-11-30 05:32:13 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!(val & DISABLE_FCP_RING_INT) &&
|
|
|
|
|
(old_val & DISABLE_FCP_RING_INT))
|
|
|
|
|
{
|
2007-06-18 08:56:36 +08:00
|
|
|
spin_unlock_irq(&phba->hbalock);
|
[SCSI] lpfc 8.1.1 : Add polled-mode support
- Add functionality to run in polled mode only. Includes run time
attribute to enable mode.
- Enable runtime writable hba settings for coallescing and delay parameters
Customers have requested a mode in the driver to run strictly polled.
This is generally to support an environment where the server is extremely
loaded and is looking to reclaim some cpu cycles from adapter interrupt
handling.
This patch adds a new "poll" attribute, and the following behavior:
if value is 0 (default):
The driver uses the normal method for i/o completion. It uses the
firmware feature of interrupt coalesing. The firmware allows a
minimum number of i/o completions before an interrupt, or a maximum
time delay between interrupts. By default, the driver sets these
to no delay (disabled) or 1 i/o - meaning coalescing is disabled.
Attributes were provided to change the coalescing values, but it was
a module-load time only and global across all adapters.
This patch allows them to be writable on a per-adapter basis.
if value is 1 :
Interrupts are left enabled, expecting that the user has tuned the
interrupt coalescing values. When this setting is enabled, the driver
will attempt to service completed i/o whenever new i/o is submitted
to the adapter. If the coalescing values are large, and the i/o
generation rate steady, an interrupt will be avoided by servicing
completed i/o prior to the coalescing thresholds kicking in. However,
if the i/o completion load is high enough or i/o generation slow, the
coalescion values will ensure that completed i/o is serviced in a timely
fashion.
if value is 3 :
Turns off FCP i/o interrupts altogether. The coalescing values now have
no effect. A new attribute "poll_tmo" (default 10ms) exists to set
the polling interval for i/o completion. When this setting is enabled,
the driver will attempt to service completed i/o and restart the
interval timer whenever new i/o is submitted. This behavior allows for
servicing of completed i/o sooner than the interval timer, but ensures
that if no i/o is being issued, then the interval timer will kick in
to service the outstanding i/o.
Signed-off-by: James Smart <James.Smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-11-30 05:32:13 +08:00
|
|
|
del_timer(&phba->fcp_poll_timer);
|
2007-06-18 08:56:36 +08:00
|
|
|
spin_lock_irq(&phba->hbalock);
|
2011-03-12 05:06:12 +08:00
|
|
|
if (lpfc_readl(phba->HCregaddr, &creg_val)) {
|
|
|
|
|
spin_unlock_irq(&phba->hbalock);
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
[SCSI] lpfc 8.1.1 : Add polled-mode support
- Add functionality to run in polled mode only. Includes run time
attribute to enable mode.
- Enable runtime writable hba settings for coallescing and delay parameters
Customers have requested a mode in the driver to run strictly polled.
This is generally to support an environment where the server is extremely
loaded and is looking to reclaim some cpu cycles from adapter interrupt
handling.
This patch adds a new "poll" attribute, and the following behavior:
if value is 0 (default):
The driver uses the normal method for i/o completion. It uses the
firmware feature of interrupt coalesing. The firmware allows a
minimum number of i/o completions before an interrupt, or a maximum
time delay between interrupts. By default, the driver sets these
to no delay (disabled) or 1 i/o - meaning coalescing is disabled.
Attributes were provided to change the coalescing values, but it was
a module-load time only and global across all adapters.
This patch allows them to be writable on a per-adapter basis.
if value is 1 :
Interrupts are left enabled, expecting that the user has tuned the
interrupt coalescing values. When this setting is enabled, the driver
will attempt to service completed i/o whenever new i/o is submitted
to the adapter. If the coalescing values are large, and the i/o
generation rate steady, an interrupt will be avoided by servicing
completed i/o prior to the coalescing thresholds kicking in. However,
if the i/o completion load is high enough or i/o generation slow, the
coalescion values will ensure that completed i/o is serviced in a timely
fashion.
if value is 3 :
Turns off FCP i/o interrupts altogether. The coalescing values now have
no effect. A new attribute "poll_tmo" (default 10ms) exists to set
the polling interval for i/o completion. When this setting is enabled,
the driver will attempt to service completed i/o and restart the
interval timer whenever new i/o is submitted. This behavior allows for
servicing of completed i/o sooner than the interval timer, but ensures
that if no i/o is being issued, then the interval timer will kick in
to service the outstanding i/o.
Signed-off-by: James Smart <James.Smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-11-30 05:32:13 +08:00
|
|
|
creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING);
|
|
|
|
|
writel(creg_val, phba->HCregaddr);
|
|
|
|
|
readl(phba->HCregaddr); /* flush */
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
phba->cfg_poll = val;
|
|
|
|
|
|
2007-06-18 08:56:36 +08:00
|
|
|
spin_unlock_irq(&phba->hbalock);
|
[SCSI] lpfc 8.1.1 : Add polled-mode support
- Add functionality to run in polled mode only. Includes run time
attribute to enable mode.
- Enable runtime writable hba settings for coallescing and delay parameters
Customers have requested a mode in the driver to run strictly polled.
This is generally to support an environment where the server is extremely
loaded and is looking to reclaim some cpu cycles from adapter interrupt
handling.
This patch adds a new "poll" attribute, and the following behavior:
if value is 0 (default):
The driver uses the normal method for i/o completion. It uses the
firmware feature of interrupt coalesing. The firmware allows a
minimum number of i/o completions before an interrupt, or a maximum
time delay between interrupts. By default, the driver sets these
to no delay (disabled) or 1 i/o - meaning coalescing is disabled.
Attributes were provided to change the coalescing values, but it was
a module-load time only and global across all adapters.
This patch allows them to be writable on a per-adapter basis.
if value is 1 :
Interrupts are left enabled, expecting that the user has tuned the
interrupt coalescing values. When this setting is enabled, the driver
will attempt to service completed i/o whenever new i/o is submitted
to the adapter. If the coalescing values are large, and the i/o
generation rate steady, an interrupt will be avoided by servicing
completed i/o prior to the coalescing thresholds kicking in. However,
if the i/o completion load is high enough or i/o generation slow, the
coalescion values will ensure that completed i/o is serviced in a timely
fashion.
if value is 3 :
Turns off FCP i/o interrupts altogether. The coalescing values now have
no effect. A new attribute "poll_tmo" (default 10ms) exists to set
the polling interval for i/o completion. When this setting is enabled,
the driver will attempt to service completed i/o and restart the
interval timer whenever new i/o is submitted. This behavior allows for
servicing of completed i/o sooner than the interval timer, but ensures
that if no i/o is being issued, then the interval timer will kick in
to service the outstanding i/o.
Signed-off-by: James Smart <James.Smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-11-30 05:32:13 +08:00
|
|
|
|
|
|
|
|
return strlen(buf);
|
|
|
|
|
}
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
/**
|
|
|
|
|
* lpfc_fips_level_show - Return the current FIPS level for the HBA
|
|
|
|
|
* @dev: class unused variable.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: on return contains the module description text.
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_fips_level_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
|
|
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", phba->fips_level);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* lpfc_fips_rev_show - Return the FIPS Spec revision for the HBA
|
|
|
|
|
* @dev: class unused variable.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: on return contains the module description text.
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_fips_rev_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
|
|
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", phba->fips_spec_rev);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* lpfc_dss_show - Return the current state of dss and the configured state
|
|
|
|
|
* @dev: class converted to a Scsi_host structure.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: on return contains the formatted text.
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_dss_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
|
|
|
|
|
return scnprintf(buf, PAGE_SIZE, "%s - %sOperational\n",
|
|
|
|
|
(phba->cfg_enable_dss) ? "Enabled" : "Disabled",
|
|
|
|
|
(phba->sli3_options & LPFC_SLI3_DSS_ENABLED) ?
|
|
|
|
|
"" : "Not ");
|
|
|
|
|
}
|
|
|
|
|
|
2010-08-05 04:11:18 +08:00
|
|
|
/**
|
2024-06-11 20:26:44 +08:00
|
|
|
* lpfc_sriov_hw_max_virtfn_show - Return maximum number of virtual functions
|
|
|
|
|
* @dev: class converted to a Scsi_host structure.
|
2010-08-05 04:11:18 +08:00
|
|
|
* @attr: device attribute, not used.
|
2024-06-11 20:26:44 +08:00
|
|
|
* @buf: on return contains the formatted support level.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* Returns the maximum number of virtual functions a physical function can
|
|
|
|
|
* support, 0 will be returned if called on virtual function.
|
2010-08-05 04:11:18 +08:00
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
2024-06-11 20:26:44 +08:00
|
|
|
lpfc_sriov_hw_max_virtfn_show(struct device *dev,
|
|
|
|
|
struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
2010-08-05 04:11:18 +08:00
|
|
|
{
|
2024-06-11 20:26:44 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2011-05-24 23:42:11 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
2011-07-23 06:37:28 +08:00
|
|
|
uint16_t max_nr_virtfn;
|
2011-05-24 23:42:11 +08:00
|
|
|
|
2011-07-23 06:37:28 +08:00
|
|
|
max_nr_virtfn = lpfc_sli_sriov_nr_virtfn_get(phba);
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", max_nr_virtfn);
|
2011-05-24 23:42:11 +08:00
|
|
|
}
|
|
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
static inline bool lpfc_rangecheck(uint val, uint min, uint max)
|
|
|
|
|
{
|
|
|
|
|
return val >= min && val <= max;
|
|
|
|
|
}
|
|
|
|
|
|
2017-08-24 07:55:47 +08:00
|
|
|
/**
|
|
|
|
|
* lpfc_enable_bbcr_set: Sets an attribute value.
|
|
|
|
|
* @phba: pointer the the adapter structure.
|
|
|
|
|
* @val: integer attribute value.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* Validates the min and max values then sets the
|
|
|
|
|
* adapter config field if in the valid range. prints error message
|
|
|
|
|
* and does not set the parameter if invalid.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* zero on success
|
|
|
|
|
* -EINVAL if val is invalid
|
|
|
|
|
*/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_enable_bbcr_set(struct lpfc_hba *phba, uint val)
|
|
|
|
|
{
|
|
|
|
|
if (lpfc_rangecheck(val, 0, 1) && phba->sli_rev == LPFC_SLI_REV4) {
|
|
|
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
|
|
|
|
|
"3068 %s_enable_bbcr changed from %d to %d\n",
|
|
|
|
|
LPFC_DRIVER_NAME, phba->cfg_enable_bbcr, val);
|
|
|
|
|
phba->cfg_enable_bbcr = val;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
|
|
|
|
|
"0451 %s_enable_bbcr cannot set to %d, range is 0, 1\n",
|
|
|
|
|
LPFC_DRIVER_NAME, val);
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_param_show - Return a cfg attribute value in decimal
|
2008-08-25 09:49:00 +08:00
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* Macro that given an attr e.g. hba_queue_depth expands
|
|
|
|
|
* into a function with the name lpfc_hba_queue_depth_show.
|
|
|
|
|
*
|
|
|
|
|
* lpfc_##attr##_show: Return the decimal value of an adapters cfg_xxx field.
|
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: on return contains the attribute value in decimal.
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
#define lpfc_param_show(attr) \
|
|
|
|
|
static ssize_t \
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
|
|
|
|
|
char *buf) \
|
2005-04-18 05:05:31 +08:00
|
|
|
{ \
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);\
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;\
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n",\
|
2005-10-29 08:29:13 +08:00
|
|
|
phba->cfg_##attr);\
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_param_hex_show - Return a cfg attribute value in hex
|
2008-08-25 09:49:00 +08:00
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* Macro that given an attr e.g. hba_queue_depth expands
|
|
|
|
|
* into a function with the name lpfc_hba_queue_depth_show
|
|
|
|
|
*
|
|
|
|
|
* lpfc_##attr##_show: Return the hex value of an adapters cfg_xxx field.
|
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
2009-04-07 06:47:14 +08:00
|
|
|
* @buf: on return contains the attribute value in hexadecimal.
|
2008-08-25 09:49:00 +08:00
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
2005-10-29 08:29:32 +08:00
|
|
|
#define lpfc_param_hex_show(attr) \
|
|
|
|
|
static ssize_t \
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
|
|
|
|
|
char *buf) \
|
2005-10-29 08:29:32 +08:00
|
|
|
{ \
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);\
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;\
|
2010-02-13 03:42:33 +08:00
|
|
|
uint val = 0;\
|
2005-10-29 08:29:32 +08:00
|
|
|
val = phba->cfg_##attr;\
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%#x\n",\
|
2005-10-29 08:29:32 +08:00
|
|
|
phba->cfg_##attr);\
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
tree-wide: fix comment/printk typos
"gadget", "through", "command", "maintain", "maintain", "controller", "address",
"between", "initiali[zs]e", "instead", "function", "select", "already",
"equal", "access", "management", "hierarchy", "registration", "interest",
"relative", "memory", "offset", "already",
Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2010-11-02 03:38:34 +08:00
|
|
|
* lpfc_param_init - Initializes a cfg attribute
|
2008-08-25 09:49:00 +08:00
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* Macro that given an attr e.g. hba_queue_depth expands
|
|
|
|
|
* into a function with the name lpfc_hba_queue_depth_init. The macro also
|
|
|
|
|
* takes a default argument, a minimum and maximum argument.
|
|
|
|
|
*
|
|
|
|
|
* lpfc_##attr##_init: Initializes an attribute.
|
|
|
|
|
* @phba: pointer the the adapter structure.
|
|
|
|
|
* @val: integer attribute value.
|
|
|
|
|
*
|
|
|
|
|
* Validates the min and max values then sets the adapter config field
|
|
|
|
|
* accordingly, or uses the default if out of range and prints an error message.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* zero on success
|
|
|
|
|
* -EINVAL if default used
|
|
|
|
|
**/
|
2005-10-29 08:29:13 +08:00
|
|
|
#define lpfc_param_init(attr, default, minval, maxval) \
|
|
|
|
|
static int \
|
2010-02-13 03:42:33 +08:00
|
|
|
lpfc_##attr##_init(struct lpfc_hba *phba, uint val) \
|
2005-10-29 08:29:13 +08:00
|
|
|
{ \
|
2016-06-16 04:42:17 +08:00
|
|
|
if (lpfc_rangecheck(val, minval, maxval)) {\
|
2005-10-29 08:29:13 +08:00
|
|
|
phba->cfg_##attr = val;\
|
|
|
|
|
return 0;\
|
2005-04-18 05:05:31 +08:00
|
|
|
}\
|
2005-10-29 08:29:13 +08:00
|
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
|
2024-06-12 13:13:20 +08:00
|
|
|
"0449 lpfc_"#attr" attribute cannot be set to %d, "\
|
|
|
|
|
"allowed range is ["#minval", "#maxval"]\n", val); \
|
2005-10-29 08:29:13 +08:00
|
|
|
phba->cfg_##attr = default;\
|
|
|
|
|
return -EINVAL;\
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_param_set - Set a cfg attribute value
|
2008-08-25 09:49:00 +08:00
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* Macro that given an attr e.g. hba_queue_depth expands
|
|
|
|
|
* into a function with the name lpfc_hba_queue_depth_set
|
|
|
|
|
*
|
|
|
|
|
* lpfc_##attr##_set: Sets an attribute value.
|
|
|
|
|
* @phba: pointer the the adapter structure.
|
|
|
|
|
* @val: integer attribute value.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* Validates the min and max values then sets the
|
|
|
|
|
* adapter config field if in the valid range. prints error message
|
|
|
|
|
* and does not set the parameter if invalid.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* zero on success
|
|
|
|
|
* -EINVAL if val is invalid
|
|
|
|
|
**/
|
2005-10-29 08:29:13 +08:00
|
|
|
#define lpfc_param_set(attr, default, minval, maxval) \
|
|
|
|
|
static int \
|
2010-02-13 03:42:33 +08:00
|
|
|
lpfc_##attr##_set(struct lpfc_hba *phba, uint val) \
|
2005-10-29 08:29:13 +08:00
|
|
|
{ \
|
2016-06-16 04:42:17 +08:00
|
|
|
if (lpfc_rangecheck(val, minval, maxval)) {\
|
2011-07-23 06:36:33 +08:00
|
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
|
2024-06-12 13:13:20 +08:00
|
|
|
"3052 lpfc_" #attr " changed from %d to %d\n", \
|
|
|
|
|
phba->cfg_##attr, val); \
|
2005-10-29 08:29:13 +08:00
|
|
|
phba->cfg_##attr = val;\
|
|
|
|
|
return 0;\
|
|
|
|
|
}\
|
|
|
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
|
2024-06-12 13:13:20 +08:00
|
|
|
"0450 lpfc_"#attr" attribute cannot be set to %d, "\
|
|
|
|
|
"allowed range is ["#minval", "#maxval"]\n", val); \
|
2005-10-29 08:29:13 +08:00
|
|
|
return -EINVAL;\
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_param_store - Set a vport attribute value
|
2008-08-25 09:49:00 +08:00
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* Macro that given an attr e.g. hba_queue_depth expands
|
|
|
|
|
* into a function with the name lpfc_hba_queue_depth_store.
|
|
|
|
|
*
|
|
|
|
|
* lpfc_##attr##_store: Set an sttribute value.
|
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: contains the attribute value in ascii.
|
|
|
|
|
* @count: not used.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* Convert the ascii text number to an integer, then
|
|
|
|
|
* use the lpfc_##attr##_set function to set the value.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* -EINVAL if val is invalid or lpfc_##attr##_set() fails
|
|
|
|
|
* length of buffer upon success.
|
|
|
|
|
**/
|
2005-10-29 08:29:13 +08:00
|
|
|
#define lpfc_param_store(attr) \
|
2005-04-18 05:05:31 +08:00
|
|
|
static ssize_t \
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \
|
|
|
|
|
const char *buf, size_t count) \
|
2005-04-18 05:05:31 +08:00
|
|
|
{ \
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);\
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;\
|
2010-02-13 03:42:33 +08:00
|
|
|
uint val = 0;\
|
2005-10-29 08:29:32 +08:00
|
|
|
if (!isdigit(buf[0]))\
|
|
|
|
|
return -EINVAL;\
|
|
|
|
|
if (sscanf(buf, "%i", &val) != 1)\
|
|
|
|
|
return -EINVAL;\
|
2005-10-29 08:29:13 +08:00
|
|
|
if (lpfc_##attr##_set(phba, val) == 0) \
|
2005-10-29 08:29:06 +08:00
|
|
|
return strlen(buf);\
|
2005-10-29 08:29:13 +08:00
|
|
|
else \
|
|
|
|
|
return -EINVAL;\
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_vport_param_show - Return decimal formatted cfg attribute value
|
2008-08-25 09:49:00 +08:00
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* Macro that given an attr e.g. hba_queue_depth expands
|
|
|
|
|
* into a function with the name lpfc_hba_queue_depth_show
|
|
|
|
|
*
|
|
|
|
|
* lpfc_##attr##_show: prints the attribute value in decimal.
|
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: on return contains the attribute value in decimal.
|
|
|
|
|
*
|
|
|
|
|
* Returns: length of formatted string.
|
|
|
|
|
**/
|
2007-08-02 23:09:59 +08:00
|
|
|
#define lpfc_vport_param_show(attr) \
|
|
|
|
|
static ssize_t \
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
|
|
|
|
|
char *buf) \
|
2007-08-02 23:09:59 +08:00
|
|
|
{ \
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);\
|
2007-08-02 23:09:59 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", vport->cfg_##attr);\
|
2007-08-02 23:09:59 +08:00
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_vport_param_hex_show - Return hex formatted attribute value
|
2008-08-25 09:49:00 +08:00
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* Macro that given an attr e.g.
|
|
|
|
|
* hba_queue_depth expands into a function with the name
|
|
|
|
|
* lpfc_hba_queue_depth_show
|
|
|
|
|
*
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_##attr##_show: prints the attribute value in hexadecimal.
|
2008-08-25 09:49:00 +08:00
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
2009-04-07 06:47:14 +08:00
|
|
|
* @buf: on return contains the attribute value in hexadecimal.
|
2008-08-25 09:49:00 +08:00
|
|
|
*
|
|
|
|
|
* Returns: length of formatted string.
|
|
|
|
|
**/
|
2007-08-02 23:09:59 +08:00
|
|
|
#define lpfc_vport_param_hex_show(attr) \
|
|
|
|
|
static ssize_t \
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
|
|
|
|
|
char *buf) \
|
2007-08-02 23:09:59 +08:00
|
|
|
{ \
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);\
|
2007-08-02 23:09:59 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%#x\n", vport->cfg_##attr);\
|
2007-08-02 23:09:59 +08:00
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_vport_param_init - Initialize a vport cfg attribute
|
2008-08-25 09:49:00 +08:00
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* Macro that given an attr e.g. hba_queue_depth expands
|
|
|
|
|
* into a function with the name lpfc_hba_queue_depth_init. The macro also
|
|
|
|
|
* takes a default argument, a minimum and maximum argument.
|
|
|
|
|
*
|
|
|
|
|
* lpfc_##attr##_init: validates the min and max values then sets the
|
|
|
|
|
* adapter config field accordingly, or uses the default if out of range
|
|
|
|
|
* and prints an error message.
|
|
|
|
|
* @phba: pointer the the adapter structure.
|
|
|
|
|
* @val: integer attribute value.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* zero on success
|
|
|
|
|
* -EINVAL if default used
|
|
|
|
|
**/
|
2007-08-02 23:09:59 +08:00
|
|
|
#define lpfc_vport_param_init(attr, default, minval, maxval) \
|
|
|
|
|
static int \
|
2010-02-13 03:42:33 +08:00
|
|
|
lpfc_##attr##_init(struct lpfc_vport *vport, uint val) \
|
2007-08-02 23:09:59 +08:00
|
|
|
{ \
|
2016-06-16 04:42:17 +08:00
|
|
|
if (lpfc_rangecheck(val, minval, maxval)) {\
|
2007-08-02 23:09:59 +08:00
|
|
|
vport->cfg_##attr = val;\
|
|
|
|
|
return 0;\
|
|
|
|
|
}\
|
2007-08-02 23:10:09 +08:00
|
|
|
lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
|
2024-06-12 13:13:20 +08:00
|
|
|
"0423 lpfc_"#attr" attribute cannot be set to %d, "\
|
|
|
|
|
"allowed range is ["#minval", "#maxval"]\n", val); \
|
2007-08-02 23:09:59 +08:00
|
|
|
vport->cfg_##attr = default;\
|
|
|
|
|
return -EINVAL;\
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_vport_param_set - Set a vport cfg attribute
|
2008-08-25 09:49:00 +08:00
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* Macro that given an attr e.g. hba_queue_depth expands
|
|
|
|
|
* into a function with the name lpfc_hba_queue_depth_set
|
|
|
|
|
*
|
|
|
|
|
* lpfc_##attr##_set: validates the min and max values then sets the
|
|
|
|
|
* adapter config field if in the valid range. prints error message
|
|
|
|
|
* and does not set the parameter if invalid.
|
|
|
|
|
* @phba: pointer the the adapter structure.
|
|
|
|
|
* @val: integer attribute value.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* zero on success
|
|
|
|
|
* -EINVAL if val is invalid
|
|
|
|
|
**/
|
2007-08-02 23:09:59 +08:00
|
|
|
#define lpfc_vport_param_set(attr, default, minval, maxval) \
|
|
|
|
|
static int \
|
2010-02-13 03:42:33 +08:00
|
|
|
lpfc_##attr##_set(struct lpfc_vport *vport, uint val) \
|
2007-08-02 23:09:59 +08:00
|
|
|
{ \
|
2016-06-16 04:42:17 +08:00
|
|
|
if (lpfc_rangecheck(val, minval, maxval)) {\
|
2011-07-23 06:36:33 +08:00
|
|
|
lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
|
2024-06-12 13:13:20 +08:00
|
|
|
"3053 lpfc_" #attr \
|
2013-09-07 00:20:20 +08:00
|
|
|
" changed from %d (x%x) to %d (x%x)\n", \
|
|
|
|
|
vport->cfg_##attr, vport->cfg_##attr, \
|
|
|
|
|
val, val); \
|
2007-08-02 23:09:59 +08:00
|
|
|
vport->cfg_##attr = val;\
|
|
|
|
|
return 0;\
|
|
|
|
|
}\
|
2007-08-02 23:10:09 +08:00
|
|
|
lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
|
2024-06-12 13:13:20 +08:00
|
|
|
"0424 lpfc_"#attr" attribute cannot be set to %d, "\
|
|
|
|
|
"allowed range is ["#minval", "#maxval"]\n", val); \
|
2007-08-02 23:09:59 +08:00
|
|
|
return -EINVAL;\
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_vport_param_store - Set a vport attribute
|
2008-08-25 09:49:00 +08:00
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* Macro that given an attr e.g. hba_queue_depth
|
|
|
|
|
* expands into a function with the name lpfc_hba_queue_depth_store
|
|
|
|
|
*
|
|
|
|
|
* lpfc_##attr##_store: convert the ascii text number to an integer, then
|
|
|
|
|
* use the lpfc_##attr##_set function to set the value.
|
|
|
|
|
* @cdev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @buf: contains the attribute value in decimal.
|
|
|
|
|
* @count: not used.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* -EINVAL if val is invalid or lpfc_##attr##_set() fails
|
|
|
|
|
* length of buffer upon success.
|
|
|
|
|
**/
|
2007-08-02 23:09:59 +08:00
|
|
|
#define lpfc_vport_param_store(attr) \
|
|
|
|
|
static ssize_t \
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \
|
|
|
|
|
const char *buf, size_t count) \
|
2007-08-02 23:09:59 +08:00
|
|
|
{ \
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);\
|
2007-08-02 23:09:59 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
|
2010-02-13 03:42:33 +08:00
|
|
|
uint val = 0;\
|
2007-08-02 23:09:59 +08:00
|
|
|
if (!isdigit(buf[0]))\
|
|
|
|
|
return -EINVAL;\
|
|
|
|
|
if (sscanf(buf, "%i", &val) != 1)\
|
|
|
|
|
return -EINVAL;\
|
|
|
|
|
if (lpfc_##attr##_set(vport, val) == 0) \
|
|
|
|
|
return strlen(buf);\
|
|
|
|
|
else \
|
|
|
|
|
return -EINVAL;\
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2017-02-13 05:52:30 +08:00
|
|
|
static DEVICE_ATTR(nvme_info, 0444, lpfc_nvme_info_show, NULL);
|
2019-01-29 03:14:25 +08:00
|
|
|
static DEVICE_ATTR(scsi_stat, 0444, lpfc_scsi_stat_show, NULL);
|
2008-12-05 11:39:46 +08:00
|
|
|
static DEVICE_ATTR(bg_info, S_IRUGO, lpfc_bg_info_show, NULL);
|
|
|
|
|
static DEVICE_ATTR(bg_guard_err, S_IRUGO, lpfc_bg_guard_err_show, NULL);
|
|
|
|
|
static DEVICE_ATTR(bg_apptag_err, S_IRUGO, lpfc_bg_apptag_err_show, NULL);
|
|
|
|
|
static DEVICE_ATTR(bg_reftag_err, S_IRUGO, lpfc_bg_reftag_err_show, NULL);
|
2008-02-22 07:13:36 +08:00
|
|
|
static DEVICE_ATTR(info, S_IRUGO, lpfc_info_show, NULL);
|
|
|
|
|
static DEVICE_ATTR(serialnum, S_IRUGO, lpfc_serialnum_show, NULL);
|
|
|
|
|
static DEVICE_ATTR(modeldesc, S_IRUGO, lpfc_modeldesc_show, NULL);
|
|
|
|
|
static DEVICE_ATTR(modelname, S_IRUGO, lpfc_modelname_show, NULL);
|
|
|
|
|
static DEVICE_ATTR(programtype, S_IRUGO, lpfc_programtype_show, NULL);
|
|
|
|
|
static DEVICE_ATTR(portnum, S_IRUGO, lpfc_vportnum_show, NULL);
|
|
|
|
|
static DEVICE_ATTR(fwrev, S_IRUGO, lpfc_fwrev_show, NULL);
|
|
|
|
|
static DEVICE_ATTR(hdw, S_IRUGO, lpfc_hdw_show, NULL);
|
2010-02-13 03:42:33 +08:00
|
|
|
static DEVICE_ATTR(link_state, S_IRUGO | S_IWUSR, lpfc_link_state_show,
|
|
|
|
|
lpfc_link_state_store);
|
2008-02-22 07:13:36 +08:00
|
|
|
static DEVICE_ATTR(option_rom_version, S_IRUGO,
|
|
|
|
|
lpfc_option_rom_version_show, NULL);
|
|
|
|
|
static DEVICE_ATTR(num_discovered_ports, S_IRUGO,
|
|
|
|
|
lpfc_num_discovered_ports_show, NULL);
|
2008-08-25 09:50:06 +08:00
|
|
|
static DEVICE_ATTR(menlo_mgmt_mode, S_IRUGO, lpfc_mlomgmt_show, NULL);
|
2008-02-22 07:13:36 +08:00
|
|
|
static DEVICE_ATTR(nport_evt_cnt, S_IRUGO, lpfc_nport_evt_cnt_show, NULL);
|
2024-06-12 13:13:20 +08:00
|
|
|
static DEVICE_ATTR_RO(lpfc_drvr_version);
|
|
|
|
|
static DEVICE_ATTR_RO(lpfc_enable_fip);
|
2008-02-22 07:13:36 +08:00
|
|
|
static DEVICE_ATTR(board_mode, S_IRUGO | S_IWUSR,
|
|
|
|
|
lpfc_board_mode_show, lpfc_board_mode_store);
|
|
|
|
|
static DEVICE_ATTR(issue_reset, S_IWUSR, NULL, lpfc_issue_reset);
|
|
|
|
|
static DEVICE_ATTR(max_vpi, S_IRUGO, lpfc_max_vpi_show, NULL);
|
|
|
|
|
static DEVICE_ATTR(used_vpi, S_IRUGO, lpfc_used_vpi_show, NULL);
|
|
|
|
|
static DEVICE_ATTR(max_rpi, S_IRUGO, lpfc_max_rpi_show, NULL);
|
|
|
|
|
static DEVICE_ATTR(used_rpi, S_IRUGO, lpfc_used_rpi_show, NULL);
|
|
|
|
|
static DEVICE_ATTR(max_xri, S_IRUGO, lpfc_max_xri_show, NULL);
|
|
|
|
|
static DEVICE_ATTR(used_xri, S_IRUGO, lpfc_used_xri_show, NULL);
|
|
|
|
|
static DEVICE_ATTR(npiv_info, S_IRUGO, lpfc_npiv_info_show, NULL);
|
2024-06-12 13:13:20 +08:00
|
|
|
static DEVICE_ATTR_RO(lpfc_temp_sensor);
|
|
|
|
|
static DEVICE_ATTR_RO(lpfc_fips_level);
|
|
|
|
|
static DEVICE_ATTR_RO(lpfc_fips_rev);
|
|
|
|
|
static DEVICE_ATTR_RO(lpfc_dss);
|
|
|
|
|
static DEVICE_ATTR_RO(lpfc_sriov_hw_max_virtfn);
|
2011-12-14 02:20:45 +08:00
|
|
|
static DEVICE_ATTR(protocol, S_IRUGO, lpfc_sli4_protocol_show, NULL);
|
2014-02-20 22:56:45 +08:00
|
|
|
static DEVICE_ATTR(lpfc_xlane_supported, S_IRUGO, lpfc_oas_supported_show,
|
|
|
|
|
NULL);
|
2006-08-19 05:47:18 +08:00
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
static char *lpfc_soft_wwn_key = "C99G71SL8032A";
|
2014-02-20 22:56:45 +08:00
|
|
|
#define WWN_SZ 8
|
|
|
|
|
/**
|
|
|
|
|
* lpfc_wwn_set - Convert string to the 8 byte WWN value.
|
|
|
|
|
* @buf: WWN string.
|
|
|
|
|
* @cnt: Length of string.
|
|
|
|
|
* @wwn: Array to receive converted wwn value.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* -EINVAL if the buffer does not contain a valid wwn
|
|
|
|
|
* 0 success
|
|
|
|
|
**/
|
|
|
|
|
static size_t
|
|
|
|
|
lpfc_wwn_set(const char *buf, size_t cnt, char wwn[])
|
|
|
|
|
{
|
|
|
|
|
unsigned int i, j;
|
|
|
|
|
|
|
|
|
|
/* Count may include a LF at end of string */
|
|
|
|
|
if (buf[cnt-1] == '\n')
|
|
|
|
|
cnt--;
|
2006-08-19 05:47:18 +08:00
|
|
|
|
2014-02-20 22:56:45 +08:00
|
|
|
if ((cnt < 16) || (cnt > 18) || ((cnt == 17) && (*buf++ != 'x')) ||
|
|
|
|
|
((cnt == 18) && ((*buf++ != '0') || (*buf++ != 'x'))))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
memset(wwn, 0, WWN_SZ);
|
|
|
|
|
|
|
|
|
|
/* Validate and store the new name */
|
|
|
|
|
for (i = 0, j = 0; i < 16; i++) {
|
|
|
|
|
if ((*buf >= 'a') && (*buf <= 'f'))
|
|
|
|
|
j = ((j << 4) | ((*buf++ - 'a') + 10));
|
|
|
|
|
else if ((*buf >= 'A') && (*buf <= 'F'))
|
|
|
|
|
j = ((j << 4) | ((*buf++ - 'A') + 10));
|
|
|
|
|
else if ((*buf >= '0') && (*buf <= '9'))
|
|
|
|
|
j = ((j << 4) | (*buf++ - '0'));
|
|
|
|
|
else
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
if (i % 2) {
|
|
|
|
|
wwn[i/2] = j & 0xff;
|
|
|
|
|
j = 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2024-06-12 13:13:20 +08:00
|
|
|
/**
|
|
|
|
|
* lpfc_soft_wwn_enable_store - Allows setting of the wwn if the key is valid
|
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: containing the string lpfc_soft_wwn_key.
|
|
|
|
|
* @count: must be size of lpfc_soft_wwn_key.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* -EINVAL if the buffer does not contain lpfc_soft_wwn_key
|
|
|
|
|
* length of buf indicates success
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_soft_wwn_enable_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
const char *buf, size_t count)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
unsigned int cnt = count;
|
|
|
|
|
uint8_t vvvl = vport->fc_sparam.cmn.valid_vendor_ver_level;
|
|
|
|
|
u32 *fawwpn_key = (uint32_t *)&vport->fc_sparam.un.vendorVersion[0];
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* We're doing a simple sanity check for soft_wwpn setting.
|
|
|
|
|
* We require that the user write a specific key to enable
|
|
|
|
|
* the soft_wwpn attribute to be settable. Once the attribute
|
|
|
|
|
* is written, the enable key resets. If further updates are
|
|
|
|
|
* desired, the key must be written again to re-enable the
|
|
|
|
|
* attribute.
|
|
|
|
|
*
|
|
|
|
|
* The "key" is not secret - it is a hardcoded string shown
|
|
|
|
|
* here. The intent is to protect against the random user or
|
|
|
|
|
* application that is just writing attributes.
|
|
|
|
|
*/
|
|
|
|
|
if (vvvl == 1 && cpu_to_be32(*fawwpn_key) == FAPWWN_KEY_VENDOR) {
|
|
|
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
|
|
|
|
|
"0051 "LPFC_DRIVER_NAME" soft wwpn can not"
|
|
|
|
|
" be enabled: fawwpn is enabled\n");
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* count may include a LF at end of string */
|
|
|
|
|
if (buf[cnt-1] == '\n')
|
|
|
|
|
cnt--;
|
|
|
|
|
|
|
|
|
|
if ((cnt != strlen(lpfc_soft_wwn_key)) ||
|
|
|
|
|
(strncmp(buf, lpfc_soft_wwn_key, strlen(lpfc_soft_wwn_key)) != 0))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
phba->soft_wwn_enable = 1;
|
|
|
|
|
|
|
|
|
|
dev_printk(KERN_WARNING, &phba->pcidev->dev,
|
|
|
|
|
"lpfc%d: soft_wwpn assignment has been enabled.\n",
|
|
|
|
|
phba->brd_no);
|
|
|
|
|
dev_printk(KERN_WARNING, &phba->pcidev->dev,
|
|
|
|
|
" The soft_wwpn feature is not supported by Broadcom.");
|
|
|
|
|
|
|
|
|
|
return count;
|
|
|
|
|
}
|
|
|
|
|
static DEVICE_ATTR_WO(lpfc_soft_wwn_enable);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* lpfc_soft_wwpn_show - Return the cfg soft ww port name of the adapter
|
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: on return contains the wwpn in hexadecimal.
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_soft_wwpn_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
|
|
|
|
|
return scnprintf(buf, PAGE_SIZE, "0x%llx\n",
|
|
|
|
|
(unsigned long long)phba->cfg_soft_wwpn);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* lpfc_soft_wwpn_store - Set the ww port name of the adapter
|
|
|
|
|
* @dev class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: contains the wwpn in hexadecimal.
|
|
|
|
|
* @count: number of wwpn bytes in buf
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* -EACCES hba reset not enabled, adapter over temp
|
|
|
|
|
* -EINVAL soft wwn not enabled, count is invalid, invalid wwpn byte invalid
|
|
|
|
|
* -EIO error taking adapter offline or online
|
|
|
|
|
* value of count on success
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_soft_wwpn_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
const char *buf, size_t count)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
struct completion online_compl;
|
|
|
|
|
int stat1 = 0, stat2 = 0;
|
|
|
|
|
unsigned int cnt = count;
|
|
|
|
|
u8 wwpn[WWN_SZ];
|
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
|
|
if (!phba->cfg_enable_hba_reset)
|
|
|
|
|
return -EACCES;
|
|
|
|
|
spin_lock_irq(&phba->hbalock);
|
|
|
|
|
if (phba->over_temp_state == HBA_OVER_TEMP) {
|
|
|
|
|
spin_unlock_irq(&phba->hbalock);
|
|
|
|
|
return -EACCES;
|
|
|
|
|
}
|
|
|
|
|
spin_unlock_irq(&phba->hbalock);
|
|
|
|
|
/* count may include a LF at end of string */
|
|
|
|
|
if (buf[cnt-1] == '\n')
|
|
|
|
|
cnt--;
|
|
|
|
|
|
|
|
|
|
if (!phba->soft_wwn_enable)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
/* lock setting wwpn, wwnn down */
|
|
|
|
|
phba->soft_wwn_enable = 0;
|
|
|
|
|
|
|
|
|
|
rc = lpfc_wwn_set(buf, cnt, wwpn);
|
|
|
|
|
if (rc) {
|
|
|
|
|
/* not able to set wwpn, unlock it */
|
|
|
|
|
phba->soft_wwn_enable = 1;
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
phba->cfg_soft_wwpn = wwn_to_u64(wwpn);
|
|
|
|
|
fc_host_port_name(shost) = phba->cfg_soft_wwpn;
|
|
|
|
|
if (phba->cfg_soft_wwnn)
|
|
|
|
|
fc_host_node_name(shost) = phba->cfg_soft_wwnn;
|
|
|
|
|
|
|
|
|
|
dev_printk(KERN_NOTICE, &phba->pcidev->dev,
|
|
|
|
|
"lpfc%d: Reinitializing to use soft_wwpn\n", phba->brd_no);
|
|
|
|
|
|
|
|
|
|
stat1 = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
|
|
|
|
|
if (stat1)
|
|
|
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
|
|
|
|
|
"0463 lpfc_soft_wwpn attribute set failed to "
|
|
|
|
|
"reinit adapter - %d\n", stat1);
|
|
|
|
|
init_completion(&online_compl);
|
|
|
|
|
rc = lpfc_workq_post_event(phba, &stat2, &online_compl,
|
|
|
|
|
LPFC_EVT_ONLINE);
|
|
|
|
|
if (rc == 0)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
wait_for_completion(&online_compl);
|
|
|
|
|
if (stat2)
|
|
|
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
|
|
|
|
|
"0464 lpfc_soft_wwpn attribute set failed to "
|
|
|
|
|
"reinit adapter - %d\n", stat2);
|
|
|
|
|
return (stat1 || stat2) ? -EIO : count;
|
|
|
|
|
}
|
|
|
|
|
static DEVICE_ATTR_RW(lpfc_soft_wwpn);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* lpfc_soft_wwnn_show - Return the cfg soft ww node name for the adapter
|
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: on return contains the wwnn in hexadecimal.
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_soft_wwnn_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
|
|
|
|
|
return scnprintf(buf, PAGE_SIZE, "0x%llx\n",
|
|
|
|
|
(unsigned long long)phba->cfg_soft_wwnn);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* lpfc_soft_wwnn_store - sets the ww node name of the adapter
|
|
|
|
|
* @cdev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @buf: contains the ww node name in hexadecimal.
|
|
|
|
|
* @count: number of wwnn bytes in buf.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* -EINVAL soft wwn not enabled, count is invalid, invalid wwnn byte invalid
|
|
|
|
|
* value of count on success
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_soft_wwnn_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
const char *buf, size_t count)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
|
|
|
|
|
unsigned int cnt = count;
|
|
|
|
|
u8 wwnn[WWN_SZ];
|
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
|
|
/* count may include a LF at end of string */
|
|
|
|
|
if (buf[cnt-1] == '\n')
|
|
|
|
|
cnt--;
|
|
|
|
|
|
|
|
|
|
if (!phba->soft_wwn_enable)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
rc = lpfc_wwn_set(buf, cnt, wwnn);
|
|
|
|
|
if (rc) {
|
|
|
|
|
/* Allow wwnn to be set many times, as long as the enable
|
|
|
|
|
* is set. However, once the wwpn is set, everything locks.
|
|
|
|
|
*/
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
phba->cfg_soft_wwnn = wwn_to_u64(wwnn);
|
|
|
|
|
|
|
|
|
|
dev_printk(KERN_NOTICE, &phba->pcidev->dev,
|
|
|
|
|
"lpfc%d: soft_wwnn set. Value will take effect upon "
|
|
|
|
|
"setting of the soft_wwpn\n", phba->brd_no);
|
|
|
|
|
|
|
|
|
|
return count;
|
|
|
|
|
}
|
|
|
|
|
static DEVICE_ATTR_RW(lpfc_soft_wwnn);
|
2006-12-03 02:35:30 +08:00
|
|
|
|
2014-02-20 22:56:45 +08:00
|
|
|
/**
|
|
|
|
|
* lpfc_oas_tgt_show - Return wwpn of target whose luns maybe enabled for
|
|
|
|
|
* Optimized Access Storage (OAS) operations.
|
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: buffer for passing information.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* value of count
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_oas_tgt_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
|
|
|
|
|
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "0x%llx\n",
|
2014-02-20 22:56:45 +08:00
|
|
|
wwn_to_u64(phba->cfg_oas_tgt_wwpn));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* lpfc_oas_tgt_store - Store wwpn of target whose luns maybe enabled for
|
|
|
|
|
* Optimized Access Storage (OAS) operations.
|
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: buffer for passing information.
|
|
|
|
|
* @count: Size of the data buffer.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* -EINVAL count is invalid, invalid wwpn byte invalid
|
|
|
|
|
* -EPERM oas is not supported by hba
|
|
|
|
|
* value of count on success
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_oas_tgt_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
const char *buf, size_t count)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
|
|
|
|
|
unsigned int cnt = count;
|
|
|
|
|
uint8_t wwpn[WWN_SZ];
|
|
|
|
|
int rc;
|
|
|
|
|
|
2014-04-05 01:52:21 +08:00
|
|
|
if (!phba->cfg_fof)
|
2014-02-20 22:56:45 +08:00
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
|
|
/* count may include a LF at end of string */
|
|
|
|
|
if (buf[cnt-1] == '\n')
|
|
|
|
|
cnt--;
|
|
|
|
|
|
|
|
|
|
rc = lpfc_wwn_set(buf, cnt, wwpn);
|
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
|
|
memcpy(phba->cfg_oas_tgt_wwpn, wwpn, (8 * sizeof(uint8_t)));
|
|
|
|
|
memcpy(phba->sli4_hba.oas_next_tgt_wwpn, wwpn, (8 * sizeof(uint8_t)));
|
|
|
|
|
if (wwn_to_u64(wwpn) == 0)
|
|
|
|
|
phba->cfg_oas_flags |= OAS_FIND_ANY_TARGET;
|
|
|
|
|
else
|
|
|
|
|
phba->cfg_oas_flags &= ~OAS_FIND_ANY_TARGET;
|
|
|
|
|
phba->cfg_oas_flags &= ~OAS_LUN_VALID;
|
|
|
|
|
phba->sli4_hba.oas_next_lun = FIND_FIRST_OAS_LUN;
|
|
|
|
|
return count;
|
|
|
|
|
}
|
|
|
|
|
static DEVICE_ATTR(lpfc_xlane_tgt, S_IRUGO | S_IWUSR,
|
|
|
|
|
lpfc_oas_tgt_show, lpfc_oas_tgt_store);
|
|
|
|
|
|
2016-07-07 03:36:05 +08:00
|
|
|
/**
|
|
|
|
|
* lpfc_oas_priority_show - Return wwpn of target whose luns maybe enabled for
|
|
|
|
|
* Optimized Access Storage (OAS) operations.
|
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: buffer for passing information.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* value of count
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_oas_priority_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
|
|
|
|
|
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", phba->cfg_oas_priority);
|
2016-07-07 03:36:05 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* lpfc_oas_priority_store - Store wwpn of target whose luns maybe enabled for
|
|
|
|
|
* Optimized Access Storage (OAS) operations.
|
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: buffer for passing information.
|
|
|
|
|
* @count: Size of the data buffer.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* -EINVAL count is invalid, invalid wwpn byte invalid
|
|
|
|
|
* -EPERM oas is not supported by hba
|
|
|
|
|
* value of count on success
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_oas_priority_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
const char *buf, size_t count)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
|
|
|
|
|
unsigned int cnt = count;
|
|
|
|
|
unsigned long val;
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
if (!phba->cfg_fof)
|
|
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
|
|
/* count may include a LF at end of string */
|
|
|
|
|
if (buf[cnt-1] == '\n')
|
|
|
|
|
cnt--;
|
|
|
|
|
|
|
|
|
|
ret = kstrtoul(buf, 0, &val);
|
|
|
|
|
if (ret || (val > 0x7f))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
if (val)
|
|
|
|
|
phba->cfg_oas_priority = (uint8_t)val;
|
|
|
|
|
else
|
|
|
|
|
phba->cfg_oas_priority = phba->cfg_XLanePriority;
|
2016-07-07 03:36:05 +08:00
|
|
|
return count;
|
|
|
|
|
}
|
|
|
|
|
static DEVICE_ATTR(lpfc_xlane_priority, S_IRUGO | S_IWUSR,
|
|
|
|
|
lpfc_oas_priority_show, lpfc_oas_priority_store);
|
|
|
|
|
|
2014-02-20 22:56:45 +08:00
|
|
|
/**
|
|
|
|
|
* lpfc_oas_vpt_show - Return wwpn of vport whose targets maybe enabled
|
|
|
|
|
* for Optimized Access Storage (OAS) operations.
|
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: buffer for passing information.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* value of count on success
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_oas_vpt_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
|
|
|
|
|
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "0x%llx\n",
|
2014-02-20 22:56:45 +08:00
|
|
|
wwn_to_u64(phba->cfg_oas_vpt_wwpn));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* lpfc_oas_vpt_store - Store wwpn of vport whose targets maybe enabled
|
|
|
|
|
* for Optimized Access Storage (OAS) operations.
|
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: buffer for passing information.
|
|
|
|
|
* @count: Size of the data buffer.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* -EINVAL count is invalid, invalid wwpn byte invalid
|
|
|
|
|
* -EPERM oas is not supported by hba
|
|
|
|
|
* value of count on success
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_oas_vpt_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
const char *buf, size_t count)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
|
|
|
|
|
unsigned int cnt = count;
|
|
|
|
|
uint8_t wwpn[WWN_SZ];
|
|
|
|
|
int rc;
|
|
|
|
|
|
2014-04-05 01:52:21 +08:00
|
|
|
if (!phba->cfg_fof)
|
2014-02-20 22:56:45 +08:00
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
|
|
/* count may include a LF at end of string */
|
|
|
|
|
if (buf[cnt-1] == '\n')
|
|
|
|
|
cnt--;
|
|
|
|
|
|
|
|
|
|
rc = lpfc_wwn_set(buf, cnt, wwpn);
|
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
|
|
memcpy(phba->cfg_oas_vpt_wwpn, wwpn, (8 * sizeof(uint8_t)));
|
|
|
|
|
memcpy(phba->sli4_hba.oas_next_vpt_wwpn, wwpn, (8 * sizeof(uint8_t)));
|
|
|
|
|
if (wwn_to_u64(wwpn) == 0)
|
|
|
|
|
phba->cfg_oas_flags |= OAS_FIND_ANY_VPORT;
|
|
|
|
|
else
|
|
|
|
|
phba->cfg_oas_flags &= ~OAS_FIND_ANY_VPORT;
|
|
|
|
|
phba->cfg_oas_flags &= ~OAS_LUN_VALID;
|
2016-12-20 07:07:26 +08:00
|
|
|
if (phba->cfg_oas_priority == 0)
|
|
|
|
|
phba->cfg_oas_priority = phba->cfg_XLanePriority;
|
2014-02-20 22:56:45 +08:00
|
|
|
phba->sli4_hba.oas_next_lun = FIND_FIRST_OAS_LUN;
|
|
|
|
|
return count;
|
|
|
|
|
}
|
|
|
|
|
static DEVICE_ATTR(lpfc_xlane_vpt, S_IRUGO | S_IWUSR,
|
|
|
|
|
lpfc_oas_vpt_show, lpfc_oas_vpt_store);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* lpfc_oas_lun_state_show - Return the current state (enabled or disabled)
|
|
|
|
|
* of whether luns will be enabled or disabled
|
|
|
|
|
* for Optimized Access Storage (OAS) operations.
|
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: buffer for passing information.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* size of formatted string.
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_oas_lun_state_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
|
|
|
|
|
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", phba->cfg_oas_lun_state);
|
2014-02-20 22:56:45 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* lpfc_oas_lun_state_store - Store the state (enabled or disabled)
|
|
|
|
|
* of whether luns will be enabled or disabled
|
|
|
|
|
* for Optimized Access Storage (OAS) operations.
|
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: buffer for passing information.
|
|
|
|
|
* @count: Size of the data buffer.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* -EINVAL count is invalid, invalid wwpn byte invalid
|
|
|
|
|
* -EPERM oas is not supported by hba
|
|
|
|
|
* value of count on success
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_oas_lun_state_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
const char *buf, size_t count)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
|
|
|
|
|
int val = 0;
|
|
|
|
|
|
2014-04-05 01:52:21 +08:00
|
|
|
if (!phba->cfg_fof)
|
2014-02-20 22:56:45 +08:00
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
|
|
if (!isdigit(buf[0]))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
if (sscanf(buf, "%i", &val) != 1)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
if ((val != 0) && (val != 1))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
phba->cfg_oas_lun_state = val;
|
|
|
|
|
return strlen(buf);
|
|
|
|
|
}
|
|
|
|
|
static DEVICE_ATTR(lpfc_xlane_lun_state, S_IRUGO | S_IWUSR,
|
|
|
|
|
lpfc_oas_lun_state_show, lpfc_oas_lun_state_store);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* lpfc_oas_lun_status_show - Return the status of the Optimized Access
|
|
|
|
|
* Storage (OAS) lun returned by the
|
|
|
|
|
* lpfc_oas_lun_show function.
|
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: buffer for passing information.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* size of formatted string.
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_oas_lun_status_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
|
|
|
|
|
|
|
|
|
|
if (!(phba->cfg_oas_flags & OAS_LUN_VALID))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", phba->cfg_oas_lun_status);
|
2014-02-20 22:56:45 +08:00
|
|
|
}
|
|
|
|
|
static DEVICE_ATTR(lpfc_xlane_lun_status, S_IRUGO,
|
|
|
|
|
lpfc_oas_lun_status_show, NULL);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* lpfc_oas_lun_state_set - enable or disable a lun for Optimized Access Storage
|
|
|
|
|
* (OAS) operations.
|
|
|
|
|
* @phba: lpfc_hba pointer.
|
|
|
|
|
* @ndlp: pointer to fcp target node.
|
|
|
|
|
* @lun: the fc lun for setting oas state.
|
|
|
|
|
* @oas_state: the oas state to be set to the lun.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* SUCCESS : 0
|
|
|
|
|
* -EPERM OAS is not enabled or not supported by this port.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
static size_t
|
|
|
|
|
lpfc_oas_lun_state_set(struct lpfc_hba *phba, uint8_t vpt_wwpn[],
|
2016-07-07 03:36:05 +08:00
|
|
|
uint8_t tgt_wwpn[], uint64_t lun,
|
|
|
|
|
uint32_t oas_state, uint8_t pri)
|
2014-02-20 22:56:45 +08:00
|
|
|
{
|
|
|
|
|
|
|
|
|
|
int rc = 0;
|
|
|
|
|
|
2014-04-05 01:52:21 +08:00
|
|
|
if (!phba->cfg_fof)
|
2014-02-20 22:56:45 +08:00
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
|
|
if (oas_state) {
|
|
|
|
|
if (!lpfc_enable_oas_lun(phba, (struct lpfc_name *)vpt_wwpn,
|
2016-07-07 03:36:05 +08:00
|
|
|
(struct lpfc_name *)tgt_wwpn,
|
|
|
|
|
lun, pri))
|
2014-02-20 22:56:45 +08:00
|
|
|
rc = -ENOMEM;
|
|
|
|
|
} else {
|
|
|
|
|
lpfc_disable_oas_lun(phba, (struct lpfc_name *)vpt_wwpn,
|
2016-12-20 07:07:26 +08:00
|
|
|
(struct lpfc_name *)tgt_wwpn, lun, pri);
|
2014-02-20 22:56:45 +08:00
|
|
|
}
|
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* lpfc_oas_lun_get_next - get the next lun that has been enabled for Optimized
|
|
|
|
|
* Access Storage (OAS) operations.
|
|
|
|
|
* @phba: lpfc_hba pointer.
|
|
|
|
|
* @vpt_wwpn: wwpn of the vport associated with the returned lun
|
|
|
|
|
* @tgt_wwpn: wwpn of the target associated with the returned lun
|
|
|
|
|
* @lun_status: status of the lun returned lun
|
|
|
|
|
*
|
|
|
|
|
* Returns the first or next lun enabled for OAS operations for the vport/target
|
|
|
|
|
* specified. If a lun is found, its vport wwpn, target wwpn and status is
|
|
|
|
|
* returned. If the lun is not found, NOT_OAS_ENABLED_LUN is returned.
|
|
|
|
|
*
|
|
|
|
|
* Return:
|
|
|
|
|
* lun that is OAS enabled for the vport/target
|
|
|
|
|
* NOT_OAS_ENABLED_LUN when no oas enabled lun found.
|
|
|
|
|
*/
|
|
|
|
|
static uint64_t
|
|
|
|
|
lpfc_oas_lun_get_next(struct lpfc_hba *phba, uint8_t vpt_wwpn[],
|
2016-12-20 07:07:26 +08:00
|
|
|
uint8_t tgt_wwpn[], uint32_t *lun_status,
|
|
|
|
|
uint32_t *lun_pri)
|
2014-02-20 22:56:45 +08:00
|
|
|
{
|
|
|
|
|
uint64_t found_lun;
|
|
|
|
|
|
|
|
|
|
if (unlikely(!phba) || !vpt_wwpn || !tgt_wwpn)
|
|
|
|
|
return NOT_OAS_ENABLED_LUN;
|
|
|
|
|
if (lpfc_find_next_oas_lun(phba, (struct lpfc_name *)
|
|
|
|
|
phba->sli4_hba.oas_next_vpt_wwpn,
|
|
|
|
|
(struct lpfc_name *)
|
|
|
|
|
phba->sli4_hba.oas_next_tgt_wwpn,
|
|
|
|
|
&phba->sli4_hba.oas_next_lun,
|
|
|
|
|
(struct lpfc_name *)vpt_wwpn,
|
|
|
|
|
(struct lpfc_name *)tgt_wwpn,
|
2016-12-20 07:07:26 +08:00
|
|
|
&found_lun, lun_status, lun_pri))
|
2014-02-20 22:56:45 +08:00
|
|
|
return found_lun;
|
|
|
|
|
else
|
|
|
|
|
return NOT_OAS_ENABLED_LUN;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* lpfc_oas_lun_state_change - enable/disable a lun for OAS operations
|
|
|
|
|
* @phba: lpfc_hba pointer.
|
|
|
|
|
* @vpt_wwpn: vport wwpn by reference.
|
|
|
|
|
* @tgt_wwpn: target wwpn by reference.
|
|
|
|
|
* @lun: the fc lun for setting oas state.
|
|
|
|
|
* @oas_state: the oas state to be set to the oas_lun.
|
|
|
|
|
*
|
|
|
|
|
* This routine enables (OAS_LUN_ENABLE) or disables (OAS_LUN_DISABLE)
|
|
|
|
|
* a lun for OAS operations.
|
|
|
|
|
*
|
|
|
|
|
* Return:
|
|
|
|
|
* SUCCESS: 0
|
|
|
|
|
* -ENOMEM: failed to enable an lun for OAS operations
|
|
|
|
|
* -EPERM: OAS is not enabled
|
|
|
|
|
*/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_oas_lun_state_change(struct lpfc_hba *phba, uint8_t vpt_wwpn[],
|
|
|
|
|
uint8_t tgt_wwpn[], uint64_t lun,
|
2016-07-07 03:36:05 +08:00
|
|
|
uint32_t oas_state, uint8_t pri)
|
2014-02-20 22:56:45 +08:00
|
|
|
{
|
|
|
|
|
|
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
|
|
rc = lpfc_oas_lun_state_set(phba, vpt_wwpn, tgt_wwpn, lun,
|
2016-07-07 03:36:05 +08:00
|
|
|
oas_state, pri);
|
2014-02-20 22:56:45 +08:00
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* lpfc_oas_lun_show - Return oas enabled luns from a chosen target
|
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: buffer for passing information.
|
|
|
|
|
*
|
|
|
|
|
* This routine returns a lun enabled for OAS each time the function
|
|
|
|
|
* is called.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* SUCCESS: size of formatted string.
|
|
|
|
|
* -EFAULT: target or vport wwpn was not set properly.
|
|
|
|
|
* -EPERM: oas is not enabled.
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_oas_lun_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
|
|
|
|
|
|
|
|
|
|
uint64_t oas_lun;
|
|
|
|
|
int len = 0;
|
|
|
|
|
|
2014-04-05 01:52:21 +08:00
|
|
|
if (!phba->cfg_fof)
|
2014-02-20 22:56:45 +08:00
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
|
|
if (wwn_to_u64(phba->cfg_oas_vpt_wwpn) == 0)
|
|
|
|
|
if (!(phba->cfg_oas_flags & OAS_FIND_ANY_VPORT))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
if (wwn_to_u64(phba->cfg_oas_tgt_wwpn) == 0)
|
|
|
|
|
if (!(phba->cfg_oas_flags & OAS_FIND_ANY_TARGET))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
oas_lun = lpfc_oas_lun_get_next(phba, phba->cfg_oas_vpt_wwpn,
|
|
|
|
|
phba->cfg_oas_tgt_wwpn,
|
2016-12-20 07:07:26 +08:00
|
|
|
&phba->cfg_oas_lun_status,
|
|
|
|
|
&phba->cfg_oas_priority);
|
2014-02-20 22:56:45 +08:00
|
|
|
if (oas_lun != NOT_OAS_ENABLED_LUN)
|
|
|
|
|
phba->cfg_oas_flags |= OAS_LUN_VALID;
|
|
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
len += scnprintf(buf + len, PAGE_SIZE-len, "0x%llx", oas_lun);
|
2014-02-20 22:56:45 +08:00
|
|
|
|
|
|
|
|
return len;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* lpfc_oas_lun_store - Sets the OAS state for lun
|
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: buffer for passing information.
|
|
|
|
|
*
|
|
|
|
|
* This function sets the OAS state for lun. Before this function is called,
|
|
|
|
|
* the vport wwpn, target wwpn, and oas state need to be set.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* SUCCESS: size of formatted string.
|
|
|
|
|
* -EFAULT: target or vport wwpn was not set properly.
|
|
|
|
|
* -EPERM: oas is not enabled.
|
|
|
|
|
* size of formatted string.
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_oas_lun_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
const char *buf, size_t count)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
|
|
|
|
|
uint64_t scsi_lun;
|
2016-12-20 07:07:26 +08:00
|
|
|
uint32_t pri;
|
2014-02-20 22:56:45 +08:00
|
|
|
ssize_t rc;
|
|
|
|
|
|
2014-04-05 01:52:21 +08:00
|
|
|
if (!phba->cfg_fof)
|
2014-02-20 22:56:45 +08:00
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
|
|
if (wwn_to_u64(phba->cfg_oas_vpt_wwpn) == 0)
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
if (wwn_to_u64(phba->cfg_oas_tgt_wwpn) == 0)
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
if (!isdigit(buf[0]))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
if (sscanf(buf, "0x%llx", &scsi_lun) != 1)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2016-12-20 07:07:26 +08:00
|
|
|
pri = phba->cfg_oas_priority;
|
2024-06-12 13:13:20 +08:00
|
|
|
if (pri == 0)
|
|
|
|
|
pri = phba->cfg_XLanePriority;
|
|
|
|
|
|
2014-02-20 22:56:45 +08:00
|
|
|
lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
|
2016-07-07 03:36:05 +08:00
|
|
|
"3372 Try to set vport 0x%llx target 0x%llx lun:0x%llx "
|
|
|
|
|
"priority 0x%x with oas state %d\n",
|
2014-02-20 22:56:45 +08:00
|
|
|
wwn_to_u64(phba->cfg_oas_vpt_wwpn),
|
|
|
|
|
wwn_to_u64(phba->cfg_oas_tgt_wwpn), scsi_lun,
|
2016-12-20 07:07:26 +08:00
|
|
|
pri, phba->cfg_oas_lun_state);
|
2014-02-20 22:56:45 +08:00
|
|
|
|
|
|
|
|
rc = lpfc_oas_lun_state_change(phba, phba->cfg_oas_vpt_wwpn,
|
2016-07-07 03:36:05 +08:00
|
|
|
phba->cfg_oas_tgt_wwpn, scsi_lun,
|
2016-12-20 07:07:26 +08:00
|
|
|
phba->cfg_oas_lun_state, pri);
|
2014-02-20 22:56:45 +08:00
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
|
|
return count;
|
|
|
|
|
}
|
|
|
|
|
static DEVICE_ATTR(lpfc_xlane_lun, S_IRUGO | S_IWUSR,
|
|
|
|
|
lpfc_oas_lun_show, lpfc_oas_lun_store);
|
2006-08-19 05:47:18 +08:00
|
|
|
|
2017-02-13 05:52:34 +08:00
|
|
|
int lpfc_enable_nvmet_cnt;
|
|
|
|
|
unsigned long long lpfc_enable_nvmet[LPFC_NVMET_MAX_PORTS] = {
|
|
|
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
|
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
|
|
|
|
|
module_param_array(lpfc_enable_nvmet, ullong, &lpfc_enable_nvmet_cnt, 0444);
|
|
|
|
|
MODULE_PARM_DESC(lpfc_enable_nvmet, "Enable HBA port(s) WWPN as a NVME Target");
|
|
|
|
|
|
[SCSI] lpfc 8.1.1 : Add polled-mode support
- Add functionality to run in polled mode only. Includes run time
attribute to enable mode.
- Enable runtime writable hba settings for coallescing and delay parameters
Customers have requested a mode in the driver to run strictly polled.
This is generally to support an environment where the server is extremely
loaded and is looking to reclaim some cpu cycles from adapter interrupt
handling.
This patch adds a new "poll" attribute, and the following behavior:
if value is 0 (default):
The driver uses the normal method for i/o completion. It uses the
firmware feature of interrupt coalesing. The firmware allows a
minimum number of i/o completions before an interrupt, or a maximum
time delay between interrupts. By default, the driver sets these
to no delay (disabled) or 1 i/o - meaning coalescing is disabled.
Attributes were provided to change the coalescing values, but it was
a module-load time only and global across all adapters.
This patch allows them to be writable on a per-adapter basis.
if value is 1 :
Interrupts are left enabled, expecting that the user has tuned the
interrupt coalescing values. When this setting is enabled, the driver
will attempt to service completed i/o whenever new i/o is submitted
to the adapter. If the coalescing values are large, and the i/o
generation rate steady, an interrupt will be avoided by servicing
completed i/o prior to the coalescing thresholds kicking in. However,
if the i/o completion load is high enough or i/o generation slow, the
coalescion values will ensure that completed i/o is serviced in a timely
fashion.
if value is 3 :
Turns off FCP i/o interrupts altogether. The coalescing values now have
no effect. A new attribute "poll_tmo" (default 10ms) exists to set
the polling interval for i/o completion. When this setting is enabled,
the driver will attempt to service completed i/o and restart the
interval timer whenever new i/o is submitted. This behavior allows for
servicing of completed i/o sooner than the interval timer, but ensures
that if no i/o is being issued, then the interval timer will kick in
to service the outstanding i/o.
Signed-off-by: James Smart <James.Smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-11-30 05:32:13 +08:00
|
|
|
static int lpfc_poll = 0;
|
2011-02-17 01:39:57 +08:00
|
|
|
module_param(lpfc_poll, int, S_IRUGO);
|
[SCSI] lpfc 8.1.1 : Add polled-mode support
- Add functionality to run in polled mode only. Includes run time
attribute to enable mode.
- Enable runtime writable hba settings for coallescing and delay parameters
Customers have requested a mode in the driver to run strictly polled.
This is generally to support an environment where the server is extremely
loaded and is looking to reclaim some cpu cycles from adapter interrupt
handling.
This patch adds a new "poll" attribute, and the following behavior:
if value is 0 (default):
The driver uses the normal method for i/o completion. It uses the
firmware feature of interrupt coalesing. The firmware allows a
minimum number of i/o completions before an interrupt, or a maximum
time delay between interrupts. By default, the driver sets these
to no delay (disabled) or 1 i/o - meaning coalescing is disabled.
Attributes were provided to change the coalescing values, but it was
a module-load time only and global across all adapters.
This patch allows them to be writable on a per-adapter basis.
if value is 1 :
Interrupts are left enabled, expecting that the user has tuned the
interrupt coalescing values. When this setting is enabled, the driver
will attempt to service completed i/o whenever new i/o is submitted
to the adapter. If the coalescing values are large, and the i/o
generation rate steady, an interrupt will be avoided by servicing
completed i/o prior to the coalescing thresholds kicking in. However,
if the i/o completion load is high enough or i/o generation slow, the
coalescion values will ensure that completed i/o is serviced in a timely
fashion.
if value is 3 :
Turns off FCP i/o interrupts altogether. The coalescing values now have
no effect. A new attribute "poll_tmo" (default 10ms) exists to set
the polling interval for i/o completion. When this setting is enabled,
the driver will attempt to service completed i/o and restart the
interval timer whenever new i/o is submitted. This behavior allows for
servicing of completed i/o sooner than the interval timer, but ensures
that if no i/o is being issued, then the interval timer will kick in
to service the outstanding i/o.
Signed-off-by: James Smart <James.Smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-11-30 05:32:13 +08:00
|
|
|
MODULE_PARM_DESC(lpfc_poll, "FCP ring polling mode control:"
|
|
|
|
|
" 0 - none,"
|
|
|
|
|
" 1 - poll with interrupts enabled"
|
|
|
|
|
" 3 - poll and disable FCP ring interrupts");
|
|
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
static DEVICE_ATTR_RW(lpfc_poll);
|
2005-04-18 05:05:31 +08:00
|
|
|
|
scsi: lpfc: Fix eh_deadline setting for sli3 adapters.
A previous change unilaterally removed the hba reset entry point
from the sli3 host template. This was done to allow tape devices
being used for back up from being removed. Why was this done ?
When there was non-responding device on the fabric, the error
escalation policy would escalate to the reset handler. When the
reset handler was called, it would reset the adapter, dropping
link, thus logging out and terminating all i/o's - on any target.
If there was a tape device on the same adapter that wasn't in
error, it would kill the tape i/o's, effectively killing the
tape device state. With the reset point removed, the adapter
reset avoided the fabric logout, allowing the other devices to
continue to operate unaffected. A hack - yes. Hint: we really
need a transport I_T nexus reset callback added to the eh process
(in between the SCSI target reset and hba reset points), so a
fc logout could occur to the one bad target only and stop the error
escalation process.
This patch commonizes the approach so it can be used for sli3 and sli4
adapters, but mandates the admin, via module parameter, specifically
identify which adapters the resets are to be removed for. Additionally,
bus_reset, which sends Target Reset TMFs to all targets, is also removed
from the template as it too has the same effect as the adapter reset.
Signed-off-by: Dick Kennedy <dick.kennedy@broadcom.com>
Signed-off-by: James Smart <james.smart@broadcom.com>
Reviewed-by: Laurence Oberman <loberman@redhat.com>
Tested-by: Laurence Oberman <loberman@redhat.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2017-03-05 01:30:31 +08:00
|
|
|
int lpfc_no_hba_reset_cnt;
|
|
|
|
|
unsigned long lpfc_no_hba_reset[MAX_HBAS_NO_RESET] = {
|
|
|
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
|
|
|
|
|
module_param_array(lpfc_no_hba_reset, ulong, &lpfc_no_hba_reset_cnt, 0444);
|
|
|
|
|
MODULE_PARM_DESC(lpfc_no_hba_reset, "WWPN of HBAs that should not be reset");
|
|
|
|
|
|
2016-07-07 03:36:09 +08:00
|
|
|
LPFC_ATTR(sli_mode, 0, 0, 3,
|
|
|
|
|
"SLI mode selector:"
|
|
|
|
|
" 0 - auto (SLI-3 if supported),"
|
|
|
|
|
" 2 - select SLI-2 even on SLI-3 capable HBAs,"
|
|
|
|
|
" 3 - select SLI-3");
|
2007-06-18 08:56:38 +08:00
|
|
|
|
2016-07-07 03:36:07 +08:00
|
|
|
LPFC_ATTR_R(enable_npiv, 1, 0, 1,
|
|
|
|
|
"Enable NPIV functionality");
|
2007-06-18 08:56:38 +08:00
|
|
|
|
2011-07-23 06:37:52 +08:00
|
|
|
LPFC_ATTR_R(fcf_failover_policy, 1, 1, 2,
|
|
|
|
|
"FCF Fast failover=1 Priority failover=2");
|
|
|
|
|
|
2013-03-02 05:37:14 +08:00
|
|
|
/*
|
|
|
|
|
# lpfc_enable_rrq: Track XRI/OXID reuse after IO failures
|
|
|
|
|
# 0x0 = disabled, XRI/OXID use not tracked.
|
|
|
|
|
# 0x1 = XRI/OXID reuse is timed with ratov, RRQ sent.
|
|
|
|
|
# 0x2 = XRI/OXID reuse is timed with ratov, No RRQ sent.
|
|
|
|
|
*/
|
2016-10-14 06:06:08 +08:00
|
|
|
LPFC_ATTR_R(enable_rrq, 2, 0, 2,
|
|
|
|
|
"Enable RRQ functionality");
|
2010-11-21 12:11:55 +08:00
|
|
|
|
2010-02-13 03:42:33 +08:00
|
|
|
/*
|
|
|
|
|
# lpfc_suppress_link_up: Bring link up at initialization
|
|
|
|
|
# 0x0 = bring link up (issue MBX_INIT_LINK)
|
|
|
|
|
# 0x1 = do NOT bring link up at initialization(MBX_INIT_LINK)
|
|
|
|
|
# 0x2 = never bring up link
|
|
|
|
|
# Default value is 0.
|
|
|
|
|
*/
|
2010-02-27 03:13:54 +08:00
|
|
|
LPFC_ATTR_R(suppress_link_up, LPFC_INITIALIZE_LINK, LPFC_INITIALIZE_LINK,
|
|
|
|
|
LPFC_DELAY_INIT_LINK_INDEFINITELY,
|
|
|
|
|
"Suppress Link Up at initialization");
|
2010-06-08 03:24:45 +08:00
|
|
|
/*
|
|
|
|
|
# lpfc_cnt: Number of IOCBs allocated for ELS, CT, and ABTS
|
|
|
|
|
# 1 - (1024)
|
|
|
|
|
# 2 - (2048)
|
|
|
|
|
# 3 - (3072)
|
|
|
|
|
# 4 - (4096)
|
|
|
|
|
# 5 - (5120)
|
|
|
|
|
*/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_iocb_hw_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_hba *phba = ((struct lpfc_vport *) shost->hostdata)->phba;
|
|
|
|
|
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", phba->iocb_max);
|
2010-06-08 03:24:45 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static DEVICE_ATTR(iocb_hw, S_IRUGO,
|
|
|
|
|
lpfc_iocb_hw_show, NULL);
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_txq_hw_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_hba *phba = ((struct lpfc_vport *) shost->hostdata)->phba;
|
2017-02-13 05:52:30 +08:00
|
|
|
struct lpfc_sli_ring *pring = lpfc_phba_elsring(phba);
|
2010-06-08 03:24:45 +08:00
|
|
|
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n",
|
2017-09-30 08:34:29 +08:00
|
|
|
pring ? pring->txq_max : 0);
|
2010-06-08 03:24:45 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static DEVICE_ATTR(txq_hw, S_IRUGO,
|
|
|
|
|
lpfc_txq_hw_show, NULL);
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_txcmplq_hw_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_hba *phba = ((struct lpfc_vport *) shost->hostdata)->phba;
|
2017-02-13 05:52:30 +08:00
|
|
|
struct lpfc_sli_ring *pring = lpfc_phba_elsring(phba);
|
2010-06-08 03:24:45 +08:00
|
|
|
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n",
|
2017-09-30 08:34:29 +08:00
|
|
|
pring ? pring->txcmplq_max : 0);
|
2010-06-08 03:24:45 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static DEVICE_ATTR(txcmplq_hw, S_IRUGO,
|
|
|
|
|
lpfc_txcmplq_hw_show, NULL);
|
|
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
LPFC_ATTR_R(iocb_cnt, 2, 1, 5,
|
|
|
|
|
"Number of IOCBs alloc for ELS, CT, and ABTS: 1k to 5k IOCBs");
|
|
|
|
|
|
2006-08-19 05:47:08 +08:00
|
|
|
/*
|
|
|
|
|
# lpfc_nodev_tmo: If set, it will hold all I/O errors on devices that disappear
|
|
|
|
|
# until the timer expires. Value range is [0,255]. Default value is 30.
|
|
|
|
|
*/
|
|
|
|
|
static int lpfc_nodev_tmo = LPFC_DEF_DEVLOSS_TMO;
|
|
|
|
|
static int lpfc_devloss_tmo = LPFC_DEF_DEVLOSS_TMO;
|
|
|
|
|
module_param(lpfc_nodev_tmo, int, 0);
|
|
|
|
|
MODULE_PARM_DESC(lpfc_nodev_tmo,
|
|
|
|
|
"Seconds driver will hold I/O waiting "
|
|
|
|
|
"for a device to come back");
|
2008-08-25 09:49:00 +08:00
|
|
|
|
|
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_nodev_tmo_show - Return the hba dev loss timeout value
|
2008-08-25 09:49:00 +08:00
|
|
|
* @dev: class converted to a Scsi_host structure.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: on return contains the dev loss timeout in decimal.
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
2006-08-19 05:47:08 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_nodev_tmo_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
2006-08-19 05:47:08 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
2010-02-27 03:13:54 +08:00
|
|
|
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", vport->cfg_devloss_tmo);
|
2006-08-19 05:47:08 +08:00
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_nodev_tmo_init - Set the hba nodev timeout value
|
2008-08-25 09:49:00 +08:00
|
|
|
* @vport: lpfc vport structure pointer.
|
|
|
|
|
* @val: contains the nodev timeout value.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* If the devloss tmo is already set then nodev tmo is set to devloss tmo,
|
|
|
|
|
* a kernel error message is printed and zero is returned.
|
|
|
|
|
* Else if val is in range then nodev tmo and devloss tmo are set to val.
|
|
|
|
|
* Otherwise nodev tmo is set to the default value.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* zero if already set or if val is in range
|
|
|
|
|
* -EINVAL val out of range
|
|
|
|
|
**/
|
2006-08-19 05:47:08 +08:00
|
|
|
static int
|
2007-08-02 23:09:59 +08:00
|
|
|
lpfc_nodev_tmo_init(struct lpfc_vport *vport, int val)
|
|
|
|
|
{
|
|
|
|
|
if (vport->cfg_devloss_tmo != LPFC_DEF_DEVLOSS_TMO) {
|
|
|
|
|
vport->cfg_nodev_tmo = vport->cfg_devloss_tmo;
|
|
|
|
|
if (val != LPFC_DEF_DEVLOSS_TMO)
|
2007-08-02 23:10:09 +08:00
|
|
|
lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
|
2024-06-12 13:13:20 +08:00
|
|
|
"0407 Ignoring lpfc_nodev_tmo module "
|
|
|
|
|
"parameter because lpfc_devloss_tmo "
|
|
|
|
|
"is set.\n");
|
2006-08-19 05:47:08 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
|
2007-08-02 23:09:59 +08:00
|
|
|
vport->cfg_nodev_tmo = val;
|
|
|
|
|
vport->cfg_devloss_tmo = val;
|
2006-08-19 05:47:08 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
2007-08-02 23:10:09 +08:00
|
|
|
lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
|
2024-06-12 13:13:20 +08:00
|
|
|
"0400 lpfc_nodev_tmo attribute cannot be set to"
|
|
|
|
|
" %d, allowed range is [%d, %d]\n",
|
2007-08-02 23:10:09 +08:00
|
|
|
val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO);
|
2007-08-02 23:09:59 +08:00
|
|
|
vport->cfg_nodev_tmo = LPFC_DEF_DEVLOSS_TMO;
|
2006-08-19 05:47:08 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_update_rport_devloss_tmo - Update dev loss tmo value
|
2008-08-25 09:49:00 +08:00
|
|
|
* @vport: lpfc vport structure pointer.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* Update all the ndlp's dev loss tmo with the vport devloss tmo value.
|
|
|
|
|
**/
|
2007-04-25 21:52:34 +08:00
|
|
|
static void
|
2007-08-02 23:09:59 +08:00
|
|
|
lpfc_update_rport_devloss_tmo(struct lpfc_vport *vport)
|
2007-04-25 21:52:34 +08:00
|
|
|
{
|
2007-06-18 08:56:39 +08:00
|
|
|
struct Scsi_Host *shost;
|
2007-04-25 21:52:34 +08:00
|
|
|
struct lpfc_nodelist *ndlp;
|
2024-06-12 13:13:20 +08:00
|
|
|
#if (IS_ENABLED(CONFIG_NVME_FC))
|
2018-04-10 05:24:27 +08:00
|
|
|
struct lpfc_nvme_rport *rport;
|
2018-09-14 06:41:10 +08:00
|
|
|
struct nvme_fc_remote_port *remoteport = NULL;
|
2018-04-10 05:24:27 +08:00
|
|
|
#endif
|
2007-04-25 21:52:34 +08:00
|
|
|
|
2007-08-02 23:10:31 +08:00
|
|
|
shost = lpfc_shost_from_vport(vport);
|
|
|
|
|
spin_lock_irq(shost->host_lock);
|
2017-06-02 12:06:55 +08:00
|
|
|
list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
|
|
|
|
|
if (!NLP_CHK_NODE_ACT(ndlp))
|
|
|
|
|
continue;
|
|
|
|
|
if (ndlp->rport)
|
2007-08-02 23:10:31 +08:00
|
|
|
ndlp->rport->dev_loss_tmo = vport->cfg_devloss_tmo;
|
2024-06-12 13:13:20 +08:00
|
|
|
#if (IS_ENABLED(CONFIG_NVME_FC))
|
2018-09-14 06:41:10 +08:00
|
|
|
spin_lock(&vport->phba->hbalock);
|
2018-04-10 05:24:27 +08:00
|
|
|
rport = lpfc_ndlp_get_nrport(ndlp);
|
|
|
|
|
if (rport)
|
2018-09-14 06:41:10 +08:00
|
|
|
remoteport = rport->remoteport;
|
|
|
|
|
spin_unlock(&vport->phba->hbalock);
|
2019-08-15 07:56:45 +08:00
|
|
|
if (rport && remoteport)
|
|
|
|
|
nvme_fc_set_remoteport_devloss(remoteport,
|
2017-11-04 00:33:30 +08:00
|
|
|
vport->cfg_devloss_tmo);
|
|
|
|
|
#endif
|
2017-06-02 12:06:55 +08:00
|
|
|
}
|
2007-08-02 23:10:31 +08:00
|
|
|
spin_unlock_irq(shost->host_lock);
|
2007-04-25 21:52:34 +08:00
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_nodev_tmo_set - Set the vport nodev tmo and devloss tmo values
|
2008-08-25 09:49:00 +08:00
|
|
|
* @vport: lpfc vport structure pointer.
|
|
|
|
|
* @val: contains the tmo value.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* If the devloss tmo is already set or the vport dev loss tmo has changed
|
|
|
|
|
* then a kernel error message is printed and zero is returned.
|
|
|
|
|
* Else if val is in range then nodev tmo and devloss tmo are set to val.
|
|
|
|
|
* Otherwise nodev tmo is set to the default value.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* zero if already set or if val is in range
|
|
|
|
|
* -EINVAL val out of range
|
|
|
|
|
**/
|
2006-08-19 05:47:08 +08:00
|
|
|
static int
|
2007-08-02 23:09:59 +08:00
|
|
|
lpfc_nodev_tmo_set(struct lpfc_vport *vport, int val)
|
2006-08-19 05:47:08 +08:00
|
|
|
{
|
2007-08-02 23:09:59 +08:00
|
|
|
if (vport->dev_loss_tmo_changed ||
|
|
|
|
|
(lpfc_devloss_tmo != LPFC_DEF_DEVLOSS_TMO)) {
|
2007-08-02 23:10:09 +08:00
|
|
|
lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
|
2024-06-12 13:13:20 +08:00
|
|
|
"0401 Ignoring change to lpfc_nodev_tmo "
|
|
|
|
|
"because lpfc_devloss_tmo is set.\n");
|
2006-08-19 05:47:08 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
|
2007-08-02 23:09:59 +08:00
|
|
|
vport->cfg_nodev_tmo = val;
|
|
|
|
|
vport->cfg_devloss_tmo = val;
|
2024-06-12 13:13:20 +08:00
|
|
|
/*
|
|
|
|
|
* For compat: set the fc_host dev loss so new rports
|
|
|
|
|
* will get the value.
|
|
|
|
|
*/
|
|
|
|
|
fc_host_dev_loss_tmo(lpfc_shost_from_vport(vport)) = val;
|
2007-08-02 23:09:59 +08:00
|
|
|
lpfc_update_rport_devloss_tmo(vport);
|
2006-08-19 05:47:08 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
2007-08-02 23:10:09 +08:00
|
|
|
lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
|
2024-06-12 13:13:20 +08:00
|
|
|
"0403 lpfc_nodev_tmo attribute cannot be set to "
|
|
|
|
|
"%d, allowed range is [%d, %d]\n",
|
2007-08-02 23:10:09 +08:00
|
|
|
val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO);
|
2006-08-19 05:47:08 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
2007-08-02 23:09:59 +08:00
|
|
|
lpfc_vport_param_store(nodev_tmo)
|
2006-08-19 05:47:08 +08:00
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
static DEVICE_ATTR_RW(lpfc_nodev_tmo);
|
2006-08-19 05:47:08 +08:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
# lpfc_devloss_tmo: If set, it will hold all I/O errors on devices that
|
|
|
|
|
# disappear until the timer expires. Value range is [0,255]. Default
|
|
|
|
|
# value is 30.
|
|
|
|
|
*/
|
2011-02-17 01:39:57 +08:00
|
|
|
module_param(lpfc_devloss_tmo, int, S_IRUGO);
|
2006-08-19 05:47:08 +08:00
|
|
|
MODULE_PARM_DESC(lpfc_devloss_tmo,
|
|
|
|
|
"Seconds driver will hold I/O waiting "
|
|
|
|
|
"for a device to come back");
|
2007-08-02 23:09:59 +08:00
|
|
|
lpfc_vport_param_init(devloss_tmo, LPFC_DEF_DEVLOSS_TMO,
|
|
|
|
|
LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO)
|
|
|
|
|
lpfc_vport_param_show(devloss_tmo)
|
2008-08-25 09:49:00 +08:00
|
|
|
|
|
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_devloss_tmo_set - Sets vport nodev tmo, devloss tmo values, changed bit
|
2008-08-25 09:49:00 +08:00
|
|
|
* @vport: lpfc vport structure pointer.
|
|
|
|
|
* @val: contains the tmo value.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* If val is in a valid range then set the vport nodev tmo,
|
|
|
|
|
* devloss tmo, also set the vport dev loss tmo changed flag.
|
|
|
|
|
* Else a kernel error message is printed.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* zero if val is in range
|
|
|
|
|
* -EINVAL val out of range
|
|
|
|
|
**/
|
2006-08-19 05:47:08 +08:00
|
|
|
static int
|
2007-08-02 23:09:59 +08:00
|
|
|
lpfc_devloss_tmo_set(struct lpfc_vport *vport, int val)
|
2006-08-19 05:47:08 +08:00
|
|
|
{
|
|
|
|
|
if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
|
2007-08-02 23:09:59 +08:00
|
|
|
vport->cfg_nodev_tmo = val;
|
|
|
|
|
vport->cfg_devloss_tmo = val;
|
|
|
|
|
vport->dev_loss_tmo_changed = 1;
|
2024-06-12 13:13:20 +08:00
|
|
|
fc_host_dev_loss_tmo(lpfc_shost_from_vport(vport)) = val;
|
2007-08-02 23:09:59 +08:00
|
|
|
lpfc_update_rport_devloss_tmo(vport);
|
2006-08-19 05:47:08 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2007-08-02 23:10:09 +08:00
|
|
|
lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
|
2024-06-12 13:13:20 +08:00
|
|
|
"0404 lpfc_devloss_tmo attribute cannot be set to "
|
|
|
|
|
"%d, allowed range is [%d, %d]\n",
|
2007-08-02 23:10:09 +08:00
|
|
|
val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO);
|
2006-08-19 05:47:08 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
2007-08-02 23:09:59 +08:00
|
|
|
lpfc_vport_param_store(devloss_tmo)
|
2024-06-12 13:13:20 +08:00
|
|
|
static DEVICE_ATTR_RW(lpfc_devloss_tmo);
|
2006-08-19 05:47:08 +08:00
|
|
|
|
2017-02-13 05:52:34 +08:00
|
|
|
/*
|
|
|
|
|
* lpfc_suppress_rsp: Enable suppress rsp feature is firmware supports it
|
|
|
|
|
* lpfc_suppress_rsp = 0 Disable
|
|
|
|
|
* lpfc_suppress_rsp = 1 Enable (default)
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
LPFC_ATTR_R(suppress_rsp, 1, 0, 1,
|
|
|
|
|
"Enable suppress rsp feature is firmware supports it");
|
|
|
|
|
|
2017-02-13 05:52:35 +08:00
|
|
|
/*
|
|
|
|
|
* lpfc_nvmet_mrq: Specify number of RQ pairs for processing NVMET cmds
|
2017-11-21 08:00:36 +08:00
|
|
|
* lpfc_nvmet_mrq = 0 driver will calcualte optimal number of RQ pairs
|
2017-02-13 05:52:35 +08:00
|
|
|
* lpfc_nvmet_mrq = 1 use a single RQ pair
|
|
|
|
|
* lpfc_nvmet_mrq >= 2 use specified RQ pairs for MRQ
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
LPFC_ATTR_R(nvmet_mrq,
|
2017-11-21 08:00:36 +08:00
|
|
|
LPFC_NVMET_MRQ_AUTO, LPFC_NVMET_MRQ_AUTO, LPFC_NVMET_MRQ_MAX,
|
2017-02-13 05:52:35 +08:00
|
|
|
"Specify number of RQ pairs for processing NVMET cmds");
|
|
|
|
|
|
2018-04-10 05:24:24 +08:00
|
|
|
/*
|
|
|
|
|
* lpfc_nvmet_mrq_post: Specify number of RQ buffer to initially post
|
|
|
|
|
* to each NVMET RQ. Range 64 to 2048, default is 512.
|
|
|
|
|
*/
|
|
|
|
|
LPFC_ATTR_R(nvmet_mrq_post,
|
|
|
|
|
LPFC_NVMET_RQE_DEF_POST, LPFC_NVMET_RQE_MIN_POST,
|
|
|
|
|
LPFC_NVMET_RQE_DEF_COUNT,
|
|
|
|
|
"Specify number of RQ buffers to initially post");
|
|
|
|
|
|
2017-02-13 05:52:30 +08:00
|
|
|
/*
|
|
|
|
|
* lpfc_enable_fc4_type: Defines what FC4 types are supported.
|
|
|
|
|
* Supported Values: 1 - register just FCP
|
|
|
|
|
* 3 - register both FCP and NVME
|
2019-01-29 03:14:36 +08:00
|
|
|
* Supported values are [1,3]. Default value is 3
|
2017-02-13 05:52:30 +08:00
|
|
|
*/
|
2024-06-12 13:13:20 +08:00
|
|
|
LPFC_ATTR_R(enable_fc4_type, LPFC_DEF_ENBL_FC4_TYPE,
|
|
|
|
|
LPFC_ENABLE_FCP, LPFC_MAX_ENBL_FC4_TYPE,
|
2017-09-30 08:34:38 +08:00
|
|
|
"Enable FC4 Protocol support - FCP / NVME");
|
2017-02-13 05:52:30 +08:00
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
/*
|
|
|
|
|
# lpfc_log_verbose: Only turn this flag on if you are willing to risk being
|
|
|
|
|
# deluged with LOTS of information.
|
|
|
|
|
# You can set a bit mask to record specific types of verbose messages:
|
2009-05-23 02:53:12 +08:00
|
|
|
# See lpfc_logmsh.h for definitions.
|
2005-04-18 05:05:31 +08:00
|
|
|
*/
|
2009-05-23 02:53:12 +08:00
|
|
|
LPFC_VPORT_ATTR_HEX_RW(log_verbose, 0x0, 0x0, 0xffffffff,
|
2007-08-02 23:10:09 +08:00
|
|
|
"Verbose logging bit-mask");
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2007-10-28 01:37:17 +08:00
|
|
|
/*
|
|
|
|
|
# lpfc_enable_da_id: This turns on the DA_ID CT command that deregisters
|
|
|
|
|
# objects that have been registered with the nameserver after login.
|
|
|
|
|
*/
|
2012-03-02 11:37:32 +08:00
|
|
|
LPFC_VPORT_ATTR_R(enable_da_id, 1, 0, 1,
|
2007-10-28 01:37:17 +08:00
|
|
|
"Deregister nameserver objects before LOGO");
|
|
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
/*
|
|
|
|
|
# lun_queue_depth: This parameter is used to limit the number of outstanding
|
2013-07-16 06:32:43 +08:00
|
|
|
# commands per FCP LUN. Value range is [1,512]. Default value is 30.
|
2024-06-12 13:13:20 +08:00
|
|
|
# If this parameter value is greater than 1/8th the maximum number of exchanges
|
|
|
|
|
# supported by the HBA port, then the lun queue depth will be reduced to
|
|
|
|
|
# 1/8th the maximum number of exchanges.
|
2005-04-18 05:05:31 +08:00
|
|
|
*/
|
2024-06-12 13:13:20 +08:00
|
|
|
LPFC_VPORT_ATTR_R(lun_queue_depth, 30, 1, 512,
|
|
|
|
|
"Max number of FCP commands we can queue to a specific LUN");
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2010-07-15 03:32:10 +08:00
|
|
|
/*
|
|
|
|
|
# tgt_queue_depth: This parameter is used to limit the number of outstanding
|
|
|
|
|
# commands per target port. Value range is [10,65535]. Default value is 65535.
|
|
|
|
|
*/
|
2018-04-10 05:24:22 +08:00
|
|
|
static uint lpfc_tgt_queue_depth = LPFC_MAX_TGT_QDEPTH;
|
2024-06-12 13:13:20 +08:00
|
|
|
module_param(lpfc_tgt_queue_depth, uint, 0444);
|
2018-04-10 05:24:22 +08:00
|
|
|
MODULE_PARM_DESC(lpfc_tgt_queue_depth, "Set max Target queue depth");
|
|
|
|
|
lpfc_vport_param_show(tgt_queue_depth);
|
|
|
|
|
lpfc_vport_param_init(tgt_queue_depth, LPFC_MAX_TGT_QDEPTH,
|
|
|
|
|
LPFC_MIN_TGT_QDEPTH, LPFC_MAX_TGT_QDEPTH);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* lpfc_tgt_queue_depth_store: Sets an attribute value.
|
|
|
|
|
* @phba: pointer the the adapter structure.
|
|
|
|
|
* @val: integer attribute value.
|
|
|
|
|
*
|
|
|
|
|
* Description: Sets the parameter to the new value.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* zero on success
|
|
|
|
|
* -EINVAL if val is invalid
|
|
|
|
|
*/
|
|
|
|
|
static int
|
|
|
|
|
lpfc_tgt_queue_depth_set(struct lpfc_vport *vport, uint val)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
|
|
|
|
|
struct lpfc_nodelist *ndlp;
|
|
|
|
|
|
|
|
|
|
if (!lpfc_rangecheck(val, LPFC_MIN_TGT_QDEPTH, LPFC_MAX_TGT_QDEPTH))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
if (val == vport->cfg_tgt_queue_depth)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
spin_lock_irq(shost->host_lock);
|
|
|
|
|
vport->cfg_tgt_queue_depth = val;
|
|
|
|
|
|
|
|
|
|
/* Next loop thru nodelist and change cmd_qdepth */
|
|
|
|
|
list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp)
|
|
|
|
|
ndlp->cmd_qdepth = vport->cfg_tgt_queue_depth;
|
|
|
|
|
|
|
|
|
|
spin_unlock_irq(shost->host_lock);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
lpfc_vport_param_store(tgt_queue_depth);
|
|
|
|
|
static DEVICE_ATTR_RW(lpfc_tgt_queue_depth);
|
2010-07-15 03:32:10 +08:00
|
|
|
|
2006-03-01 08:25:21 +08:00
|
|
|
/*
|
|
|
|
|
# hba_queue_depth: This parameter is used to limit the number of outstanding
|
|
|
|
|
# commands per lpfc HBA. Value range is [32,8192]. If this parameter
|
|
|
|
|
# value is greater than the maximum number of exchanges supported by the HBA,
|
|
|
|
|
# then maximum number of exchanges supported by the HBA is used to determine
|
|
|
|
|
# the hba_queue_depth.
|
|
|
|
|
*/
|
|
|
|
|
LPFC_ATTR_R(hba_queue_depth, 8192, 32, 8192,
|
|
|
|
|
"Max number of FCP commands we can queue to a lpfc HBA");
|
|
|
|
|
|
2007-06-18 08:56:38 +08:00
|
|
|
/*
|
|
|
|
|
# peer_port_login: This parameter allows/prevents logins
|
|
|
|
|
# between peer ports hosted on the same physical port.
|
|
|
|
|
# When this parameter is set 0 peer ports of same physical port
|
|
|
|
|
# are not allowed to login to each other.
|
|
|
|
|
# When this parameter is set 1 peer ports of same physical port
|
|
|
|
|
# are allowed to login to each other.
|
|
|
|
|
# Default value of this parameter is 0.
|
|
|
|
|
*/
|
2007-08-02 23:09:59 +08:00
|
|
|
LPFC_VPORT_ATTR_R(peer_port_login, 0, 0, 1,
|
|
|
|
|
"Allow peer ports on the same physical port to login to each "
|
|
|
|
|
"other.");
|
2007-06-18 08:56:38 +08:00
|
|
|
|
|
|
|
|
/*
|
2007-08-02 23:09:59 +08:00
|
|
|
# restrict_login: This parameter allows/prevents logins
|
2007-06-18 08:56:38 +08:00
|
|
|
# between Virtual Ports and remote initiators.
|
|
|
|
|
# When this parameter is not set (0) Virtual Ports will accept PLOGIs from
|
|
|
|
|
# other initiators and will attempt to PLOGI all remote ports.
|
|
|
|
|
# When this parameter is set (1) Virtual Ports will reject PLOGIs from
|
|
|
|
|
# remote ports and will not attempt to PLOGI to other initiators.
|
|
|
|
|
# This parameter does not restrict to the physical port.
|
|
|
|
|
# This parameter does not restrict logins to Fabric resident remote ports.
|
|
|
|
|
# Default value of this parameter is 1.
|
|
|
|
|
*/
|
2007-08-02 23:09:59 +08:00
|
|
|
static int lpfc_restrict_login = 1;
|
2011-02-17 01:39:57 +08:00
|
|
|
module_param(lpfc_restrict_login, int, S_IRUGO);
|
2007-08-02 23:09:59 +08:00
|
|
|
MODULE_PARM_DESC(lpfc_restrict_login,
|
|
|
|
|
"Restrict virtual ports login to remote initiators.");
|
|
|
|
|
lpfc_vport_param_show(restrict_login);
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_restrict_login_init - Set the vport restrict login flag
|
2008-08-25 09:49:00 +08:00
|
|
|
* @vport: lpfc vport structure pointer.
|
|
|
|
|
* @val: contains the restrict login value.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* If val is not in a valid range then log a kernel error message and set
|
|
|
|
|
* the vport restrict login to one.
|
|
|
|
|
* If the port type is physical clear the restrict login flag and return.
|
|
|
|
|
* Else set the restrict login flag to val.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* zero if val is in range
|
|
|
|
|
* -EINVAL val out of range
|
|
|
|
|
**/
|
2007-08-02 23:09:59 +08:00
|
|
|
static int
|
|
|
|
|
lpfc_restrict_login_init(struct lpfc_vport *vport, int val)
|
|
|
|
|
{
|
|
|
|
|
if (val < 0 || val > 1) {
|
2007-08-02 23:10:09 +08:00
|
|
|
lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
|
2024-06-12 13:13:20 +08:00
|
|
|
"0422 lpfc_restrict_login attribute cannot "
|
|
|
|
|
"be set to %d, allowed range is [0, 1]\n",
|
|
|
|
|
val);
|
2007-08-02 23:09:59 +08:00
|
|
|
vport->cfg_restrict_login = 1;
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
if (vport->port_type == LPFC_PHYSICAL_PORT) {
|
|
|
|
|
vport->cfg_restrict_login = 0;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
vport->cfg_restrict_login = val;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_restrict_login_set - Set the vport restrict login flag
|
2008-08-25 09:49:00 +08:00
|
|
|
* @vport: lpfc vport structure pointer.
|
|
|
|
|
* @val: contains the restrict login value.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* If val is not in a valid range then log a kernel error message and set
|
|
|
|
|
* the vport restrict login to one.
|
|
|
|
|
* If the port type is physical and the val is not zero log a kernel
|
|
|
|
|
* error message, clear the restrict login flag and return zero.
|
|
|
|
|
* Else set the restrict login flag to val.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* zero if val is in range
|
|
|
|
|
* -EINVAL val out of range
|
|
|
|
|
**/
|
2007-08-02 23:09:59 +08:00
|
|
|
static int
|
|
|
|
|
lpfc_restrict_login_set(struct lpfc_vport *vport, int val)
|
|
|
|
|
{
|
|
|
|
|
if (val < 0 || val > 1) {
|
2007-08-02 23:10:09 +08:00
|
|
|
lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
|
2024-06-12 13:13:20 +08:00
|
|
|
"0425 lpfc_restrict_login attribute cannot "
|
|
|
|
|
"be set to %d, allowed range is [0, 1]\n",
|
|
|
|
|
val);
|
2007-08-02 23:09:59 +08:00
|
|
|
vport->cfg_restrict_login = 1;
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
if (vport->port_type == LPFC_PHYSICAL_PORT && val != 0) {
|
2007-08-02 23:10:09 +08:00
|
|
|
lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
|
2024-06-12 13:13:20 +08:00
|
|
|
"0468 lpfc_restrict_login must be 0 for "
|
|
|
|
|
"Physical ports.\n");
|
2007-08-02 23:09:59 +08:00
|
|
|
vport->cfg_restrict_login = 0;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
vport->cfg_restrict_login = val;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
lpfc_vport_param_store(restrict_login);
|
2024-06-12 13:13:20 +08:00
|
|
|
static DEVICE_ATTR_RW(lpfc_restrict_login);
|
2007-06-18 08:56:38 +08:00
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
/*
|
|
|
|
|
# Some disk devices have a "select ID" or "select Target" capability.
|
|
|
|
|
# From a protocol standpoint "select ID" usually means select the
|
|
|
|
|
# Fibre channel "ALPA". In the FC-AL Profile there is an "informative
|
|
|
|
|
# annex" which contains a table that maps a "select ID" (a number
|
|
|
|
|
# between 0 and 7F) to an ALPA. By default, for compatibility with
|
|
|
|
|
# older drivers, the lpfc driver scans this table from low ALPA to high
|
|
|
|
|
# ALPA.
|
|
|
|
|
#
|
|
|
|
|
# Turning on the scan-down variable (on = 1, off = 0) will
|
|
|
|
|
# cause the lpfc driver to use an inverted table, effectively
|
|
|
|
|
# scanning ALPAs from high to low. Value range is [0,1]. Default value is 1.
|
|
|
|
|
#
|
|
|
|
|
# (Note: This "select ID" functionality is a LOOP ONLY characteristic
|
|
|
|
|
# and will not work across a fabric. Also this parameter will take
|
|
|
|
|
# effect only in the case when ALPA map is not available.)
|
|
|
|
|
*/
|
2007-08-02 23:09:59 +08:00
|
|
|
LPFC_VPORT_ATTR_R(scan_down, 1, 0, 1,
|
|
|
|
|
"Start scanning for devices from highest ALPA to lowest");
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
# lpfc_topology: link topology for init link
|
|
|
|
|
# 0x0 = attempt loop mode then point-to-point
|
2006-03-01 08:25:32 +08:00
|
|
|
# 0x01 = internal loopback mode
|
2005-04-18 05:05:31 +08:00
|
|
|
# 0x02 = attempt point-to-point mode only
|
|
|
|
|
# 0x04 = attempt loop mode only
|
|
|
|
|
# 0x06 = attempt point-to-point mode then loop
|
|
|
|
|
# Set point-to-point mode if you want to run as an N_Port.
|
|
|
|
|
# Set loop mode if you want to run as an NL_Port. Value range is [0,0x6].
|
|
|
|
|
# Default value is 0.
|
|
|
|
|
*/
|
2016-10-14 06:06:10 +08:00
|
|
|
LPFC_ATTR(topology, 0, 0, 6,
|
|
|
|
|
"Select Fibre Channel topology");
|
2008-08-25 09:49:00 +08:00
|
|
|
|
|
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_topology_set - Set the adapters topology field
|
2008-08-25 09:49:00 +08:00
|
|
|
* @phba: lpfc_hba pointer.
|
|
|
|
|
* @val: topology value.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* If val is in a valid range then set the adapter's topology field and
|
|
|
|
|
* issue a lip; if the lip fails reset the topology to the old value.
|
|
|
|
|
*
|
|
|
|
|
* If the value is not in range log a kernel error message and return an error.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* zero if val is in range and lip okay
|
|
|
|
|
* non-zero return value from lpfc_issue_lip()
|
|
|
|
|
* -EINVAL val out of range
|
|
|
|
|
**/
|
2009-04-07 06:48:10 +08:00
|
|
|
static ssize_t
|
|
|
|
|
lpfc_topology_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
const char *buf, size_t count)
|
2008-01-11 14:53:09 +08:00
|
|
|
{
|
2009-04-07 06:48:10 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
int val = 0;
|
|
|
|
|
int nolip = 0;
|
|
|
|
|
const char *val_buf = buf;
|
2008-01-11 14:53:09 +08:00
|
|
|
int err;
|
|
|
|
|
uint32_t prev_val;
|
2009-04-07 06:48:10 +08:00
|
|
|
|
|
|
|
|
if (!strncmp(buf, "nolip ", strlen("nolip "))) {
|
|
|
|
|
nolip = 1;
|
|
|
|
|
val_buf = &buf[strlen("nolip ")];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!isdigit(val_buf[0]))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
if (sscanf(val_buf, "%i", &val) != 1)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2008-01-11 14:53:09 +08:00
|
|
|
if (val >= 0 && val <= 6) {
|
|
|
|
|
prev_val = phba->cfg_topology;
|
2011-12-14 02:21:35 +08:00
|
|
|
if (phba->cfg_link_speed == LPFC_USER_LINK_SPEED_16G &&
|
|
|
|
|
val == 4) {
|
|
|
|
|
lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
|
|
|
|
|
"3113 Loop mode not supported at speed %d\n",
|
2015-09-01 04:48:17 +08:00
|
|
|
val);
|
2011-12-14 02:21:35 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
2024-06-12 13:13:20 +08:00
|
|
|
if ((phba->pcidev->device == PCI_DEVICE_ID_LANCER_G6_FC ||
|
|
|
|
|
phba->pcidev->device == PCI_DEVICE_ID_LANCER_G7_FC) &&
|
2019-05-22 08:48:57 +08:00
|
|
|
val == 4) {
|
2015-09-01 04:48:17 +08:00
|
|
|
lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
|
2019-05-22 08:48:57 +08:00
|
|
|
"3114 Loop mode not supported\n");
|
2015-09-01 04:48:17 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
phba->cfg_topology = val;
|
2009-04-07 06:48:10 +08:00
|
|
|
if (nolip)
|
|
|
|
|
return strlen(buf);
|
|
|
|
|
|
2011-07-23 06:36:33 +08:00
|
|
|
lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
|
|
|
|
|
"3054 lpfc_topology changed from %d to %d\n",
|
|
|
|
|
prev_val, val);
|
2013-04-18 08:15:19 +08:00
|
|
|
if (prev_val != val && phba->sli_rev == LPFC_SLI_REV4)
|
|
|
|
|
phba->fc_topology_changed = 1;
|
2008-01-11 14:53:09 +08:00
|
|
|
err = lpfc_issue_lip(lpfc_shost_from_vport(phba->pport));
|
2009-04-07 06:48:10 +08:00
|
|
|
if (err) {
|
2008-01-11 14:53:09 +08:00
|
|
|
phba->cfg_topology = prev_val;
|
2009-04-07 06:48:10 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
} else
|
|
|
|
|
return strlen(buf);
|
2008-01-11 14:53:09 +08:00
|
|
|
}
|
|
|
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
|
|
|
|
|
"%d:0467 lpfc_topology attribute cannot be set to %d, "
|
|
|
|
|
"allowed range is [0, 6]\n",
|
|
|
|
|
phba->brd_no, val);
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
2016-10-14 06:06:10 +08:00
|
|
|
|
2008-01-11 14:53:09 +08:00
|
|
|
lpfc_param_show(topology)
|
2024-06-12 13:13:20 +08:00
|
|
|
static DEVICE_ATTR_RW(lpfc_topology);
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2009-05-23 02:53:21 +08:00
|
|
|
/**
|
|
|
|
|
* lpfc_static_vport_show: Read callback function for
|
|
|
|
|
* lpfc_static_vport sysfs file.
|
|
|
|
|
* @dev: Pointer to class device object.
|
|
|
|
|
* @attr: device attribute structure.
|
|
|
|
|
* @buf: Data buffer.
|
|
|
|
|
*
|
|
|
|
|
* This function is the read call back function for
|
|
|
|
|
* lpfc_static_vport sysfs file. The lpfc_static_vport
|
|
|
|
|
* sysfs file report the mageability of the vport.
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_static_vport_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
if (vport->vport_flag & STATIC_VPORT)
|
|
|
|
|
sprintf(buf, "1\n");
|
|
|
|
|
else
|
|
|
|
|
sprintf(buf, "0\n");
|
|
|
|
|
|
|
|
|
|
return strlen(buf);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Sysfs attribute to control the statistical data collection.
|
|
|
|
|
*/
|
2024-06-12 13:13:20 +08:00
|
|
|
static DEVICE_ATTR_RO(lpfc_static_vport);
|
2008-09-07 23:52:10 +08:00
|
|
|
|
|
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_stat_data_ctrl_store - write call back for lpfc_stat_data_ctrl sysfs file
|
2008-09-07 23:52:10 +08:00
|
|
|
* @dev: Pointer to class device.
|
|
|
|
|
* @buf: Data buffer.
|
|
|
|
|
* @count: Size of the data buffer.
|
|
|
|
|
*
|
2017-02-28 06:28:47 +08:00
|
|
|
* This function get called when a user write to the lpfc_stat_data_ctrl
|
2008-09-07 23:52:10 +08:00
|
|
|
* sysfs file. This function parse the command written to the sysfs file
|
|
|
|
|
* and take appropriate action. These commands are used for controlling
|
|
|
|
|
* driver statistical data collection.
|
|
|
|
|
* Following are the command this function handles.
|
|
|
|
|
*
|
|
|
|
|
* setbucket <bucket_type> <base> <step>
|
|
|
|
|
* = Set the latency buckets.
|
|
|
|
|
* destroybucket = destroy all the buckets.
|
|
|
|
|
* start = start data collection
|
|
|
|
|
* stop = stop data collection
|
|
|
|
|
* reset = reset the collected data
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_stat_data_ctrl_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
const char *buf, size_t count)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
#define LPFC_MAX_DATA_CTRL_LEN 1024
|
|
|
|
|
static char bucket_data[LPFC_MAX_DATA_CTRL_LEN];
|
|
|
|
|
unsigned long i;
|
|
|
|
|
char *str_ptr, *token;
|
|
|
|
|
struct lpfc_vport **vports;
|
|
|
|
|
struct Scsi_Host *v_shost;
|
|
|
|
|
char *bucket_type_str, *base_str, *step_str;
|
|
|
|
|
unsigned long base, step, bucket_type;
|
|
|
|
|
|
|
|
|
|
if (!strncmp(buf, "setbucket", strlen("setbucket"))) {
|
2009-04-07 06:48:10 +08:00
|
|
|
if (strlen(buf) > (LPFC_MAX_DATA_CTRL_LEN - 1))
|
2008-09-07 23:52:10 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
2014-09-04 00:58:06 +08:00
|
|
|
strncpy(bucket_data, buf, LPFC_MAX_DATA_CTRL_LEN);
|
2008-09-07 23:52:10 +08:00
|
|
|
str_ptr = &bucket_data[0];
|
|
|
|
|
/* Ignore this token - this is command token */
|
|
|
|
|
token = strsep(&str_ptr, "\t ");
|
|
|
|
|
if (!token)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
bucket_type_str = strsep(&str_ptr, "\t ");
|
|
|
|
|
if (!bucket_type_str)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
if (!strncmp(bucket_type_str, "linear", strlen("linear")))
|
|
|
|
|
bucket_type = LPFC_LINEAR_BUCKET;
|
|
|
|
|
else if (!strncmp(bucket_type_str, "power2", strlen("power2")))
|
|
|
|
|
bucket_type = LPFC_POWER2_BUCKET;
|
|
|
|
|
else
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
base_str = strsep(&str_ptr, "\t ");
|
|
|
|
|
if (!base_str)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
base = simple_strtoul(base_str, NULL, 0);
|
|
|
|
|
|
|
|
|
|
step_str = strsep(&str_ptr, "\t ");
|
|
|
|
|
if (!step_str)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
step = simple_strtoul(step_str, NULL, 0);
|
|
|
|
|
if (!step)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
/* Block the data collection for every vport */
|
|
|
|
|
vports = lpfc_create_vport_work_array(phba);
|
|
|
|
|
if (vports == NULL)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
2009-05-23 02:53:12 +08:00
|
|
|
for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
|
2008-09-07 23:52:10 +08:00
|
|
|
v_shost = lpfc_shost_from_vport(vports[i]);
|
|
|
|
|
spin_lock_irq(v_shost->host_lock);
|
|
|
|
|
/* Block and reset data collection */
|
|
|
|
|
vports[i]->stat_data_blocked = 1;
|
|
|
|
|
if (vports[i]->stat_data_enabled)
|
|
|
|
|
lpfc_vport_reset_stat_data(vports[i]);
|
|
|
|
|
spin_unlock_irq(v_shost->host_lock);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Set the bucket attributes */
|
|
|
|
|
phba->bucket_type = bucket_type;
|
|
|
|
|
phba->bucket_base = base;
|
|
|
|
|
phba->bucket_step = step;
|
|
|
|
|
|
2009-05-23 02:53:12 +08:00
|
|
|
for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
|
2008-09-07 23:52:10 +08:00
|
|
|
v_shost = lpfc_shost_from_vport(vports[i]);
|
|
|
|
|
|
|
|
|
|
/* Unblock data collection */
|
|
|
|
|
spin_lock_irq(v_shost->host_lock);
|
|
|
|
|
vports[i]->stat_data_blocked = 0;
|
|
|
|
|
spin_unlock_irq(v_shost->host_lock);
|
|
|
|
|
}
|
|
|
|
|
lpfc_destroy_vport_work_array(phba, vports);
|
|
|
|
|
return strlen(buf);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!strncmp(buf, "destroybucket", strlen("destroybucket"))) {
|
|
|
|
|
vports = lpfc_create_vport_work_array(phba);
|
|
|
|
|
if (vports == NULL)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
2009-05-23 02:53:12 +08:00
|
|
|
for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
|
2008-09-07 23:52:10 +08:00
|
|
|
v_shost = lpfc_shost_from_vport(vports[i]);
|
|
|
|
|
spin_lock_irq(shost->host_lock);
|
|
|
|
|
vports[i]->stat_data_blocked = 1;
|
|
|
|
|
lpfc_free_bucket(vport);
|
|
|
|
|
vport->stat_data_enabled = 0;
|
|
|
|
|
vports[i]->stat_data_blocked = 0;
|
|
|
|
|
spin_unlock_irq(shost->host_lock);
|
|
|
|
|
}
|
|
|
|
|
lpfc_destroy_vport_work_array(phba, vports);
|
|
|
|
|
phba->bucket_type = LPFC_NO_BUCKET;
|
|
|
|
|
phba->bucket_base = 0;
|
|
|
|
|
phba->bucket_step = 0;
|
|
|
|
|
return strlen(buf);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!strncmp(buf, "start", strlen("start"))) {
|
|
|
|
|
/* If no buckets configured return error */
|
|
|
|
|
if (phba->bucket_type == LPFC_NO_BUCKET)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
spin_lock_irq(shost->host_lock);
|
|
|
|
|
if (vport->stat_data_enabled) {
|
|
|
|
|
spin_unlock_irq(shost->host_lock);
|
|
|
|
|
return strlen(buf);
|
|
|
|
|
}
|
|
|
|
|
lpfc_alloc_bucket(vport);
|
|
|
|
|
vport->stat_data_enabled = 1;
|
|
|
|
|
spin_unlock_irq(shost->host_lock);
|
|
|
|
|
return strlen(buf);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!strncmp(buf, "stop", strlen("stop"))) {
|
|
|
|
|
spin_lock_irq(shost->host_lock);
|
|
|
|
|
if (vport->stat_data_enabled == 0) {
|
|
|
|
|
spin_unlock_irq(shost->host_lock);
|
|
|
|
|
return strlen(buf);
|
|
|
|
|
}
|
|
|
|
|
lpfc_free_bucket(vport);
|
|
|
|
|
vport->stat_data_enabled = 0;
|
|
|
|
|
spin_unlock_irq(shost->host_lock);
|
|
|
|
|
return strlen(buf);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!strncmp(buf, "reset", strlen("reset"))) {
|
|
|
|
|
if ((phba->bucket_type == LPFC_NO_BUCKET)
|
|
|
|
|
|| !vport->stat_data_enabled)
|
|
|
|
|
return strlen(buf);
|
|
|
|
|
spin_lock_irq(shost->host_lock);
|
|
|
|
|
vport->stat_data_blocked = 1;
|
|
|
|
|
lpfc_vport_reset_stat_data(vport);
|
|
|
|
|
vport->stat_data_blocked = 0;
|
|
|
|
|
spin_unlock_irq(shost->host_lock);
|
|
|
|
|
return strlen(buf);
|
|
|
|
|
}
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_stat_data_ctrl_show - Read function for lpfc_stat_data_ctrl sysfs file
|
2008-09-07 23:52:10 +08:00
|
|
|
* @dev: Pointer to class device object.
|
|
|
|
|
* @buf: Data buffer.
|
|
|
|
|
*
|
|
|
|
|
* This function is the read call back function for
|
|
|
|
|
* lpfc_stat_data_ctrl sysfs file. This function report the
|
|
|
|
|
* current statistical data collection state.
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_stat_data_ctrl_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
int index = 0;
|
|
|
|
|
int i;
|
|
|
|
|
char *bucket_type;
|
|
|
|
|
unsigned long bucket_value;
|
|
|
|
|
|
|
|
|
|
switch (phba->bucket_type) {
|
|
|
|
|
case LPFC_LINEAR_BUCKET:
|
|
|
|
|
bucket_type = "linear";
|
|
|
|
|
break;
|
|
|
|
|
case LPFC_POWER2_BUCKET:
|
|
|
|
|
bucket_type = "power2";
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
bucket_type = "No Bucket";
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
sprintf(&buf[index], "Statistical Data enabled :%d, "
|
|
|
|
|
"blocked :%d, Bucket type :%s, Bucket base :%d,"
|
|
|
|
|
" Bucket step :%d\nLatency Ranges :",
|
|
|
|
|
vport->stat_data_enabled, vport->stat_data_blocked,
|
|
|
|
|
bucket_type, phba->bucket_base, phba->bucket_step);
|
|
|
|
|
index = strlen(buf);
|
|
|
|
|
if (phba->bucket_type != LPFC_NO_BUCKET) {
|
|
|
|
|
for (i = 0; i < LPFC_MAX_BUCKET_COUNT; i++) {
|
|
|
|
|
if (phba->bucket_type == LPFC_LINEAR_BUCKET)
|
|
|
|
|
bucket_value = phba->bucket_base +
|
|
|
|
|
phba->bucket_step * i;
|
|
|
|
|
else
|
|
|
|
|
bucket_value = phba->bucket_base +
|
|
|
|
|
(1 << i) * phba->bucket_step;
|
|
|
|
|
|
|
|
|
|
if (index + 10 > PAGE_SIZE)
|
|
|
|
|
break;
|
|
|
|
|
sprintf(&buf[index], "%08ld ", bucket_value);
|
|
|
|
|
index = strlen(buf);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
sprintf(&buf[index], "\n");
|
|
|
|
|
return strlen(buf);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Sysfs attribute to control the statistical data collection.
|
|
|
|
|
*/
|
2024-06-12 13:13:20 +08:00
|
|
|
static DEVICE_ATTR_RW(lpfc_stat_data_ctrl);
|
2008-09-07 23:52:10 +08:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* lpfc_drvr_stat_data: sysfs attr to get driver statistical data.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Each Bucket takes 11 characters and 1 new line + 17 bytes WWN
|
|
|
|
|
* for each target.
|
|
|
|
|
*/
|
|
|
|
|
#define STAT_DATA_SIZE_PER_TARGET(NUM_BUCKETS) ((NUM_BUCKETS) * 11 + 18)
|
|
|
|
|
#define MAX_STAT_DATA_SIZE_PER_TARGET \
|
|
|
|
|
STAT_DATA_SIZE_PER_TARGET(LPFC_MAX_BUCKET_COUNT)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* sysfs_drvr_stat_data_read - Read function for lpfc_drvr_stat_data attribute
|
2010-05-13 09:28:57 +08:00
|
|
|
* @filp: sysfs file
|
2008-09-07 23:52:10 +08:00
|
|
|
* @kobj: Pointer to the kernel object
|
|
|
|
|
* @bin_attr: Attribute object
|
|
|
|
|
* @buff: Buffer pointer
|
|
|
|
|
* @off: File offset
|
|
|
|
|
* @count: Buffer size
|
|
|
|
|
*
|
|
|
|
|
* This function is the read call back function for lpfc_drvr_stat_data
|
|
|
|
|
* sysfs file. This function export the statistical data to user
|
|
|
|
|
* applications.
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
2010-05-13 09:28:57 +08:00
|
|
|
sysfs_drvr_stat_data_read(struct file *filp, struct kobject *kobj,
|
|
|
|
|
struct bin_attribute *bin_attr,
|
2008-09-07 23:52:10 +08:00
|
|
|
char *buf, loff_t off, size_t count)
|
|
|
|
|
{
|
|
|
|
|
struct device *dev = container_of(kobj, struct device,
|
|
|
|
|
kobj);
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
int i = 0, index = 0;
|
|
|
|
|
unsigned long nport_index;
|
|
|
|
|
struct lpfc_nodelist *ndlp = NULL;
|
|
|
|
|
nport_index = (unsigned long)off /
|
|
|
|
|
MAX_STAT_DATA_SIZE_PER_TARGET;
|
|
|
|
|
|
|
|
|
|
if (!vport->stat_data_enabled || vport->stat_data_blocked
|
|
|
|
|
|| (phba->bucket_type == LPFC_NO_BUCKET))
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
spin_lock_irq(shost->host_lock);
|
|
|
|
|
list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
|
|
|
|
|
if (!NLP_CHK_NODE_ACT(ndlp) || !ndlp->lat_data)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
if (nport_index > 0) {
|
|
|
|
|
nport_index--;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if ((index + MAX_STAT_DATA_SIZE_PER_TARGET)
|
|
|
|
|
> count)
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
if (!ndlp->lat_data)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
/* Print the WWN */
|
|
|
|
|
sprintf(&buf[index], "%02x%02x%02x%02x%02x%02x%02x%02x:",
|
|
|
|
|
ndlp->nlp_portname.u.wwn[0],
|
|
|
|
|
ndlp->nlp_portname.u.wwn[1],
|
|
|
|
|
ndlp->nlp_portname.u.wwn[2],
|
|
|
|
|
ndlp->nlp_portname.u.wwn[3],
|
|
|
|
|
ndlp->nlp_portname.u.wwn[4],
|
|
|
|
|
ndlp->nlp_portname.u.wwn[5],
|
|
|
|
|
ndlp->nlp_portname.u.wwn[6],
|
|
|
|
|
ndlp->nlp_portname.u.wwn[7]);
|
|
|
|
|
|
|
|
|
|
index = strlen(buf);
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < LPFC_MAX_BUCKET_COUNT; i++) {
|
|
|
|
|
sprintf(&buf[index], "%010u,",
|
|
|
|
|
ndlp->lat_data[i].cmd_count);
|
|
|
|
|
index = strlen(buf);
|
|
|
|
|
}
|
|
|
|
|
sprintf(&buf[index], "\n");
|
|
|
|
|
index = strlen(buf);
|
|
|
|
|
}
|
|
|
|
|
spin_unlock_irq(shost->host_lock);
|
|
|
|
|
return index;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct bin_attribute sysfs_drvr_stat_data_attr = {
|
|
|
|
|
.attr = {
|
2024-06-12 13:13:20 +08:00
|
|
|
.name = "lpfc_drvr_stat_data",
|
2008-09-07 23:52:10 +08:00
|
|
|
.mode = S_IRUSR,
|
|
|
|
|
},
|
|
|
|
|
.size = LPFC_MAX_TARGET * MAX_STAT_DATA_SIZE_PER_TARGET,
|
|
|
|
|
.read = sysfs_drvr_stat_data_read,
|
|
|
|
|
.write = NULL,
|
|
|
|
|
};
|
|
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
/*
|
|
|
|
|
# lpfc_link_speed: Link speed selection for initializing the Fibre Channel
|
|
|
|
|
# connection.
|
2010-11-21 12:11:48 +08:00
|
|
|
# Value range is [0,16]. Default value is 0.
|
2005-04-18 05:05:31 +08:00
|
|
|
*/
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_link_speed_set - Set the adapters link speed
|
2008-08-25 09:49:00 +08:00
|
|
|
* @phba: lpfc_hba pointer.
|
|
|
|
|
* @val: link speed value.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* If val is in a valid range then set the adapter's link speed field and
|
|
|
|
|
* issue a lip; if the lip fails reset the link speed to the old value.
|
|
|
|
|
*
|
|
|
|
|
* Notes:
|
|
|
|
|
* If the value is not in range log a kernel error message and return an error.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* zero if val is in range and lip okay.
|
|
|
|
|
* non-zero return value from lpfc_issue_lip()
|
|
|
|
|
* -EINVAL val out of range
|
|
|
|
|
**/
|
2009-04-07 06:48:10 +08:00
|
|
|
static ssize_t
|
|
|
|
|
lpfc_link_speed_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
const char *buf, size_t count)
|
2008-01-11 14:53:09 +08:00
|
|
|
{
|
2009-04-07 06:48:10 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
2010-11-21 12:11:48 +08:00
|
|
|
int val = LPFC_USER_LINK_SPEED_AUTO;
|
2009-04-07 06:48:10 +08:00
|
|
|
int nolip = 0;
|
|
|
|
|
const char *val_buf = buf;
|
2008-01-11 14:53:09 +08:00
|
|
|
int err;
|
2016-10-14 06:06:16 +08:00
|
|
|
uint32_t prev_val, if_type;
|
|
|
|
|
|
|
|
|
|
if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf);
|
2018-12-11 11:37:01 +08:00
|
|
|
if (if_type >= LPFC_SLI_INTF_IF_TYPE_2 &&
|
2016-10-14 06:06:16 +08:00
|
|
|
phba->hba_flag & HBA_FORCED_LINK_SPEED)
|
|
|
|
|
return -EPERM;
|
2008-01-11 14:53:09 +08:00
|
|
|
|
2009-04-07 06:48:10 +08:00
|
|
|
if (!strncmp(buf, "nolip ", strlen("nolip "))) {
|
|
|
|
|
nolip = 1;
|
|
|
|
|
val_buf = &buf[strlen("nolip ")];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!isdigit(val_buf[0]))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
if (sscanf(val_buf, "%i", &val) != 1)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2011-07-23 06:36:33 +08:00
|
|
|
lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
|
|
|
|
|
"3055 lpfc_link_speed changed from %d to %d %s\n",
|
|
|
|
|
phba->cfg_link_speed, val, nolip ? "(nolip)" : "(lip)");
|
|
|
|
|
|
2010-11-21 12:11:48 +08:00
|
|
|
if (((val == LPFC_USER_LINK_SPEED_1G) && !(phba->lmt & LMT_1Gb)) ||
|
|
|
|
|
((val == LPFC_USER_LINK_SPEED_2G) && !(phba->lmt & LMT_2Gb)) ||
|
|
|
|
|
((val == LPFC_USER_LINK_SPEED_4G) && !(phba->lmt & LMT_4Gb)) ||
|
|
|
|
|
((val == LPFC_USER_LINK_SPEED_8G) && !(phba->lmt & LMT_8Gb)) ||
|
|
|
|
|
((val == LPFC_USER_LINK_SPEED_10G) && !(phba->lmt & LMT_10Gb)) ||
|
2015-09-01 04:48:17 +08:00
|
|
|
((val == LPFC_USER_LINK_SPEED_16G) && !(phba->lmt & LMT_16Gb)) ||
|
2018-02-23 00:18:45 +08:00
|
|
|
((val == LPFC_USER_LINK_SPEED_32G) && !(phba->lmt & LMT_32Gb)) ||
|
|
|
|
|
((val == LPFC_USER_LINK_SPEED_64G) && !(phba->lmt & LMT_64Gb))) {
|
2010-11-21 12:11:48 +08:00
|
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
|
|
|
|
|
"2879 lpfc_link_speed attribute cannot be set "
|
|
|
|
|
"to %d. Speed is not supported by this port.\n",
|
|
|
|
|
val);
|
2008-01-11 14:53:09 +08:00
|
|
|
return -EINVAL;
|
2010-11-21 12:11:48 +08:00
|
|
|
}
|
2018-02-23 00:18:45 +08:00
|
|
|
if (val >= LPFC_USER_LINK_SPEED_16G &&
|
|
|
|
|
phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
|
2011-12-14 02:21:35 +08:00
|
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
|
|
|
|
|
"3112 lpfc_link_speed attribute cannot be set "
|
|
|
|
|
"to %d. Speed is not supported in loop mode.\n",
|
|
|
|
|
val);
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
2018-02-23 00:18:45 +08:00
|
|
|
|
|
|
|
|
switch (val) {
|
|
|
|
|
case LPFC_USER_LINK_SPEED_AUTO:
|
|
|
|
|
case LPFC_USER_LINK_SPEED_1G:
|
|
|
|
|
case LPFC_USER_LINK_SPEED_2G:
|
|
|
|
|
case LPFC_USER_LINK_SPEED_4G:
|
|
|
|
|
case LPFC_USER_LINK_SPEED_8G:
|
|
|
|
|
case LPFC_USER_LINK_SPEED_16G:
|
|
|
|
|
case LPFC_USER_LINK_SPEED_32G:
|
|
|
|
|
case LPFC_USER_LINK_SPEED_64G:
|
2008-01-11 14:53:09 +08:00
|
|
|
prev_val = phba->cfg_link_speed;
|
|
|
|
|
phba->cfg_link_speed = val;
|
2009-04-07 06:48:10 +08:00
|
|
|
if (nolip)
|
|
|
|
|
return strlen(buf);
|
|
|
|
|
|
2008-01-11 14:53:09 +08:00
|
|
|
err = lpfc_issue_lip(lpfc_shost_from_vport(phba->pport));
|
2009-04-07 06:48:10 +08:00
|
|
|
if (err) {
|
2008-01-11 14:53:09 +08:00
|
|
|
phba->cfg_link_speed = prev_val;
|
2009-04-07 06:48:10 +08:00
|
|
|
return -EINVAL;
|
2018-02-23 00:18:45 +08:00
|
|
|
}
|
|
|
|
|
return strlen(buf);
|
|
|
|
|
default:
|
|
|
|
|
break;
|
2008-01-11 14:53:09 +08:00
|
|
|
}
|
2018-02-23 00:18:45 +08:00
|
|
|
|
2008-01-11 14:53:09 +08:00
|
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
|
2018-02-23 00:18:45 +08:00
|
|
|
"0469 lpfc_link_speed attribute cannot be set to %d, "
|
|
|
|
|
"allowed values are [%s]\n",
|
|
|
|
|
val, LPFC_LINK_SPEED_STRING);
|
2008-01-11 14:53:09 +08:00
|
|
|
return -EINVAL;
|
2018-02-23 00:18:45 +08:00
|
|
|
|
2008-01-11 14:53:09 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int lpfc_link_speed = 0;
|
2011-02-17 01:39:57 +08:00
|
|
|
module_param(lpfc_link_speed, int, S_IRUGO);
|
2008-01-11 14:53:09 +08:00
|
|
|
MODULE_PARM_DESC(lpfc_link_speed, "Select link speed");
|
|
|
|
|
lpfc_param_show(link_speed)
|
2008-08-25 09:49:00 +08:00
|
|
|
|
|
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_link_speed_init - Set the adapters link speed
|
2008-08-25 09:49:00 +08:00
|
|
|
* @phba: lpfc_hba pointer.
|
|
|
|
|
* @val: link speed value.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* If val is in a valid range then set the adapter's link speed field.
|
|
|
|
|
*
|
|
|
|
|
* Notes:
|
|
|
|
|
* If the value is not in range log a kernel error message, clear the link
|
|
|
|
|
* speed and return an error.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* zero if val saved.
|
|
|
|
|
* -EINVAL val out of range
|
|
|
|
|
**/
|
2008-01-11 14:53:09 +08:00
|
|
|
static int
|
|
|
|
|
lpfc_link_speed_init(struct lpfc_hba *phba, int val)
|
|
|
|
|
{
|
2018-02-23 00:18:45 +08:00
|
|
|
if (val >= LPFC_USER_LINK_SPEED_16G && phba->cfg_topology == 4) {
|
2011-12-14 02:21:35 +08:00
|
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
|
2024-06-12 13:13:20 +08:00
|
|
|
"3111 lpfc_link_speed of %d cannot "
|
2011-12-14 02:21:35 +08:00
|
|
|
"support loop mode, setting topology to default.\n",
|
|
|
|
|
val);
|
|
|
|
|
phba->cfg_topology = 0;
|
|
|
|
|
}
|
2018-02-23 00:18:45 +08:00
|
|
|
|
|
|
|
|
switch (val) {
|
|
|
|
|
case LPFC_USER_LINK_SPEED_AUTO:
|
|
|
|
|
case LPFC_USER_LINK_SPEED_1G:
|
|
|
|
|
case LPFC_USER_LINK_SPEED_2G:
|
|
|
|
|
case LPFC_USER_LINK_SPEED_4G:
|
|
|
|
|
case LPFC_USER_LINK_SPEED_8G:
|
|
|
|
|
case LPFC_USER_LINK_SPEED_16G:
|
|
|
|
|
case LPFC_USER_LINK_SPEED_32G:
|
|
|
|
|
case LPFC_USER_LINK_SPEED_64G:
|
2008-01-11 14:53:09 +08:00
|
|
|
phba->cfg_link_speed = val;
|
|
|
|
|
return 0;
|
2018-02-23 00:18:45 +08:00
|
|
|
default:
|
|
|
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
|
|
|
|
|
"0405 lpfc_link_speed attribute cannot "
|
|
|
|
|
"be set to %d, allowed values are "
|
|
|
|
|
"["LPFC_LINK_SPEED_STRING"]\n", val);
|
|
|
|
|
phba->cfg_link_speed = LPFC_USER_LINK_SPEED_AUTO;
|
|
|
|
|
return -EINVAL;
|
2008-01-11 14:53:09 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
static DEVICE_ATTR_RW(lpfc_link_speed);
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2009-10-03 03:16:56 +08:00
|
|
|
/*
|
|
|
|
|
# lpfc_aer_support: Support PCIe device Advanced Error Reporting (AER)
|
|
|
|
|
# 0 = aer disabled or not supported
|
|
|
|
|
# 1 = aer supported and enabled (default)
|
|
|
|
|
# Value range is [0,1]. Default value is 1.
|
|
|
|
|
*/
|
2016-10-14 06:06:09 +08:00
|
|
|
LPFC_ATTR(aer_support, 1, 0, 1,
|
|
|
|
|
"Enable PCIe device AER support");
|
|
|
|
|
lpfc_param_show(aer_support)
|
2009-10-03 03:16:56 +08:00
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* lpfc_aer_support_store - Set the adapter for aer support
|
|
|
|
|
*
|
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
2011-05-24 23:42:11 +08:00
|
|
|
* @buf: containing enable or disable aer flag.
|
2009-10-03 03:16:56 +08:00
|
|
|
* @count: unused variable.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* If the val is 1 and currently the device's AER capability was not
|
|
|
|
|
* enabled, invoke the kernel's enable AER helper routine, trying to
|
|
|
|
|
* enable the device's AER capability. If the helper routine enabling
|
|
|
|
|
* AER returns success, update the device's cfg_aer_support flag to
|
|
|
|
|
* indicate AER is supported by the device; otherwise, if the device
|
|
|
|
|
* AER capability is already enabled to support AER, then do nothing.
|
|
|
|
|
*
|
|
|
|
|
* If the val is 0 and currently the device's AER support was enabled,
|
|
|
|
|
* invoke the kernel's disable AER helper routine. After that, update
|
|
|
|
|
* the device's cfg_aer_support flag to indicate AER is not supported
|
|
|
|
|
* by the device; otherwise, if the device AER capability is already
|
|
|
|
|
* disabled from supporting AER, then do nothing.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* length of the buf on success if val is in range the intended mode
|
|
|
|
|
* is supported.
|
|
|
|
|
* -EINVAL if val out of range or intended mode is not supported.
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_aer_support_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
const char *buf, size_t count)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
int val = 0, rc = -EINVAL;
|
|
|
|
|
|
|
|
|
|
if (!isdigit(buf[0]))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
if (sscanf(buf, "%i", &val) != 1)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
switch (val) {
|
|
|
|
|
case 0:
|
|
|
|
|
if (phba->hba_flag & HBA_AER_ENABLED) {
|
|
|
|
|
rc = pci_disable_pcie_error_reporting(phba->pcidev);
|
|
|
|
|
if (!rc) {
|
|
|
|
|
spin_lock_irq(&phba->hbalock);
|
|
|
|
|
phba->hba_flag &= ~HBA_AER_ENABLED;
|
|
|
|
|
spin_unlock_irq(&phba->hbalock);
|
|
|
|
|
phba->cfg_aer_support = 0;
|
|
|
|
|
rc = strlen(buf);
|
|
|
|
|
} else
|
2009-11-19 04:40:23 +08:00
|
|
|
rc = -EPERM;
|
|
|
|
|
} else {
|
2009-10-03 03:16:56 +08:00
|
|
|
phba->cfg_aer_support = 0;
|
2009-11-19 04:40:23 +08:00
|
|
|
rc = strlen(buf);
|
|
|
|
|
}
|
2009-10-03 03:16:56 +08:00
|
|
|
break;
|
|
|
|
|
case 1:
|
|
|
|
|
if (!(phba->hba_flag & HBA_AER_ENABLED)) {
|
|
|
|
|
rc = pci_enable_pcie_error_reporting(phba->pcidev);
|
|
|
|
|
if (!rc) {
|
|
|
|
|
spin_lock_irq(&phba->hbalock);
|
|
|
|
|
phba->hba_flag |= HBA_AER_ENABLED;
|
|
|
|
|
spin_unlock_irq(&phba->hbalock);
|
|
|
|
|
phba->cfg_aer_support = 1;
|
|
|
|
|
rc = strlen(buf);
|
|
|
|
|
} else
|
2009-11-19 04:40:23 +08:00
|
|
|
rc = -EPERM;
|
|
|
|
|
} else {
|
2009-10-03 03:16:56 +08:00
|
|
|
phba->cfg_aer_support = 1;
|
2009-11-19 04:40:23 +08:00
|
|
|
rc = strlen(buf);
|
|
|
|
|
}
|
2009-10-03 03:16:56 +08:00
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
rc = -EINVAL;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
static DEVICE_ATTR_RW(lpfc_aer_support);
|
2009-10-03 03:16:56 +08:00
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* lpfc_aer_cleanup_state - Clean up aer state to the aer enabled device
|
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
2011-05-24 23:42:11 +08:00
|
|
|
* @buf: containing flag 1 for aer cleanup state.
|
2009-10-03 03:16:56 +08:00
|
|
|
* @count: unused variable.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* If the @buf contains 1 and the device currently has the AER support
|
|
|
|
|
* enabled, then invokes the kernel AER helper routine
|
2024-06-12 13:13:20 +08:00
|
|
|
* pci_cleanup_aer_uncorrect_error_status to clean up the uncorrectable
|
|
|
|
|
* error status register.
|
2009-10-03 03:16:56 +08:00
|
|
|
*
|
|
|
|
|
* Notes:
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* -EINVAL if the buf does not contain the 1 or the device is not currently
|
|
|
|
|
* enabled with the AER support.
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_aer_cleanup_state(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
const char *buf, size_t count)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
int val, rc = -1;
|
|
|
|
|
|
|
|
|
|
if (!isdigit(buf[0]))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
if (sscanf(buf, "%i", &val) != 1)
|
|
|
|
|
return -EINVAL;
|
2009-11-19 04:40:23 +08:00
|
|
|
if (val != 1)
|
|
|
|
|
return -EINVAL;
|
2009-10-03 03:16:56 +08:00
|
|
|
|
2009-11-19 04:40:23 +08:00
|
|
|
if (phba->hba_flag & HBA_AER_ENABLED)
|
2009-10-03 03:16:56 +08:00
|
|
|
rc = pci_cleanup_aer_uncorrect_error_status(phba->pcidev);
|
|
|
|
|
|
|
|
|
|
if (rc == 0)
|
|
|
|
|
return strlen(buf);
|
|
|
|
|
else
|
2009-11-19 04:40:23 +08:00
|
|
|
return -EPERM;
|
2009-10-03 03:16:56 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static DEVICE_ATTR(lpfc_aer_state_cleanup, S_IWUSR, NULL,
|
|
|
|
|
lpfc_aer_cleanup_state);
|
|
|
|
|
|
2011-05-24 23:42:11 +08:00
|
|
|
/**
|
|
|
|
|
* lpfc_sriov_nr_virtfn_store - Enable the adapter for sr-iov virtual functions
|
|
|
|
|
*
|
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: containing the string the number of vfs to be enabled.
|
|
|
|
|
* @count: unused variable.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* When this api is called either through user sysfs, the driver shall
|
|
|
|
|
* try to enable or disable SR-IOV virtual functions according to the
|
|
|
|
|
* following:
|
|
|
|
|
*
|
|
|
|
|
* If zero virtual function has been enabled to the physical function,
|
|
|
|
|
* the driver shall invoke the pci enable virtual function api trying
|
|
|
|
|
* to enable the virtual functions. If the nr_vfn provided is greater
|
|
|
|
|
* than the maximum supported, the maximum virtual function number will
|
|
|
|
|
* be used for invoking the api; otherwise, the nr_vfn provided shall
|
|
|
|
|
* be used for invoking the api. If the api call returned success, the
|
|
|
|
|
* actual number of virtual functions enabled will be set to the driver
|
|
|
|
|
* cfg_sriov_nr_virtfn; otherwise, -EINVAL shall be returned and driver
|
|
|
|
|
* cfg_sriov_nr_virtfn remains zero.
|
|
|
|
|
*
|
|
|
|
|
* If none-zero virtual functions have already been enabled to the
|
|
|
|
|
* physical function, as reflected by the driver's cfg_sriov_nr_virtfn,
|
|
|
|
|
* -EINVAL will be returned and the driver does nothing;
|
|
|
|
|
*
|
|
|
|
|
* If the nr_vfn provided is zero and none-zero virtual functions have
|
|
|
|
|
* been enabled, as indicated by the driver's cfg_sriov_nr_virtfn, the
|
|
|
|
|
* disabling virtual function api shall be invoded to disable all the
|
|
|
|
|
* virtual functions and driver's cfg_sriov_nr_virtfn shall be set to
|
|
|
|
|
* zero. Otherwise, if zero virtual function has been enabled, do
|
|
|
|
|
* nothing.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* length of the buf on success if val is in range the intended mode
|
|
|
|
|
* is supported.
|
|
|
|
|
* -EINVAL if val out of range or intended mode is not supported.
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_sriov_nr_virtfn_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
const char *buf, size_t count)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
struct pci_dev *pdev = phba->pcidev;
|
|
|
|
|
int val = 0, rc = -EINVAL;
|
|
|
|
|
|
|
|
|
|
/* Sanity check on user data */
|
|
|
|
|
if (!isdigit(buf[0]))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
if (sscanf(buf, "%i", &val) != 1)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
if (val < 0)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
/* Request disabling virtual functions */
|
|
|
|
|
if (val == 0) {
|
|
|
|
|
if (phba->cfg_sriov_nr_virtfn > 0) {
|
|
|
|
|
pci_disable_sriov(pdev);
|
|
|
|
|
phba->cfg_sriov_nr_virtfn = 0;
|
|
|
|
|
}
|
|
|
|
|
return strlen(buf);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Request enabling virtual functions */
|
|
|
|
|
if (phba->cfg_sriov_nr_virtfn > 0) {
|
|
|
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
|
|
|
|
|
"3018 There are %d virtual functions "
|
|
|
|
|
"enabled on physical function.\n",
|
|
|
|
|
phba->cfg_sriov_nr_virtfn);
|
|
|
|
|
return -EEXIST;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (val <= LPFC_MAX_VFN_PER_PFN)
|
|
|
|
|
phba->cfg_sriov_nr_virtfn = val;
|
|
|
|
|
else {
|
|
|
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
|
|
|
|
|
"3019 Enabling %d virtual functions is not "
|
|
|
|
|
"allowed.\n", val);
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
rc = lpfc_sli_probe_sriov_nr_virtfn(phba, phba->cfg_sriov_nr_virtfn);
|
|
|
|
|
if (rc) {
|
|
|
|
|
phba->cfg_sriov_nr_virtfn = 0;
|
|
|
|
|
rc = -EPERM;
|
|
|
|
|
} else
|
|
|
|
|
rc = strlen(buf);
|
|
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
2016-10-14 06:06:12 +08:00
|
|
|
LPFC_ATTR(sriov_nr_virtfn, LPFC_DEF_VFN_PER_PFN, 0, LPFC_MAX_VFN_PER_PFN,
|
|
|
|
|
"Enable PCIe device SR-IOV virtual fn");
|
2011-05-24 23:42:11 +08:00
|
|
|
|
2016-10-14 06:06:12 +08:00
|
|
|
lpfc_param_show(sriov_nr_virtfn)
|
2024-06-12 13:13:20 +08:00
|
|
|
static DEVICE_ATTR_RW(lpfc_sriov_nr_virtfn);
|
2011-05-24 23:42:11 +08:00
|
|
|
|
2012-11-01 02:44:33 +08:00
|
|
|
/**
|
|
|
|
|
* lpfc_request_firmware_store - Request for Linux generic firmware upgrade
|
|
|
|
|
*
|
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: containing the string the number of vfs to be enabled.
|
|
|
|
|
* @count: unused variable.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* length of the buf on success if val is in range the intended mode
|
|
|
|
|
* is supported.
|
|
|
|
|
* -EINVAL if val out of range or intended mode is not supported.
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_request_firmware_upgrade_store(struct device *dev,
|
|
|
|
|
struct device_attribute *attr,
|
|
|
|
|
const char *buf, size_t count)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
int val = 0, rc = -EINVAL;
|
|
|
|
|
|
|
|
|
|
/* Sanity check on user data */
|
|
|
|
|
if (!isdigit(buf[0]))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
if (sscanf(buf, "%i", &val) != 1)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
if (val != 1)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
rc = lpfc_sli4_request_firmware_update(phba, RUN_FW_UPGRADE);
|
|
|
|
|
if (rc)
|
|
|
|
|
rc = -EPERM;
|
|
|
|
|
else
|
|
|
|
|
rc = strlen(buf);
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int lpfc_req_fw_upgrade;
|
|
|
|
|
module_param(lpfc_req_fw_upgrade, int, S_IRUGO|S_IWUSR);
|
|
|
|
|
MODULE_PARM_DESC(lpfc_req_fw_upgrade, "Enable Linux generic firmware upgrade");
|
|
|
|
|
lpfc_param_show(request_firmware_upgrade)
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* lpfc_request_firmware_upgrade_init - Enable initial linux generic fw upgrade
|
|
|
|
|
* @phba: lpfc_hba pointer.
|
|
|
|
|
* @val: 0 or 1.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* Set the initial Linux generic firmware upgrade enable or disable flag.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* zero if val saved.
|
|
|
|
|
* -EINVAL val out of range
|
|
|
|
|
**/
|
|
|
|
|
static int
|
|
|
|
|
lpfc_request_firmware_upgrade_init(struct lpfc_hba *phba, int val)
|
|
|
|
|
{
|
|
|
|
|
if (val >= 0 && val <= 1) {
|
|
|
|
|
phba->cfg_request_firmware_upgrade = val;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
static DEVICE_ATTR(lpfc_req_fw_upgrade, S_IRUGO | S_IWUSR,
|
|
|
|
|
lpfc_request_firmware_upgrade_show,
|
|
|
|
|
lpfc_request_firmware_upgrade_store);
|
|
|
|
|
|
2019-05-15 05:58:08 +08:00
|
|
|
/**
|
|
|
|
|
* lpfc_force_rscn_store
|
|
|
|
|
*
|
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: unused string
|
|
|
|
|
* @count: unused variable.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* Force the switch to send a RSCN to all other NPorts in our zone
|
|
|
|
|
* If we are direct connect pt2pt, build the RSCN command ourself
|
|
|
|
|
* and send to the other NPort. Not supported for private loop.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* 0 - on success
|
|
|
|
|
* -EIO - if command is not sent
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_force_rscn_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
const char *buf, size_t count)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
i = lpfc_issue_els_rscn(vport, 0);
|
|
|
|
|
if (i)
|
|
|
|
|
return -EIO;
|
|
|
|
|
return strlen(buf);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* lpfc_force_rscn: Force an RSCN to be sent to all remote NPorts
|
|
|
|
|
* connected to the HBA.
|
|
|
|
|
*
|
|
|
|
|
* Value range is any ascii value
|
|
|
|
|
*/
|
2024-06-12 13:13:20 +08:00
|
|
|
static int lpfc_force_rscn;
|
|
|
|
|
module_param(lpfc_force_rscn, int, 0644);
|
2019-05-15 05:58:08 +08:00
|
|
|
MODULE_PARM_DESC(lpfc_force_rscn,
|
|
|
|
|
"Force an RSCN to be sent to all remote NPorts");
|
|
|
|
|
lpfc_param_show(force_rscn)
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* lpfc_force_rscn_init - Force an RSCN to be sent to all remote NPorts
|
|
|
|
|
* @phba: lpfc_hba pointer.
|
|
|
|
|
* @val: unused value.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* zero if val saved.
|
|
|
|
|
**/
|
|
|
|
|
static int
|
|
|
|
|
lpfc_force_rscn_init(struct lpfc_hba *phba, int val)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
static DEVICE_ATTR_RW(lpfc_force_rscn);
|
|
|
|
|
|
2012-06-13 01:54:50 +08:00
|
|
|
/**
|
|
|
|
|
* lpfc_fcp_imax_store
|
|
|
|
|
*
|
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: string with the number of fast-path FCP interrupts per second.
|
|
|
|
|
* @count: unused variable.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* If val is in a valid range [636,651042], then set the adapter's
|
|
|
|
|
* maximum number of fast-path FCP interrupts per second.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* length of the buf on success if val is in range the intended mode
|
|
|
|
|
* is supported.
|
|
|
|
|
* -EINVAL if val out of range or intended mode is not supported.
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_fcp_imax_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
const char *buf, size_t count)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
scsi: lpfc: Rework EQ/CQ processing to address interrupt coalescing
When driving high iop counts, auto_imax coalescing kicks in and drives the
performance to extremely small iops levels.
There are two issues:
1) auto_imax is enabled by default. The auto algorithm, when iops gets
high, divides the iops by the hdwq count and uses that value to
calculate EQ_Delay. The EQ_Delay is set uniformly on all EQs whether
they have load or not. The EQ_delay is only manipulated every 5s (a
long time). Thus there were large 5s swings of no interrupt delay
followed by large/maximum delay, before repeating.
2) When processing a CQ, the driver got mixed up on the rate of when
to ring the doorbell to keep the chip appraised of the eqe or cqe
consumption as well as how how long to sit in the thread and
process queue entries. Currently, the driver capped its work at
64 entries (very small) and exited/rearmed the CQ. Thus, on heavy
loads, additional overheads were taken to exit and re-enter the
interrupt handler. Worse, if in the large/maximum coalescing
windows,k it could be a while before getting back to servicing.
The issues are corrected by the following:
- A change in defaults. Auto_imax is turned OFF and fcp_imax is set
to 0. Thus all interrupts are immediate.
- Cleanup of field names and their meanings. Existing names were
non-intuitive or used for duplicate things.
- Added max_proc_limit field, to control the length of time the
handlers would service completions.
- Reworked EQ handling:
Added common routine that walks eq, applying notify interval and max
processing limits. Use queue_claimed to claim ownership of the queue
while processing. Always rearm the queue whenever the common routine
is called.
Rework queue element processing, namely to eliminate hba_index vs
host_index. Only one index is necessary. The queue entry can be
marked invalid and the host_index updated immediately after eqe
processing.
After rework, xx_release routines are now DB write functions. Renamed
the routines as such.
Moved lpfc_sli4_eq_flush(), which does similar action, to same area.
Replaced the 2 individual loops that walk an eq with a call to the
common routine.
Slightly revised lpfc_sli4_hba_handle_eqe() calling syntax.
Added per-cpu counters to detect interrupt rates and scale
interrupt coalescing values.
- Reworked CQ handling:
Added common routine that walks cq, applying notify interval and max
processing limits. Use queue_claimed to claim ownership of the queue
while processing. Always rearm the queue whenever the common routine
is called.
Rework queue element processing, namely to eliminate hba_index vs
host_index. Only one index is necessary. The queue entry can be
marked invalid and the host_index updated immediately after cqe
processing.
After rework, xx_release routines are now DB write functions. Renamed
the routines as such.
Replaced the 3 individual loops that walk a cq with a call to the
common routine.
Redefined lpfc_sli4_sp_handle_mcqe() to commong handler definition with
queue reference. Add increment for mbox completion to handler.
- Added a new module/sysfs attribute: lpfc_cq_max_proc_limit To allow
dynamic changing of the CQ max_proc_limit value being used.
Although this leaves an EQ as an immediate interrupt, that interrupt will
only occur if a CQ bound to it is in an armed state and has cqe's to
process. By staying in the cq processing routine longer, high loads will
avoid generating more interrupts as they will only rearm as the processing
thread exits. The immediately interrupt is also beneficial to idle or
lower-processing CQ's as they get serviced immediately without being
penalized by sharing an EQ with a more loaded CQ.
Signed-off-by: Dick Kennedy <dick.kennedy@broadcom.com>
Signed-off-by: James Smart <jsmart2021@gmail.com>
Reviewed-by: Hannes Reinecke <hare@suse.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-01-29 03:14:33 +08:00
|
|
|
struct lpfc_eq_intr_info *eqi;
|
2019-01-29 03:14:32 +08:00
|
|
|
uint32_t usdelay;
|
2012-06-13 01:54:50 +08:00
|
|
|
int val = 0, i;
|
|
|
|
|
|
2012-08-04 00:36:24 +08:00
|
|
|
/* fcp_imax is only valid for SLI4 */
|
|
|
|
|
if (phba->sli_rev != LPFC_SLI_REV4)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2012-06-13 01:54:50 +08:00
|
|
|
/* Sanity check on user data */
|
|
|
|
|
if (!isdigit(buf[0]))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
if (sscanf(buf, "%i", &val) != 1)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2012-08-04 00:36:24 +08:00
|
|
|
/*
|
|
|
|
|
* Value range for the HBA is [5000,5000000]
|
|
|
|
|
* The value for each EQ depends on how many EQs are configured.
|
2017-02-13 05:52:30 +08:00
|
|
|
* Allow value == 0
|
2012-08-04 00:36:24 +08:00
|
|
|
*/
|
2017-02-13 05:52:30 +08:00
|
|
|
if (val && (val < LPFC_MIN_IMAX || val > LPFC_MAX_IMAX))
|
2012-06-13 01:54:50 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
scsi: lpfc: Rework EQ/CQ processing to address interrupt coalescing
When driving high iop counts, auto_imax coalescing kicks in and drives the
performance to extremely small iops levels.
There are two issues:
1) auto_imax is enabled by default. The auto algorithm, when iops gets
high, divides the iops by the hdwq count and uses that value to
calculate EQ_Delay. The EQ_Delay is set uniformly on all EQs whether
they have load or not. The EQ_delay is only manipulated every 5s (a
long time). Thus there were large 5s swings of no interrupt delay
followed by large/maximum delay, before repeating.
2) When processing a CQ, the driver got mixed up on the rate of when
to ring the doorbell to keep the chip appraised of the eqe or cqe
consumption as well as how how long to sit in the thread and
process queue entries. Currently, the driver capped its work at
64 entries (very small) and exited/rearmed the CQ. Thus, on heavy
loads, additional overheads were taken to exit and re-enter the
interrupt handler. Worse, if in the large/maximum coalescing
windows,k it could be a while before getting back to servicing.
The issues are corrected by the following:
- A change in defaults. Auto_imax is turned OFF and fcp_imax is set
to 0. Thus all interrupts are immediate.
- Cleanup of field names and their meanings. Existing names were
non-intuitive or used for duplicate things.
- Added max_proc_limit field, to control the length of time the
handlers would service completions.
- Reworked EQ handling:
Added common routine that walks eq, applying notify interval and max
processing limits. Use queue_claimed to claim ownership of the queue
while processing. Always rearm the queue whenever the common routine
is called.
Rework queue element processing, namely to eliminate hba_index vs
host_index. Only one index is necessary. The queue entry can be
marked invalid and the host_index updated immediately after eqe
processing.
After rework, xx_release routines are now DB write functions. Renamed
the routines as such.
Moved lpfc_sli4_eq_flush(), which does similar action, to same area.
Replaced the 2 individual loops that walk an eq with a call to the
common routine.
Slightly revised lpfc_sli4_hba_handle_eqe() calling syntax.
Added per-cpu counters to detect interrupt rates and scale
interrupt coalescing values.
- Reworked CQ handling:
Added common routine that walks cq, applying notify interval and max
processing limits. Use queue_claimed to claim ownership of the queue
while processing. Always rearm the queue whenever the common routine
is called.
Rework queue element processing, namely to eliminate hba_index vs
host_index. Only one index is necessary. The queue entry can be
marked invalid and the host_index updated immediately after cqe
processing.
After rework, xx_release routines are now DB write functions. Renamed
the routines as such.
Replaced the 3 individual loops that walk a cq with a call to the
common routine.
Redefined lpfc_sli4_sp_handle_mcqe() to commong handler definition with
queue reference. Add increment for mbox completion to handler.
- Added a new module/sysfs attribute: lpfc_cq_max_proc_limit To allow
dynamic changing of the CQ max_proc_limit value being used.
Although this leaves an EQ as an immediate interrupt, that interrupt will
only occur if a CQ bound to it is in an armed state and has cqe's to
process. By staying in the cq processing routine longer, high loads will
avoid generating more interrupts as they will only rearm as the processing
thread exits. The immediately interrupt is also beneficial to idle or
lower-processing CQ's as they get serviced immediately without being
penalized by sharing an EQ with a more loaded CQ.
Signed-off-by: Dick Kennedy <dick.kennedy@broadcom.com>
Signed-off-by: James Smart <jsmart2021@gmail.com>
Reviewed-by: Hannes Reinecke <hare@suse.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-01-29 03:14:33 +08:00
|
|
|
phba->cfg_auto_imax = (val) ? 0 : 1;
|
|
|
|
|
if (phba->cfg_fcp_imax && !val) {
|
|
|
|
|
queue_delayed_work(phba->wq, &phba->eq_delay_work,
|
|
|
|
|
msecs_to_jiffies(LPFC_EQ_DELAY_MSECS));
|
|
|
|
|
|
|
|
|
|
for_each_present_cpu(i) {
|
|
|
|
|
eqi = per_cpu_ptr(phba->sli4_hba.eq_info, i);
|
|
|
|
|
eqi->icnt = 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-06-13 01:54:50 +08:00
|
|
|
phba->cfg_fcp_imax = (uint32_t)val;
|
2017-03-05 01:30:34 +08:00
|
|
|
|
2019-01-29 03:14:32 +08:00
|
|
|
if (phba->cfg_fcp_imax)
|
|
|
|
|
usdelay = LPFC_SEC_TO_USEC / phba->cfg_fcp_imax;
|
|
|
|
|
else
|
|
|
|
|
usdelay = 0;
|
|
|
|
|
|
2019-01-29 03:14:31 +08:00
|
|
|
for (i = 0; i < phba->cfg_irq_chann; i += LPFC_MAX_EQ_DELAY_EQID_CNT)
|
2017-06-02 12:07:10 +08:00
|
|
|
lpfc_modify_hba_eq_delay(phba, i, LPFC_MAX_EQ_DELAY_EQID_CNT,
|
2019-01-29 03:14:32 +08:00
|
|
|
usdelay);
|
2012-06-13 01:54:50 +08:00
|
|
|
|
|
|
|
|
return strlen(buf);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
# lpfc_fcp_imax: The maximum number of fast-path FCP interrupts per second
|
2012-08-04 00:36:24 +08:00
|
|
|
# for the HBA.
|
2012-06-13 01:54:50 +08:00
|
|
|
#
|
2012-08-04 00:36:24 +08:00
|
|
|
# Value range is [5,000 to 5,000,000]. Default value is 50,000.
|
2012-06-13 01:54:50 +08:00
|
|
|
*/
|
2012-08-04 00:36:24 +08:00
|
|
|
static int lpfc_fcp_imax = LPFC_DEF_IMAX;
|
2012-06-13 01:54:50 +08:00
|
|
|
module_param(lpfc_fcp_imax, int, S_IRUGO|S_IWUSR);
|
|
|
|
|
MODULE_PARM_DESC(lpfc_fcp_imax,
|
2012-08-04 00:36:24 +08:00
|
|
|
"Set the maximum number of FCP interrupts per second per HBA");
|
2012-06-13 01:54:50 +08:00
|
|
|
lpfc_param_show(fcp_imax)
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* lpfc_fcp_imax_init - Set the initial sr-iov virtual function enable
|
|
|
|
|
* @phba: lpfc_hba pointer.
|
|
|
|
|
* @val: link speed value.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* If val is in a valid range [636,651042], then initialize the adapter's
|
|
|
|
|
* maximum number of fast-path FCP interrupts per second.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* zero if val saved.
|
|
|
|
|
* -EINVAL val out of range
|
|
|
|
|
**/
|
|
|
|
|
static int
|
|
|
|
|
lpfc_fcp_imax_init(struct lpfc_hba *phba, int val)
|
|
|
|
|
{
|
2012-08-04 00:36:24 +08:00
|
|
|
if (phba->sli_rev != LPFC_SLI_REV4) {
|
|
|
|
|
phba->cfg_fcp_imax = 0;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2017-02-13 05:52:30 +08:00
|
|
|
if ((val >= LPFC_MIN_IMAX && val <= LPFC_MAX_IMAX) ||
|
|
|
|
|
(val == 0)) {
|
2012-06-13 01:54:50 +08:00
|
|
|
phba->cfg_fcp_imax = val;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
|
2024-06-12 13:13:20 +08:00
|
|
|
"3016 lpfc_fcp_imax: %d out of range, using default\n",
|
|
|
|
|
val);
|
2012-08-04 00:36:24 +08:00
|
|
|
phba->cfg_fcp_imax = LPFC_DEF_IMAX;
|
2012-06-13 01:54:50 +08:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
static DEVICE_ATTR_RW(lpfc_fcp_imax);
|
2024-06-11 20:26:44 +08:00
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* lpfc_cq_max_proc_limit_store
|
|
|
|
|
*
|
scsi: lpfc: Rework EQ/CQ processing to address interrupt coalescing
When driving high iop counts, auto_imax coalescing kicks in and drives the
performance to extremely small iops levels.
There are two issues:
1) auto_imax is enabled by default. The auto algorithm, when iops gets
high, divides the iops by the hdwq count and uses that value to
calculate EQ_Delay. The EQ_Delay is set uniformly on all EQs whether
they have load or not. The EQ_delay is only manipulated every 5s (a
long time). Thus there were large 5s swings of no interrupt delay
followed by large/maximum delay, before repeating.
2) When processing a CQ, the driver got mixed up on the rate of when
to ring the doorbell to keep the chip appraised of the eqe or cqe
consumption as well as how how long to sit in the thread and
process queue entries. Currently, the driver capped its work at
64 entries (very small) and exited/rearmed the CQ. Thus, on heavy
loads, additional overheads were taken to exit and re-enter the
interrupt handler. Worse, if in the large/maximum coalescing
windows,k it could be a while before getting back to servicing.
The issues are corrected by the following:
- A change in defaults. Auto_imax is turned OFF and fcp_imax is set
to 0. Thus all interrupts are immediate.
- Cleanup of field names and their meanings. Existing names were
non-intuitive or used for duplicate things.
- Added max_proc_limit field, to control the length of time the
handlers would service completions.
- Reworked EQ handling:
Added common routine that walks eq, applying notify interval and max
processing limits. Use queue_claimed to claim ownership of the queue
while processing. Always rearm the queue whenever the common routine
is called.
Rework queue element processing, namely to eliminate hba_index vs
host_index. Only one index is necessary. The queue entry can be
marked invalid and the host_index updated immediately after eqe
processing.
After rework, xx_release routines are now DB write functions. Renamed
the routines as such.
Moved lpfc_sli4_eq_flush(), which does similar action, to same area.
Replaced the 2 individual loops that walk an eq with a call to the
common routine.
Slightly revised lpfc_sli4_hba_handle_eqe() calling syntax.
Added per-cpu counters to detect interrupt rates and scale
interrupt coalescing values.
- Reworked CQ handling:
Added common routine that walks cq, applying notify interval and max
processing limits. Use queue_claimed to claim ownership of the queue
while processing. Always rearm the queue whenever the common routine
is called.
Rework queue element processing, namely to eliminate hba_index vs
host_index. Only one index is necessary. The queue entry can be
marked invalid and the host_index updated immediately after cqe
processing.
After rework, xx_release routines are now DB write functions. Renamed
the routines as such.
Replaced the 3 individual loops that walk a cq with a call to the
common routine.
Redefined lpfc_sli4_sp_handle_mcqe() to commong handler definition with
queue reference. Add increment for mbox completion to handler.
- Added a new module/sysfs attribute: lpfc_cq_max_proc_limit To allow
dynamic changing of the CQ max_proc_limit value being used.
Although this leaves an EQ as an immediate interrupt, that interrupt will
only occur if a CQ bound to it is in an armed state and has cqe's to
process. By staying in the cq processing routine longer, high loads will
avoid generating more interrupts as they will only rearm as the processing
thread exits. The immediately interrupt is also beneficial to idle or
lower-processing CQ's as they get serviced immediately without being
penalized by sharing an EQ with a more loaded CQ.
Signed-off-by: Dick Kennedy <dick.kennedy@broadcom.com>
Signed-off-by: James Smart <jsmart2021@gmail.com>
Reviewed-by: Hannes Reinecke <hare@suse.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-01-29 03:14:33 +08:00
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: string with the cq max processing limit of cqes
|
|
|
|
|
* @count: unused variable.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* If val is in a valid range, then set value on each cq
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* The length of the buf: if successful
|
|
|
|
|
* -ERANGE: if val is not in the valid range
|
|
|
|
|
* -EINVAL: if bad value format or intended mode is not supported.
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_cq_max_proc_limit_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
const char *buf, size_t count)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
struct lpfc_queue *eq, *cq;
|
|
|
|
|
unsigned long val;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
/* cq_max_proc_limit is only valid for SLI4 */
|
|
|
|
|
if (phba->sli_rev != LPFC_SLI_REV4)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
/* Sanity check on user data */
|
|
|
|
|
if (!isdigit(buf[0]))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
if (kstrtoul(buf, 0, &val))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
if (val < LPFC_CQ_MIN_PROC_LIMIT || val > LPFC_CQ_MAX_PROC_LIMIT)
|
|
|
|
|
return -ERANGE;
|
|
|
|
|
|
|
|
|
|
phba->cfg_cq_max_proc_limit = (uint32_t)val;
|
|
|
|
|
|
|
|
|
|
/* set the values on the cq's */
|
|
|
|
|
for (i = 0; i < phba->cfg_irq_chann; i++) {
|
2019-05-22 08:49:06 +08:00
|
|
|
/* Get the EQ corresponding to the IRQ vector */
|
|
|
|
|
eq = phba->sli4_hba.hba_eq_hdl[i].eq;
|
scsi: lpfc: Rework EQ/CQ processing to address interrupt coalescing
When driving high iop counts, auto_imax coalescing kicks in and drives the
performance to extremely small iops levels.
There are two issues:
1) auto_imax is enabled by default. The auto algorithm, when iops gets
high, divides the iops by the hdwq count and uses that value to
calculate EQ_Delay. The EQ_Delay is set uniformly on all EQs whether
they have load or not. The EQ_delay is only manipulated every 5s (a
long time). Thus there were large 5s swings of no interrupt delay
followed by large/maximum delay, before repeating.
2) When processing a CQ, the driver got mixed up on the rate of when
to ring the doorbell to keep the chip appraised of the eqe or cqe
consumption as well as how how long to sit in the thread and
process queue entries. Currently, the driver capped its work at
64 entries (very small) and exited/rearmed the CQ. Thus, on heavy
loads, additional overheads were taken to exit and re-enter the
interrupt handler. Worse, if in the large/maximum coalescing
windows,k it could be a while before getting back to servicing.
The issues are corrected by the following:
- A change in defaults. Auto_imax is turned OFF and fcp_imax is set
to 0. Thus all interrupts are immediate.
- Cleanup of field names and their meanings. Existing names were
non-intuitive or used for duplicate things.
- Added max_proc_limit field, to control the length of time the
handlers would service completions.
- Reworked EQ handling:
Added common routine that walks eq, applying notify interval and max
processing limits. Use queue_claimed to claim ownership of the queue
while processing. Always rearm the queue whenever the common routine
is called.
Rework queue element processing, namely to eliminate hba_index vs
host_index. Only one index is necessary. The queue entry can be
marked invalid and the host_index updated immediately after eqe
processing.
After rework, xx_release routines are now DB write functions. Renamed
the routines as such.
Moved lpfc_sli4_eq_flush(), which does similar action, to same area.
Replaced the 2 individual loops that walk an eq with a call to the
common routine.
Slightly revised lpfc_sli4_hba_handle_eqe() calling syntax.
Added per-cpu counters to detect interrupt rates and scale
interrupt coalescing values.
- Reworked CQ handling:
Added common routine that walks cq, applying notify interval and max
processing limits. Use queue_claimed to claim ownership of the queue
while processing. Always rearm the queue whenever the common routine
is called.
Rework queue element processing, namely to eliminate hba_index vs
host_index. Only one index is necessary. The queue entry can be
marked invalid and the host_index updated immediately after cqe
processing.
After rework, xx_release routines are now DB write functions. Renamed
the routines as such.
Replaced the 3 individual loops that walk a cq with a call to the
common routine.
Redefined lpfc_sli4_sp_handle_mcqe() to commong handler definition with
queue reference. Add increment for mbox completion to handler.
- Added a new module/sysfs attribute: lpfc_cq_max_proc_limit To allow
dynamic changing of the CQ max_proc_limit value being used.
Although this leaves an EQ as an immediate interrupt, that interrupt will
only occur if a CQ bound to it is in an armed state and has cqe's to
process. By staying in the cq processing routine longer, high loads will
avoid generating more interrupts as they will only rearm as the processing
thread exits. The immediately interrupt is also beneficial to idle or
lower-processing CQ's as they get serviced immediately without being
penalized by sharing an EQ with a more loaded CQ.
Signed-off-by: Dick Kennedy <dick.kennedy@broadcom.com>
Signed-off-by: James Smart <jsmart2021@gmail.com>
Reviewed-by: Hannes Reinecke <hare@suse.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-01-29 03:14:33 +08:00
|
|
|
if (!eq)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
list_for_each_entry(cq, &eq->child_list, list)
|
|
|
|
|
cq->max_proc_limit = min(phba->cfg_cq_max_proc_limit,
|
|
|
|
|
cq->entry_count);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return strlen(buf);
|
|
|
|
|
}
|
|
|
|
|
|
2017-06-02 12:07:10 +08:00
|
|
|
/*
|
scsi: lpfc: Rework EQ/CQ processing to address interrupt coalescing
When driving high iop counts, auto_imax coalescing kicks in and drives the
performance to extremely small iops levels.
There are two issues:
1) auto_imax is enabled by default. The auto algorithm, when iops gets
high, divides the iops by the hdwq count and uses that value to
calculate EQ_Delay. The EQ_Delay is set uniformly on all EQs whether
they have load or not. The EQ_delay is only manipulated every 5s (a
long time). Thus there were large 5s swings of no interrupt delay
followed by large/maximum delay, before repeating.
2) When processing a CQ, the driver got mixed up on the rate of when
to ring the doorbell to keep the chip appraised of the eqe or cqe
consumption as well as how how long to sit in the thread and
process queue entries. Currently, the driver capped its work at
64 entries (very small) and exited/rearmed the CQ. Thus, on heavy
loads, additional overheads were taken to exit and re-enter the
interrupt handler. Worse, if in the large/maximum coalescing
windows,k it could be a while before getting back to servicing.
The issues are corrected by the following:
- A change in defaults. Auto_imax is turned OFF and fcp_imax is set
to 0. Thus all interrupts are immediate.
- Cleanup of field names and their meanings. Existing names were
non-intuitive or used for duplicate things.
- Added max_proc_limit field, to control the length of time the
handlers would service completions.
- Reworked EQ handling:
Added common routine that walks eq, applying notify interval and max
processing limits. Use queue_claimed to claim ownership of the queue
while processing. Always rearm the queue whenever the common routine
is called.
Rework queue element processing, namely to eliminate hba_index vs
host_index. Only one index is necessary. The queue entry can be
marked invalid and the host_index updated immediately after eqe
processing.
After rework, xx_release routines are now DB write functions. Renamed
the routines as such.
Moved lpfc_sli4_eq_flush(), which does similar action, to same area.
Replaced the 2 individual loops that walk an eq with a call to the
common routine.
Slightly revised lpfc_sli4_hba_handle_eqe() calling syntax.
Added per-cpu counters to detect interrupt rates and scale
interrupt coalescing values.
- Reworked CQ handling:
Added common routine that walks cq, applying notify interval and max
processing limits. Use queue_claimed to claim ownership of the queue
while processing. Always rearm the queue whenever the common routine
is called.
Rework queue element processing, namely to eliminate hba_index vs
host_index. Only one index is necessary. The queue entry can be
marked invalid and the host_index updated immediately after cqe
processing.
After rework, xx_release routines are now DB write functions. Renamed
the routines as such.
Replaced the 3 individual loops that walk a cq with a call to the
common routine.
Redefined lpfc_sli4_sp_handle_mcqe() to commong handler definition with
queue reference. Add increment for mbox completion to handler.
- Added a new module/sysfs attribute: lpfc_cq_max_proc_limit To allow
dynamic changing of the CQ max_proc_limit value being used.
Although this leaves an EQ as an immediate interrupt, that interrupt will
only occur if a CQ bound to it is in an armed state and has cqe's to
process. By staying in the cq processing routine longer, high loads will
avoid generating more interrupts as they will only rearm as the processing
thread exits. The immediately interrupt is also beneficial to idle or
lower-processing CQ's as they get serviced immediately without being
penalized by sharing an EQ with a more loaded CQ.
Signed-off-by: Dick Kennedy <dick.kennedy@broadcom.com>
Signed-off-by: James Smart <jsmart2021@gmail.com>
Reviewed-by: Hannes Reinecke <hare@suse.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-01-29 03:14:33 +08:00
|
|
|
* lpfc_cq_max_proc_limit: The maximum number CQE entries processed in an
|
|
|
|
|
* itteration of CQ processing.
|
2017-06-02 12:07:10 +08:00
|
|
|
*/
|
scsi: lpfc: Rework EQ/CQ processing to address interrupt coalescing
When driving high iop counts, auto_imax coalescing kicks in and drives the
performance to extremely small iops levels.
There are two issues:
1) auto_imax is enabled by default. The auto algorithm, when iops gets
high, divides the iops by the hdwq count and uses that value to
calculate EQ_Delay. The EQ_Delay is set uniformly on all EQs whether
they have load or not. The EQ_delay is only manipulated every 5s (a
long time). Thus there were large 5s swings of no interrupt delay
followed by large/maximum delay, before repeating.
2) When processing a CQ, the driver got mixed up on the rate of when
to ring the doorbell to keep the chip appraised of the eqe or cqe
consumption as well as how how long to sit in the thread and
process queue entries. Currently, the driver capped its work at
64 entries (very small) and exited/rearmed the CQ. Thus, on heavy
loads, additional overheads were taken to exit and re-enter the
interrupt handler. Worse, if in the large/maximum coalescing
windows,k it could be a while before getting back to servicing.
The issues are corrected by the following:
- A change in defaults. Auto_imax is turned OFF and fcp_imax is set
to 0. Thus all interrupts are immediate.
- Cleanup of field names and their meanings. Existing names were
non-intuitive or used for duplicate things.
- Added max_proc_limit field, to control the length of time the
handlers would service completions.
- Reworked EQ handling:
Added common routine that walks eq, applying notify interval and max
processing limits. Use queue_claimed to claim ownership of the queue
while processing. Always rearm the queue whenever the common routine
is called.
Rework queue element processing, namely to eliminate hba_index vs
host_index. Only one index is necessary. The queue entry can be
marked invalid and the host_index updated immediately after eqe
processing.
After rework, xx_release routines are now DB write functions. Renamed
the routines as such.
Moved lpfc_sli4_eq_flush(), which does similar action, to same area.
Replaced the 2 individual loops that walk an eq with a call to the
common routine.
Slightly revised lpfc_sli4_hba_handle_eqe() calling syntax.
Added per-cpu counters to detect interrupt rates and scale
interrupt coalescing values.
- Reworked CQ handling:
Added common routine that walks cq, applying notify interval and max
processing limits. Use queue_claimed to claim ownership of the queue
while processing. Always rearm the queue whenever the common routine
is called.
Rework queue element processing, namely to eliminate hba_index vs
host_index. Only one index is necessary. The queue entry can be
marked invalid and the host_index updated immediately after cqe
processing.
After rework, xx_release routines are now DB write functions. Renamed
the routines as such.
Replaced the 3 individual loops that walk a cq with a call to the
common routine.
Redefined lpfc_sli4_sp_handle_mcqe() to commong handler definition with
queue reference. Add increment for mbox completion to handler.
- Added a new module/sysfs attribute: lpfc_cq_max_proc_limit To allow
dynamic changing of the CQ max_proc_limit value being used.
Although this leaves an EQ as an immediate interrupt, that interrupt will
only occur if a CQ bound to it is in an armed state and has cqe's to
process. By staying in the cq processing routine longer, high loads will
avoid generating more interrupts as they will only rearm as the processing
thread exits. The immediately interrupt is also beneficial to idle or
lower-processing CQ's as they get serviced immediately without being
penalized by sharing an EQ with a more loaded CQ.
Signed-off-by: Dick Kennedy <dick.kennedy@broadcom.com>
Signed-off-by: James Smart <jsmart2021@gmail.com>
Reviewed-by: Hannes Reinecke <hare@suse.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-01-29 03:14:33 +08:00
|
|
|
static int lpfc_cq_max_proc_limit = LPFC_CQ_DEF_MAX_PROC_LIMIT;
|
|
|
|
|
module_param(lpfc_cq_max_proc_limit, int, 0644);
|
|
|
|
|
MODULE_PARM_DESC(lpfc_cq_max_proc_limit,
|
|
|
|
|
"Set the maximum number CQEs processed in an iteration of "
|
|
|
|
|
"CQ processing");
|
|
|
|
|
lpfc_param_show(cq_max_proc_limit)
|
|
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
/*
|
|
|
|
|
* lpfc_cq_poll_threshold: Set the threshold of CQE completions in a
|
|
|
|
|
* single handler call which should request a polled completion rather
|
|
|
|
|
* than re-enabling interrupts.
|
|
|
|
|
*/
|
|
|
|
|
LPFC_ATTR_RW(cq_poll_threshold, LPFC_CQ_DEF_THRESHOLD_TO_POLL,
|
|
|
|
|
LPFC_CQ_MIN_THRESHOLD_TO_POLL,
|
|
|
|
|
LPFC_CQ_MAX_THRESHOLD_TO_POLL,
|
|
|
|
|
"CQE Processing Threshold to enable Polling");
|
|
|
|
|
|
scsi: lpfc: Rework EQ/CQ processing to address interrupt coalescing
When driving high iop counts, auto_imax coalescing kicks in and drives the
performance to extremely small iops levels.
There are two issues:
1) auto_imax is enabled by default. The auto algorithm, when iops gets
high, divides the iops by the hdwq count and uses that value to
calculate EQ_Delay. The EQ_Delay is set uniformly on all EQs whether
they have load or not. The EQ_delay is only manipulated every 5s (a
long time). Thus there were large 5s swings of no interrupt delay
followed by large/maximum delay, before repeating.
2) When processing a CQ, the driver got mixed up on the rate of when
to ring the doorbell to keep the chip appraised of the eqe or cqe
consumption as well as how how long to sit in the thread and
process queue entries. Currently, the driver capped its work at
64 entries (very small) and exited/rearmed the CQ. Thus, on heavy
loads, additional overheads were taken to exit and re-enter the
interrupt handler. Worse, if in the large/maximum coalescing
windows,k it could be a while before getting back to servicing.
The issues are corrected by the following:
- A change in defaults. Auto_imax is turned OFF and fcp_imax is set
to 0. Thus all interrupts are immediate.
- Cleanup of field names and their meanings. Existing names were
non-intuitive or used for duplicate things.
- Added max_proc_limit field, to control the length of time the
handlers would service completions.
- Reworked EQ handling:
Added common routine that walks eq, applying notify interval and max
processing limits. Use queue_claimed to claim ownership of the queue
while processing. Always rearm the queue whenever the common routine
is called.
Rework queue element processing, namely to eliminate hba_index vs
host_index. Only one index is necessary. The queue entry can be
marked invalid and the host_index updated immediately after eqe
processing.
After rework, xx_release routines are now DB write functions. Renamed
the routines as such.
Moved lpfc_sli4_eq_flush(), which does similar action, to same area.
Replaced the 2 individual loops that walk an eq with a call to the
common routine.
Slightly revised lpfc_sli4_hba_handle_eqe() calling syntax.
Added per-cpu counters to detect interrupt rates and scale
interrupt coalescing values.
- Reworked CQ handling:
Added common routine that walks cq, applying notify interval and max
processing limits. Use queue_claimed to claim ownership of the queue
while processing. Always rearm the queue whenever the common routine
is called.
Rework queue element processing, namely to eliminate hba_index vs
host_index. Only one index is necessary. The queue entry can be
marked invalid and the host_index updated immediately after cqe
processing.
After rework, xx_release routines are now DB write functions. Renamed
the routines as such.
Replaced the 3 individual loops that walk a cq with a call to the
common routine.
Redefined lpfc_sli4_sp_handle_mcqe() to commong handler definition with
queue reference. Add increment for mbox completion to handler.
- Added a new module/sysfs attribute: lpfc_cq_max_proc_limit To allow
dynamic changing of the CQ max_proc_limit value being used.
Although this leaves an EQ as an immediate interrupt, that interrupt will
only occur if a CQ bound to it is in an armed state and has cqe's to
process. By staying in the cq processing routine longer, high loads will
avoid generating more interrupts as they will only rearm as the processing
thread exits. The immediately interrupt is also beneficial to idle or
lower-processing CQ's as they get serviced immediately without being
penalized by sharing an EQ with a more loaded CQ.
Signed-off-by: Dick Kennedy <dick.kennedy@broadcom.com>
Signed-off-by: James Smart <jsmart2021@gmail.com>
Reviewed-by: Hannes Reinecke <hare@suse.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-01-29 03:14:33 +08:00
|
|
|
/**
|
|
|
|
|
* lpfc_cq_max_proc_limit_init - Set the initial cq max_proc_limit
|
|
|
|
|
* @phba: lpfc_hba pointer.
|
|
|
|
|
* @val: entry limit
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* If val is in a valid range, then initialize the adapter's maximum
|
|
|
|
|
* value.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* Always returns 0 for success, even if value not always set to
|
|
|
|
|
* requested value. If value out of range or not supported, will fall
|
|
|
|
|
* back to default.
|
|
|
|
|
**/
|
|
|
|
|
static int
|
|
|
|
|
lpfc_cq_max_proc_limit_init(struct lpfc_hba *phba, int val)
|
|
|
|
|
{
|
|
|
|
|
phba->cfg_cq_max_proc_limit = LPFC_CQ_DEF_MAX_PROC_LIMIT;
|
|
|
|
|
|
|
|
|
|
if (phba->sli_rev != LPFC_SLI_REV4)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
if (val >= LPFC_CQ_MIN_PROC_LIMIT && val <= LPFC_CQ_MAX_PROC_LIMIT) {
|
|
|
|
|
phba->cfg_cq_max_proc_limit = val;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
|
|
|
|
|
"0371 "LPFC_DRIVER_NAME"_cq_max_proc_limit: "
|
|
|
|
|
"%d out of range, using default\n",
|
|
|
|
|
phba->cfg_cq_max_proc_limit);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
static DEVICE_ATTR_RW(lpfc_cq_max_proc_limit);
|
2017-06-02 12:07:10 +08:00
|
|
|
|
2013-04-18 08:19:16 +08:00
|
|
|
/**
|
|
|
|
|
* lpfc_state_show - Display current driver CPU affinity
|
|
|
|
|
* @dev: class converted to a Scsi_host structure.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: on return contains text describing the state of the link.
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_fcp_cpu_map_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
struct lpfc_vector_map_info *cpup;
|
2014-02-20 22:57:18 +08:00
|
|
|
int len = 0;
|
2013-04-18 08:19:16 +08:00
|
|
|
|
|
|
|
|
if ((phba->sli_rev != LPFC_SLI_REV4) ||
|
|
|
|
|
(phba->intr_type != MSIX))
|
|
|
|
|
return len;
|
|
|
|
|
|
|
|
|
|
switch (phba->cfg_fcp_cpu_map) {
|
|
|
|
|
case 0:
|
2024-06-12 13:13:20 +08:00
|
|
|
len += scnprintf(buf + len, PAGE_SIZE-len,
|
2013-04-18 08:19:16 +08:00
|
|
|
"fcp_cpu_map: No mapping (%d)\n",
|
|
|
|
|
phba->cfg_fcp_cpu_map);
|
|
|
|
|
return len;
|
|
|
|
|
case 1:
|
2024-06-12 13:13:20 +08:00
|
|
|
len += scnprintf(buf + len, PAGE_SIZE-len,
|
2013-04-18 08:19:16 +08:00
|
|
|
"fcp_cpu_map: HBA centric mapping (%d): "
|
2019-01-29 03:14:35 +08:00
|
|
|
"%d of %d CPUs online from %d possible CPUs\n",
|
|
|
|
|
phba->cfg_fcp_cpu_map, num_online_cpus(),
|
|
|
|
|
num_present_cpus(),
|
|
|
|
|
phba->sli4_hba.num_possible_cpu);
|
2013-04-18 08:19:16 +08:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
while (phba->sli4_hba.curr_disp_cpu <
|
|
|
|
|
phba->sli4_hba.num_possible_cpu) {
|
2014-02-20 22:57:18 +08:00
|
|
|
cpup = &phba->sli4_hba.cpu_map[phba->sli4_hba.curr_disp_cpu];
|
|
|
|
|
|
2019-01-29 03:14:35 +08:00
|
|
|
if (!cpu_present(phba->sli4_hba.curr_disp_cpu))
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
len += scnprintf(buf + len, PAGE_SIZE - len,
|
2019-01-29 03:14:35 +08:00
|
|
|
"CPU %02d not present\n",
|
|
|
|
|
phba->sli4_hba.curr_disp_cpu);
|
2024-06-12 13:13:20 +08:00
|
|
|
else if (cpup->irq == LPFC_VECTOR_MAP_EMPTY) {
|
2019-01-29 03:14:30 +08:00
|
|
|
if (cpup->hdwq == LPFC_VECTOR_MAP_EMPTY)
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
len += scnprintf(
|
2019-01-29 03:14:30 +08:00
|
|
|
buf + len, PAGE_SIZE - len,
|
|
|
|
|
"CPU %02d hdwq None "
|
2019-05-22 08:49:05 +08:00
|
|
|
"physid %d coreid %d ht %d ua %d\n",
|
2014-02-20 22:57:18 +08:00
|
|
|
phba->sli4_hba.curr_disp_cpu,
|
2019-05-22 08:49:05 +08:00
|
|
|
cpup->phys_id, cpup->core_id,
|
|
|
|
|
(cpup->flag & LPFC_CPU_MAP_HYPER),
|
|
|
|
|
(cpup->flag & LPFC_CPU_MAP_UNASSIGN));
|
2019-01-29 03:14:30 +08:00
|
|
|
else
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
len += scnprintf(
|
2019-01-29 03:14:30 +08:00
|
|
|
buf + len, PAGE_SIZE - len,
|
2024-06-12 13:13:20 +08:00
|
|
|
"CPU %02d EQ %04d hdwq %04d "
|
2019-05-22 08:49:05 +08:00
|
|
|
"physid %d coreid %d ht %d ua %d\n",
|
2019-01-29 03:14:30 +08:00
|
|
|
phba->sli4_hba.curr_disp_cpu,
|
2024-06-12 13:13:20 +08:00
|
|
|
cpup->eq, cpup->hdwq, cpup->phys_id,
|
2019-05-22 08:49:05 +08:00
|
|
|
cpup->core_id,
|
|
|
|
|
(cpup->flag & LPFC_CPU_MAP_HYPER),
|
|
|
|
|
(cpup->flag & LPFC_CPU_MAP_UNASSIGN));
|
2019-01-29 03:14:30 +08:00
|
|
|
} else {
|
|
|
|
|
if (cpup->hdwq == LPFC_VECTOR_MAP_EMPTY)
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
len += scnprintf(
|
2019-01-29 03:14:30 +08:00
|
|
|
buf + len, PAGE_SIZE - len,
|
|
|
|
|
"CPU %02d hdwq None "
|
2019-05-22 08:49:05 +08:00
|
|
|
"physid %d coreid %d ht %d ua %d IRQ %d\n",
|
2019-01-29 03:14:30 +08:00
|
|
|
phba->sli4_hba.curr_disp_cpu,
|
|
|
|
|
cpup->phys_id,
|
2019-05-22 08:49:05 +08:00
|
|
|
cpup->core_id,
|
|
|
|
|
(cpup->flag & LPFC_CPU_MAP_HYPER),
|
|
|
|
|
(cpup->flag & LPFC_CPU_MAP_UNASSIGN),
|
2024-06-12 13:13:20 +08:00
|
|
|
cpup->irq);
|
2019-01-29 03:14:30 +08:00
|
|
|
else
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
len += scnprintf(
|
2019-01-29 03:14:30 +08:00
|
|
|
buf + len, PAGE_SIZE - len,
|
2019-01-29 03:14:31 +08:00
|
|
|
"CPU %02d EQ %04d hdwq %04d "
|
2019-05-22 08:49:05 +08:00
|
|
|
"physid %d coreid %d ht %d ua %d IRQ %d\n",
|
2014-02-20 22:57:18 +08:00
|
|
|
phba->sli4_hba.curr_disp_cpu,
|
2019-01-29 03:14:31 +08:00
|
|
|
cpup->eq, cpup->hdwq, cpup->phys_id,
|
2019-05-22 08:49:05 +08:00
|
|
|
cpup->core_id,
|
|
|
|
|
(cpup->flag & LPFC_CPU_MAP_HYPER),
|
|
|
|
|
(cpup->flag & LPFC_CPU_MAP_UNASSIGN),
|
2024-06-12 13:13:20 +08:00
|
|
|
cpup->irq);
|
2019-01-29 03:14:30 +08:00
|
|
|
}
|
2013-04-18 08:19:16 +08:00
|
|
|
|
2014-02-20 22:57:18 +08:00
|
|
|
phba->sli4_hba.curr_disp_cpu++;
|
|
|
|
|
|
|
|
|
|
/* display max number of CPUs keeping some margin */
|
|
|
|
|
if (phba->sli4_hba.curr_disp_cpu <
|
2019-01-29 03:14:35 +08:00
|
|
|
phba->sli4_hba.num_possible_cpu &&
|
2014-02-20 22:57:18 +08:00
|
|
|
(len >= (PAGE_SIZE - 64))) {
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
len += scnprintf(buf + len,
|
2019-01-29 03:14:35 +08:00
|
|
|
PAGE_SIZE - len, "more...\n");
|
2014-02-20 22:57:18 +08:00
|
|
|
break;
|
|
|
|
|
}
|
2013-04-18 08:19:16 +08:00
|
|
|
}
|
2014-02-20 22:57:18 +08:00
|
|
|
|
2019-01-29 03:14:35 +08:00
|
|
|
if (phba->sli4_hba.curr_disp_cpu == phba->sli4_hba.num_possible_cpu)
|
2014-02-20 22:57:18 +08:00
|
|
|
phba->sli4_hba.curr_disp_cpu = 0;
|
|
|
|
|
|
2013-04-18 08:19:16 +08:00
|
|
|
return len;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* lpfc_fcp_cpu_map_store - Change CPU affinity of driver vectors
|
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: one or more lpfc_polling_flags values.
|
|
|
|
|
* @count: not used.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* -EINVAL - Not implemented yet.
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_fcp_cpu_map_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
const char *buf, size_t count)
|
|
|
|
|
{
|
|
|
|
|
int status = -EINVAL;
|
|
|
|
|
return status;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
# lpfc_fcp_cpu_map: Defines how to map CPUs to IRQ vectors
|
|
|
|
|
# for the HBA.
|
|
|
|
|
#
|
2019-01-29 03:14:31 +08:00
|
|
|
# Value range is [0 to 1]. Default value is LPFC_HBA_CPU_MAP (1).
|
2013-04-18 08:19:16 +08:00
|
|
|
# 0 - Do not affinitze IRQ vectors
|
|
|
|
|
# 1 - Affintize HBA vectors with respect to each HBA
|
|
|
|
|
# (start with CPU0 for each HBA)
|
2019-01-29 03:14:31 +08:00
|
|
|
# This also defines how Hardware Queues are mapped to specific CPUs.
|
2013-04-18 08:19:16 +08:00
|
|
|
*/
|
2019-01-29 03:14:31 +08:00
|
|
|
static int lpfc_fcp_cpu_map = LPFC_HBA_CPU_MAP;
|
2013-04-18 08:19:16 +08:00
|
|
|
module_param(lpfc_fcp_cpu_map, int, S_IRUGO|S_IWUSR);
|
|
|
|
|
MODULE_PARM_DESC(lpfc_fcp_cpu_map,
|
|
|
|
|
"Defines how to map CPUs to IRQ vectors per HBA");
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* lpfc_fcp_cpu_map_init - Set the initial sr-iov virtual function enable
|
|
|
|
|
* @phba: lpfc_hba pointer.
|
|
|
|
|
* @val: link speed value.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* If val is in a valid range [0-2], then affinitze the adapter's
|
|
|
|
|
* MSIX vectors.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* zero if val saved.
|
|
|
|
|
* -EINVAL val out of range
|
|
|
|
|
**/
|
|
|
|
|
static int
|
|
|
|
|
lpfc_fcp_cpu_map_init(struct lpfc_hba *phba, int val)
|
|
|
|
|
{
|
|
|
|
|
if (phba->sli_rev != LPFC_SLI_REV4) {
|
|
|
|
|
phba->cfg_fcp_cpu_map = 0;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (val >= LPFC_MIN_CPU_MAP && val <= LPFC_MAX_CPU_MAP) {
|
|
|
|
|
phba->cfg_fcp_cpu_map = val;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
|
2024-06-12 13:13:20 +08:00
|
|
|
"3326 lpfc_fcp_cpu_map: %d out of range, using "
|
|
|
|
|
"default\n", val);
|
2019-01-29 03:14:31 +08:00
|
|
|
phba->cfg_fcp_cpu_map = LPFC_HBA_CPU_MAP;
|
2013-04-18 08:19:16 +08:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
static DEVICE_ATTR_RW(lpfc_fcp_cpu_map);
|
2013-04-18 08:19:16 +08:00
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
/*
|
|
|
|
|
# lpfc_fcp_class: Determines FC class to use for the FCP protocol.
|
|
|
|
|
# Value range is [2,3]. Default value is 3.
|
|
|
|
|
*/
|
2007-08-02 23:09:59 +08:00
|
|
|
LPFC_VPORT_ATTR_R(fcp_class, 3, 2, 3,
|
|
|
|
|
"Select Fibre Channel class of service for FCP sequences");
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
# lpfc_use_adisc: Use ADISC for FCP rediscovery instead of PLOGI. Value range
|
|
|
|
|
# is [0,1]. Default value is 0.
|
|
|
|
|
*/
|
2007-08-02 23:09:59 +08:00
|
|
|
LPFC_VPORT_ATTR_RW(use_adisc, 0, 0, 1,
|
|
|
|
|
"Use ADISC on rediscovery to authenticate FCP devices");
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2013-07-16 06:35:04 +08:00
|
|
|
/*
|
|
|
|
|
# lpfc_first_burst_size: First burst size to use on the NPorts
|
|
|
|
|
# that support first burst.
|
|
|
|
|
# Value range is [0,65536]. Default value is 0.
|
|
|
|
|
*/
|
|
|
|
|
LPFC_VPORT_ATTR_RW(first_burst_size, 0, 0, 65536,
|
|
|
|
|
"First burst size for Targets that support first burst");
|
|
|
|
|
|
2017-02-13 05:52:30 +08:00
|
|
|
/*
|
2017-02-13 05:52:35 +08:00
|
|
|
* lpfc_nvmet_fb_size: NVME Target mode supported first burst size.
|
|
|
|
|
* When the driver is configured as an NVME target, this value is
|
|
|
|
|
* communicated to the NVME initiator in the PRLI response. It is
|
|
|
|
|
* used only when the lpfc_nvme_enable_fb and lpfc_nvmet_support
|
|
|
|
|
* parameters are set and the target is sending the PRLI RSP.
|
2017-02-13 05:52:30 +08:00
|
|
|
* Parameter supported on physical port only - no NPIV support.
|
2017-02-13 05:52:35 +08:00
|
|
|
* Value range is [0,65536]. Default value is 0.
|
2017-02-13 05:52:30 +08:00
|
|
|
*/
|
2017-02-13 05:52:35 +08:00
|
|
|
LPFC_ATTR_RW(nvmet_fb_size, 0, 0, 65536,
|
|
|
|
|
"NVME Target mode first burst size in 512B increments.");
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* lpfc_nvme_enable_fb: Enable NVME first burst on I and T functions.
|
|
|
|
|
* For the Initiator (I), enabling this parameter means that an NVMET
|
|
|
|
|
* PRLI response with FBA enabled and an FB_SIZE set to a nonzero value will be
|
2019-08-15 07:57:03 +08:00
|
|
|
* processed by the initiator for subsequent NVME FCP IO.
|
|
|
|
|
* Currently, this feature is not supported on the NVME target
|
2017-02-13 05:52:35 +08:00
|
|
|
* Value range is [0,1]. Default value is 0 (disabled).
|
|
|
|
|
*/
|
2017-02-13 05:52:30 +08:00
|
|
|
LPFC_ATTR_RW(nvme_enable_fb, 0, 0, 1,
|
2019-08-15 07:57:03 +08:00
|
|
|
"Enable First Burst feature for NVME Initiator.");
|
2017-02-13 05:52:30 +08:00
|
|
|
|
2008-09-07 23:52:04 +08:00
|
|
|
/*
|
|
|
|
|
# lpfc_max_scsicmpl_time: Use scsi command completion time to control I/O queue
|
|
|
|
|
# depth. Default value is 0. When the value of this parameter is zero the
|
|
|
|
|
# SCSI command completion time is not used for controlling I/O queue depth. When
|
|
|
|
|
# the parameter is set to a non-zero value, the I/O queue depth is controlled
|
|
|
|
|
# to limit the I/O completion time to the parameter value.
|
|
|
|
|
# The value is set in milliseconds.
|
|
|
|
|
*/
|
2016-10-14 06:06:11 +08:00
|
|
|
LPFC_VPORT_ATTR(max_scsicmpl_time, 0, 0, 60000,
|
2008-09-07 23:52:04 +08:00
|
|
|
"Use command completion time to control queue depth");
|
2016-10-14 06:06:11 +08:00
|
|
|
|
2008-09-07 23:52:04 +08:00
|
|
|
lpfc_vport_param_show(max_scsicmpl_time);
|
|
|
|
|
static int
|
|
|
|
|
lpfc_max_scsicmpl_time_set(struct lpfc_vport *vport, int val)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
|
|
|
|
|
struct lpfc_nodelist *ndlp, *next_ndlp;
|
|
|
|
|
|
|
|
|
|
if (val == vport->cfg_max_scsicmpl_time)
|
|
|
|
|
return 0;
|
|
|
|
|
if ((val < 0) || (val > 60000))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
vport->cfg_max_scsicmpl_time = val;
|
|
|
|
|
|
|
|
|
|
spin_lock_irq(shost->host_lock);
|
|
|
|
|
list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
|
|
|
|
|
if (!NLP_CHK_NODE_ACT(ndlp))
|
|
|
|
|
continue;
|
|
|
|
|
if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
|
|
|
|
|
continue;
|
2010-07-15 03:32:10 +08:00
|
|
|
ndlp->cmd_qdepth = vport->cfg_tgt_queue_depth;
|
2008-09-07 23:52:04 +08:00
|
|
|
}
|
|
|
|
|
spin_unlock_irq(shost->host_lock);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
lpfc_vport_param_store(max_scsicmpl_time);
|
2024-06-12 13:13:20 +08:00
|
|
|
static DEVICE_ATTR_RW(lpfc_max_scsicmpl_time);
|
2008-09-07 23:52:04 +08:00
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
/*
|
|
|
|
|
# lpfc_ack0: Use ACK0, instead of ACK1 for class 2 acknowledgement. Value
|
|
|
|
|
# range is [0,1]. Default value is 0.
|
|
|
|
|
*/
|
|
|
|
|
LPFC_ATTR_R(ack0, 0, 0, 1, "Enable ACK0 support");
|
|
|
|
|
|
scsi: lpfc: Adapt partitioned XRI lists to efficient sharing
The XRI get/put lists were partitioned per hardware queue. However, the
adapter rarely had sufficient resources to give a large number of resources
per queue. As such, it became common for a cpu to encounter a lack of XRI
resource and request the upper io stack to retry after returning a BUSY
condition. This occurred even though other cpus were idle and not using
their resources.
Create as efficient a scheme as possible to move resources to the cpus that
need them. Each cpu maintains a small private pool which it allocates from
for io. There is a watermark that the cpu attempts to keep in the private
pool. The private pool, when empty, pulls from a global pool from the
cpu. When the cpu's global pool is empty it will pull from other cpu's
global pool. As there many cpu global pools (1 per cpu or hardware queue
count) and as each cpu selects what cpu to pull from at different rates and
at different times, it creates a radomizing effect that minimizes the
number of cpu's that will contend with each other when the steal XRI's from
another cpu's global pool.
On io completion, a cpu will push the XRI back on to its private pool. A
watermark level is maintained for the private pool such that when it is
exceeded it will move XRI's to the CPU global pool so that other cpu's may
allocate them.
On NVME, as heartbeat commands are critical to get placed on the wire, a
single expedite pool is maintained. When a heartbeat is to be sent, it will
allocate an XRI from the expedite pool rather than the normal cpu
private/global pools. On any io completion, if a reduction in the expedite
pools is seen, it will be replenished before the XRI is placed on the cpu
private pool.
Statistics are added to aid understanding the XRI levels on each cpu and
their behaviors.
Signed-off-by: Dick Kennedy <dick.kennedy@broadcom.com>
Signed-off-by: James Smart <jsmart2021@gmail.com>
Reviewed-by: Hannes Reinecke <hare@suse.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-01-29 03:14:28 +08:00
|
|
|
/*
|
|
|
|
|
# lpfc_xri_rebalancing: enable or disable XRI rebalancing feature
|
|
|
|
|
# range is [0,1]. Default value is 1.
|
|
|
|
|
*/
|
|
|
|
|
LPFC_ATTR_R(xri_rebalancing, 1, 0, 1, "Enable/Disable XRI rebalancing");
|
|
|
|
|
|
2012-08-04 00:36:42 +08:00
|
|
|
/*
|
2017-02-13 05:52:30 +08:00
|
|
|
* lpfc_io_sched: Determine scheduling algrithmn for issuing FCP cmds
|
|
|
|
|
* range is [0,1]. Default value is 0.
|
2019-01-29 03:14:29 +08:00
|
|
|
* For [0], FCP commands are issued to Work Queues based on upper layer
|
|
|
|
|
* hardware queue index.
|
2017-02-13 05:52:30 +08:00
|
|
|
* For [1], FCP commands are issued to a Work Queue associated with the
|
|
|
|
|
* current CPU.
|
|
|
|
|
*
|
2019-01-29 03:14:29 +08:00
|
|
|
* LPFC_FCP_SCHED_BY_HDWQ == 0
|
2017-02-13 05:52:30 +08:00
|
|
|
* LPFC_FCP_SCHED_BY_CPU == 1
|
|
|
|
|
*
|
|
|
|
|
* The driver dynamically sets this to 1 (BY_CPU) if it's able to set up cpu
|
|
|
|
|
* affinity for FCP/NVME I/Os through Work Queues associated with the current
|
|
|
|
|
* CPU. Otherwise, the default 0 (Round Robin) scheduling of FCP/NVME I/Os
|
|
|
|
|
* through WQs will be used.
|
|
|
|
|
*/
|
2019-01-29 03:14:31 +08:00
|
|
|
LPFC_ATTR_RW(fcp_io_sched, LPFC_FCP_SCHED_BY_CPU,
|
2019-01-29 03:14:29 +08:00
|
|
|
LPFC_FCP_SCHED_BY_HDWQ,
|
2017-02-13 05:52:30 +08:00
|
|
|
LPFC_FCP_SCHED_BY_CPU,
|
|
|
|
|
"Determine scheduling algorithm for "
|
2019-01-29 03:14:29 +08:00
|
|
|
"issuing commands [0] - Hardware Queue, [1] - Current CPU");
|
2012-08-04 00:36:42 +08:00
|
|
|
|
2018-10-24 04:41:10 +08:00
|
|
|
/*
|
|
|
|
|
* lpfc_ns_query: Determine algrithmn for NameServer queries after RSCN
|
|
|
|
|
* range is [0,1]. Default value is 0.
|
|
|
|
|
* For [0], GID_FT is used for NameServer queries after RSCN (default)
|
|
|
|
|
* For [1], GID_PT is used for NameServer queries after RSCN
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
LPFC_ATTR_RW(ns_query, LPFC_NS_QUERY_GID_FT,
|
|
|
|
|
LPFC_NS_QUERY_GID_FT, LPFC_NS_QUERY_GID_PT,
|
|
|
|
|
"Determine algorithm NameServer queries after RSCN "
|
|
|
|
|
"[0] - GID_FT, [1] - GID_PT");
|
|
|
|
|
|
2012-11-01 02:44:42 +08:00
|
|
|
/*
|
|
|
|
|
# lpfc_fcp2_no_tgt_reset: Determine bus reset behavior
|
|
|
|
|
# range is [0,1]. Default value is 0.
|
|
|
|
|
# For [0], bus reset issues target reset to ALL devices
|
|
|
|
|
# For [1], bus reset issues target reset to non-FCP2 devices
|
|
|
|
|
*/
|
|
|
|
|
LPFC_ATTR_RW(fcp2_no_tgt_reset, 0, 0, 1, "Determine bus reset behavior for "
|
|
|
|
|
"FCP2 devices [0] - issue tgt reset, [1] - no tgt reset");
|
|
|
|
|
|
|
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
/*
|
|
|
|
|
# lpfc_cr_delay & lpfc_cr_count: Default values for I/O colaesing
|
|
|
|
|
# cr_delay (msec) or cr_count outstanding commands. cr_delay can take
|
2007-04-25 21:52:34 +08:00
|
|
|
# value [0,63]. cr_count can take value [1,255]. Default value of cr_delay
|
2005-04-18 05:05:31 +08:00
|
|
|
# is 0. Default value of cr_count is 1. The cr_count feature is disabled if
|
|
|
|
|
# cr_delay is set to 0.
|
|
|
|
|
*/
|
2006-03-01 08:25:35 +08:00
|
|
|
LPFC_ATTR_RW(cr_delay, 0, 0, 63, "A count of milliseconds after which an "
|
2005-04-18 05:05:31 +08:00
|
|
|
"interrupt response is generated");
|
|
|
|
|
|
2006-03-01 08:25:35 +08:00
|
|
|
LPFC_ATTR_RW(cr_count, 1, 1, 255, "A count of I/O completions after which an "
|
2005-04-18 05:05:31 +08:00
|
|
|
"interrupt response is generated");
|
|
|
|
|
|
2006-03-01 11:33:08 +08:00
|
|
|
/*
|
|
|
|
|
# lpfc_multi_ring_support: Determines how many rings to spread available
|
|
|
|
|
# cmd/rsp IOCB entries across.
|
|
|
|
|
# Value range is [1,2]. Default value is 1.
|
|
|
|
|
*/
|
|
|
|
|
LPFC_ATTR_R(multi_ring_support, 1, 1, 2, "Determines number of primary "
|
|
|
|
|
"SLI rings to spread IOCB entries across");
|
|
|
|
|
|
2006-12-03 02:34:16 +08:00
|
|
|
/*
|
|
|
|
|
# lpfc_multi_ring_rctl: If lpfc_multi_ring_support is enabled, this
|
|
|
|
|
# identifies what rctl value to configure the additional ring for.
|
|
|
|
|
# Value range is [1,0xff]. Default value is 4 (Unsolicated Data).
|
|
|
|
|
*/
|
2009-10-03 03:16:51 +08:00
|
|
|
LPFC_ATTR_R(multi_ring_rctl, FC_RCTL_DD_UNSOL_DATA, 1,
|
2006-12-03 02:34:16 +08:00
|
|
|
255, "Identifies RCTL for additional ring configuration");
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
# lpfc_multi_ring_type: If lpfc_multi_ring_support is enabled, this
|
|
|
|
|
# identifies what type value to configure the additional ring for.
|
|
|
|
|
# Value range is [1,0xff]. Default value is 5 (LLC/SNAP).
|
|
|
|
|
*/
|
2009-10-03 03:16:51 +08:00
|
|
|
LPFC_ATTR_R(multi_ring_type, FC_TYPE_IP, 1,
|
2006-12-03 02:34:16 +08:00
|
|
|
255, "Identifies TYPE for additional ring configuration");
|
|
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
/*
|
2015-12-17 07:11:58 +08:00
|
|
|
# lpfc_enable_SmartSAN: Sets up FDMI support for SmartSAN
|
|
|
|
|
# 0 = SmartSAN functionality disabled (default)
|
|
|
|
|
# 1 = SmartSAN functionality enabled
|
|
|
|
|
# This parameter will override the value of lpfc_fdmi_on module parameter.
|
|
|
|
|
# Value range is [0,1]. Default value is 0.
|
2005-04-18 05:05:31 +08:00
|
|
|
*/
|
2015-12-17 07:11:58 +08:00
|
|
|
LPFC_ATTR_R(enable_SmartSAN, 0, 0, 1, "Enable SmartSAN functionality");
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
# lpfc_fdmi_on: Controls FDMI support.
|
2018-08-15 03:55:05 +08:00
|
|
|
# 0 No FDMI support
|
|
|
|
|
# 1 Traditional FDMI support (default)
|
2016-04-01 05:12:33 +08:00
|
|
|
# Traditional FDMI support means the driver will assume FDMI-2 support;
|
|
|
|
|
# however, if that fails, it will fallback to FDMI-1.
|
|
|
|
|
# If lpfc_enable_SmartSAN is set to 1, the driver ignores lpfc_fdmi_on.
|
|
|
|
|
# If lpfc_enable_SmartSAN is set 0, the driver uses the current value of
|
|
|
|
|
# lpfc_fdmi_on.
|
2018-08-15 03:55:05 +08:00
|
|
|
# Value range [0,1]. Default value is 1.
|
2015-12-17 07:11:58 +08:00
|
|
|
*/
|
2018-08-15 03:55:05 +08:00
|
|
|
LPFC_ATTR_R(fdmi_on, 1, 0, 1, "Enable FDMI support");
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
# Specifies the maximum number of ELS cmds we can have outstanding (for
|
|
|
|
|
# discovery). Value range is [1,64]. Default value = 32.
|
|
|
|
|
*/
|
2007-08-02 23:09:59 +08:00
|
|
|
LPFC_VPORT_ATTR(discovery_threads, 32, 1, 64, "Maximum number of ELS commands "
|
2005-04-18 05:05:31 +08:00
|
|
|
"during discovery");
|
|
|
|
|
|
|
|
|
|
/*
|
2013-06-01 05:04:59 +08:00
|
|
|
# lpfc_max_luns: maximum allowed LUN ID. This is the highest LUN ID that
|
|
|
|
|
# will be scanned by the SCSI midlayer when sequential scanning is
|
|
|
|
|
# used; and is also the highest LUN ID allowed when the SCSI midlayer
|
|
|
|
|
# parses REPORT_LUN responses. The lpfc driver has no LUN count or
|
|
|
|
|
# LUN ID limit, but the SCSI midlayer requires this field for the uses
|
|
|
|
|
# above. The lpfc driver limits the default value to 255 for two reasons.
|
|
|
|
|
# As it bounds the sequential scan loop, scanning for thousands of luns
|
|
|
|
|
# on a target can take minutes of wall clock time. Additionally,
|
|
|
|
|
# there are FC targets, such as JBODs, that only recognize 8-bits of
|
|
|
|
|
# LUN ID. When they receive a value greater than 8 bits, they chop off
|
|
|
|
|
# the high order bits. In other words, they see LUN IDs 0, 256, 512,
|
|
|
|
|
# and so on all as LUN ID 0. This causes the linux kernel, which sees
|
|
|
|
|
# valid responses at each of the LUN IDs, to believe there are multiple
|
|
|
|
|
# devices present, when in fact, there is only 1.
|
|
|
|
|
# A customer that is aware of their target behaviors, and the results as
|
|
|
|
|
# indicated above, is welcome to increase the lpfc_max_luns value.
|
|
|
|
|
# As mentioned, this value is not used by the lpfc driver, only the
|
|
|
|
|
# SCSI midlayer.
|
2006-07-07 03:50:50 +08:00
|
|
|
# Value range is [0,65535]. Default value is 255.
|
|
|
|
|
# NOTE: The SCSI layer might probe all allowed LUN on some old targets.
|
2005-04-18 05:05:31 +08:00
|
|
|
*/
|
2014-06-25 21:27:38 +08:00
|
|
|
LPFC_VPORT_ULL_ATTR_R(max_luns, 255, 0, 65535, "Maximum allowed LUN ID");
|
2005-04-18 05:05:31 +08:00
|
|
|
|
[SCSI] lpfc 8.1.1 : Add polled-mode support
- Add functionality to run in polled mode only. Includes run time
attribute to enable mode.
- Enable runtime writable hba settings for coallescing and delay parameters
Customers have requested a mode in the driver to run strictly polled.
This is generally to support an environment where the server is extremely
loaded and is looking to reclaim some cpu cycles from adapter interrupt
handling.
This patch adds a new "poll" attribute, and the following behavior:
if value is 0 (default):
The driver uses the normal method for i/o completion. It uses the
firmware feature of interrupt coalesing. The firmware allows a
minimum number of i/o completions before an interrupt, or a maximum
time delay between interrupts. By default, the driver sets these
to no delay (disabled) or 1 i/o - meaning coalescing is disabled.
Attributes were provided to change the coalescing values, but it was
a module-load time only and global across all adapters.
This patch allows them to be writable on a per-adapter basis.
if value is 1 :
Interrupts are left enabled, expecting that the user has tuned the
interrupt coalescing values. When this setting is enabled, the driver
will attempt to service completed i/o whenever new i/o is submitted
to the adapter. If the coalescing values are large, and the i/o
generation rate steady, an interrupt will be avoided by servicing
completed i/o prior to the coalescing thresholds kicking in. However,
if the i/o completion load is high enough or i/o generation slow, the
coalescion values will ensure that completed i/o is serviced in a timely
fashion.
if value is 3 :
Turns off FCP i/o interrupts altogether. The coalescing values now have
no effect. A new attribute "poll_tmo" (default 10ms) exists to set
the polling interval for i/o completion. When this setting is enabled,
the driver will attempt to service completed i/o and restart the
interval timer whenever new i/o is submitted. This behavior allows for
servicing of completed i/o sooner than the interval timer, but ensures
that if no i/o is being issued, then the interval timer will kick in
to service the outstanding i/o.
Signed-off-by: James Smart <James.Smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-11-30 05:32:13 +08:00
|
|
|
/*
|
|
|
|
|
# lpfc_poll_tmo: .Milliseconds driver will wait between polling FCP ring.
|
|
|
|
|
# Value range is [1,255], default value is 10.
|
|
|
|
|
*/
|
|
|
|
|
LPFC_ATTR_RW(poll_tmo, 10, 1, 255,
|
|
|
|
|
"Milliseconds driver will wait between polling FCP ring");
|
|
|
|
|
|
2006-12-03 02:34:56 +08:00
|
|
|
/*
|
2013-09-07 00:22:46 +08:00
|
|
|
# lpfc_task_mgmt_tmo: Maximum time to wait for task management commands
|
|
|
|
|
# to complete in seconds. Value range is [5,180], default value is 60.
|
|
|
|
|
*/
|
|
|
|
|
LPFC_ATTR_RW(task_mgmt_tmo, 60, 5, 180,
|
|
|
|
|
"Maximum time to wait for task management commands to complete");
|
|
|
|
|
/*
|
2006-12-03 02:34:56 +08:00
|
|
|
# lpfc_use_msi: Use MSI (Message Signaled Interrupts) in systems that
|
|
|
|
|
# support this feature
|
[SCSI] lpfc: restore MSI-X/MSI support
A Gentoo bug report [1] showed that as of 2.6.31 lpfc only uses INTx interrupts.
This patch restores lpfc's ability to support MSI-X/MSI interrupts that the
"Addition of SLI4 Interface - Base Support" patch [2] broke.
It reestablishes MSI-X as the default interrupt method and in case MSI-X is not
supported lpfc_sli{4,}_enable_intr fallbacks to MSI and then to INTx.
[1]: http://bugs.gentoo.org/show_bug.cgi?id=296319
[2]: commit da0436e915a5c17ee79e72c1bf978a4ebb1cbf4d
[James Smart:
Background:
Nothing Broke. This was intended.
We had originally enabled MSI-X by default, but in qualification within the
last 12 months, we encountered a major catch-22:
There were at least 4 platforms, from 2 major OEMs, that :
- Say they support MSI-X - platform routines work and act as if they do.
- We enable it, generate a test interrupt to check they really do deliver it,
and it works.
- But shortly after attachment, the system hangs or loses interrupts,
resulting in a bad system behavior.
Given the distro's picking up the 2.6.32 kernel, we had to stick with a
default of MSI-X off, with user-enabled MSI-X as these platforms couldn't get
fixed.
However, we're also now encountering platforms that require MSI-X and never
INTx, so we must change. It's desired also for also for performance reasons.
So - now (2.6.33) is the right time to re-enable MSI-X by default.
]
[jejb: fix up comment on default values]
Signed-off-by: George Kadianakis <desnacked@gmail.com>
Acked-by: James Smart <james.smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-01-18 03:19:31 +08:00
|
|
|
# 0 = MSI disabled
|
2006-12-03 02:34:56 +08:00
|
|
|
# 1 = MSI enabled
|
[SCSI] lpfc: restore MSI-X/MSI support
A Gentoo bug report [1] showed that as of 2.6.31 lpfc only uses INTx interrupts.
This patch restores lpfc's ability to support MSI-X/MSI interrupts that the
"Addition of SLI4 Interface - Base Support" patch [2] broke.
It reestablishes MSI-X as the default interrupt method and in case MSI-X is not
supported lpfc_sli{4,}_enable_intr fallbacks to MSI and then to INTx.
[1]: http://bugs.gentoo.org/show_bug.cgi?id=296319
[2]: commit da0436e915a5c17ee79e72c1bf978a4ebb1cbf4d
[James Smart:
Background:
Nothing Broke. This was intended.
We had originally enabled MSI-X by default, but in qualification within the
last 12 months, we encountered a major catch-22:
There were at least 4 platforms, from 2 major OEMs, that :
- Say they support MSI-X - platform routines work and act as if they do.
- We enable it, generate a test interrupt to check they really do deliver it,
and it works.
- But shortly after attachment, the system hangs or loses interrupts,
resulting in a bad system behavior.
Given the distro's picking up the 2.6.32 kernel, we had to stick with a
default of MSI-X off, with user-enabled MSI-X as these platforms couldn't get
fixed.
However, we're also now encountering platforms that require MSI-X and never
INTx, so we must change. It's desired also for also for performance reasons.
So - now (2.6.33) is the right time to re-enable MSI-X by default.
]
[jejb: fix up comment on default values]
Signed-off-by: George Kadianakis <desnacked@gmail.com>
Acked-by: James Smart <james.smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-01-18 03:19:31 +08:00
|
|
|
# 2 = MSI-X enabled (default)
|
|
|
|
|
# Value range is [0,2]. Default value is 2.
|
2006-12-03 02:34:56 +08:00
|
|
|
*/
|
[SCSI] lpfc: restore MSI-X/MSI support
A Gentoo bug report [1] showed that as of 2.6.31 lpfc only uses INTx interrupts.
This patch restores lpfc's ability to support MSI-X/MSI interrupts that the
"Addition of SLI4 Interface - Base Support" patch [2] broke.
It reestablishes MSI-X as the default interrupt method and in case MSI-X is not
supported lpfc_sli{4,}_enable_intr fallbacks to MSI and then to INTx.
[1]: http://bugs.gentoo.org/show_bug.cgi?id=296319
[2]: commit da0436e915a5c17ee79e72c1bf978a4ebb1cbf4d
[James Smart:
Background:
Nothing Broke. This was intended.
We had originally enabled MSI-X by default, but in qualification within the
last 12 months, we encountered a major catch-22:
There were at least 4 platforms, from 2 major OEMs, that :
- Say they support MSI-X - platform routines work and act as if they do.
- We enable it, generate a test interrupt to check they really do deliver it,
and it works.
- But shortly after attachment, the system hangs or loses interrupts,
resulting in a bad system behavior.
Given the distro's picking up the 2.6.32 kernel, we had to stick with a
default of MSI-X off, with user-enabled MSI-X as these platforms couldn't get
fixed.
However, we're also now encountering platforms that require MSI-X and never
INTx, so we must change. It's desired also for also for performance reasons.
So - now (2.6.33) is the right time to re-enable MSI-X by default.
]
[jejb: fix up comment on default values]
Signed-off-by: George Kadianakis <desnacked@gmail.com>
Acked-by: James Smart <james.smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-01-18 03:19:31 +08:00
|
|
|
LPFC_ATTR_R(use_msi, 2, 0, 2, "Use Message Signaled Interrupts (1) or "
|
2008-02-09 07:49:51 +08:00
|
|
|
"MSI-X (2), if possible");
|
2006-12-03 02:34:56 +08:00
|
|
|
|
2012-08-04 00:36:13 +08:00
|
|
|
/*
|
2017-02-13 05:52:34 +08:00
|
|
|
* lpfc_nvme_oas: Use the oas bit when sending NVME/NVMET IOs
|
2017-02-13 05:52:30 +08:00
|
|
|
*
|
|
|
|
|
* 0 = NVME OAS disabled
|
|
|
|
|
* 1 = NVME OAS enabled
|
|
|
|
|
*
|
|
|
|
|
* Value range is [0,1]. Default value is 0.
|
|
|
|
|
*/
|
|
|
|
|
LPFC_ATTR_RW(nvme_oas, 0, 0, 1,
|
|
|
|
|
"Use OAS bit on NVME IOs");
|
|
|
|
|
|
2018-02-23 00:18:50 +08:00
|
|
|
/*
|
|
|
|
|
* lpfc_nvme_embed_cmd: Use the oas bit when sending NVME/NVMET IOs
|
|
|
|
|
*
|
|
|
|
|
* 0 = Put NVME Command in SGL
|
|
|
|
|
* 1 = Embed NVME Command in WQE (unless G7)
|
|
|
|
|
* 2 = Embed NVME Command in WQE (force)
|
|
|
|
|
*
|
|
|
|
|
* Value range is [0,2]. Default value is 1.
|
|
|
|
|
*/
|
|
|
|
|
LPFC_ATTR_RW(nvme_embed_cmd, 1, 0, 2,
|
|
|
|
|
"Embed NVME Command in WQE");
|
|
|
|
|
|
scsi: lpfc: Mitigate high memory pre-allocation by SCSI-MQ
When SCSI-MQ is enabled, the SCSI-MQ layers will do pre-allocation of MQ
resources based on shost values set by the driver. In newer cases of the
driver, which attempts to set nr_hw_queues to the cpu count, the
multipliers become excessive, with a single shost having SCSI-MQ
pre-allocation reaching into the multiple GBytes range. NPIV, which
creates additional shosts, only multiply this overhead. On lower-memory
systems, this can exhaust system memory very quickly, resulting in a system
crash or failures in the driver or elsewhere due to low memory conditions.
After testing several scenarios, the situation can be mitigated by limiting
the value set in shost->nr_hw_queues to 4. Although the shost values were
changed, the driver still had per-cpu hardware queues of its own that
allowed parallelization per-cpu. Testing revealed that even with the
smallish number for nr_hw_queues for SCSI-MQ, performance levels remained
near maximum with the within-driver affiinitization.
A module parameter was created to allow the value set for the nr_hw_queues
to be tunable.
Signed-off-by: Dick Kennedy <dick.kennedy@broadcom.com>
Signed-off-by: James Smart <jsmart2021@gmail.com>
Reviewed-by: Ming Lei <ming.lei@redhat.com>
Reviewed-by: Ewan D. Milne <emilne@redhat.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-08-16 10:36:49 +08:00
|
|
|
/*
|
|
|
|
|
* lpfc_fcp_mq_threshold: Set the maximum number of Hardware Queues
|
|
|
|
|
* the driver will advertise it supports to the SCSI layer.
|
|
|
|
|
*
|
|
|
|
|
* 0 = Set nr_hw_queues by the number of CPUs or HW queues.
|
2024-06-12 13:13:20 +08:00
|
|
|
* 1,128 = Manually specify the maximum nr_hw_queue value to be set,
|
scsi: lpfc: Mitigate high memory pre-allocation by SCSI-MQ
When SCSI-MQ is enabled, the SCSI-MQ layers will do pre-allocation of MQ
resources based on shost values set by the driver. In newer cases of the
driver, which attempts to set nr_hw_queues to the cpu count, the
multipliers become excessive, with a single shost having SCSI-MQ
pre-allocation reaching into the multiple GBytes range. NPIV, which
creates additional shosts, only multiply this overhead. On lower-memory
systems, this can exhaust system memory very quickly, resulting in a system
crash or failures in the driver or elsewhere due to low memory conditions.
After testing several scenarios, the situation can be mitigated by limiting
the value set in shost->nr_hw_queues to 4. Although the shost values were
changed, the driver still had per-cpu hardware queues of its own that
allowed parallelization per-cpu. Testing revealed that even with the
smallish number for nr_hw_queues for SCSI-MQ, performance levels remained
near maximum with the within-driver affiinitization.
A module parameter was created to allow the value set for the nr_hw_queues
to be tunable.
Signed-off-by: Dick Kennedy <dick.kennedy@broadcom.com>
Signed-off-by: James Smart <jsmart2021@gmail.com>
Reviewed-by: Ming Lei <ming.lei@redhat.com>
Reviewed-by: Ewan D. Milne <emilne@redhat.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-08-16 10:36:49 +08:00
|
|
|
*
|
2019-08-28 05:28:23 +08:00
|
|
|
* Value range is [0,256]. Default value is 8.
|
scsi: lpfc: Mitigate high memory pre-allocation by SCSI-MQ
When SCSI-MQ is enabled, the SCSI-MQ layers will do pre-allocation of MQ
resources based on shost values set by the driver. In newer cases of the
driver, which attempts to set nr_hw_queues to the cpu count, the
multipliers become excessive, with a single shost having SCSI-MQ
pre-allocation reaching into the multiple GBytes range. NPIV, which
creates additional shosts, only multiply this overhead. On lower-memory
systems, this can exhaust system memory very quickly, resulting in a system
crash or failures in the driver or elsewhere due to low memory conditions.
After testing several scenarios, the situation can be mitigated by limiting
the value set in shost->nr_hw_queues to 4. Although the shost values were
changed, the driver still had per-cpu hardware queues of its own that
allowed parallelization per-cpu. Testing revealed that even with the
smallish number for nr_hw_queues for SCSI-MQ, performance levels remained
near maximum with the within-driver affiinitization.
A module parameter was created to allow the value set for the nr_hw_queues
to be tunable.
Signed-off-by: Dick Kennedy <dick.kennedy@broadcom.com>
Signed-off-by: James Smart <jsmart2021@gmail.com>
Reviewed-by: Ming Lei <ming.lei@redhat.com>
Reviewed-by: Ewan D. Milne <emilne@redhat.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-08-16 10:36:49 +08:00
|
|
|
*/
|
|
|
|
|
LPFC_ATTR_R(fcp_mq_threshold, LPFC_FCP_MQ_THRESHOLD_DEF,
|
|
|
|
|
LPFC_FCP_MQ_THRESHOLD_MIN, LPFC_FCP_MQ_THRESHOLD_MAX,
|
|
|
|
|
"Set the number of SCSI Queues advertised");
|
|
|
|
|
|
2017-02-13 05:52:30 +08:00
|
|
|
/*
|
2019-01-29 03:14:31 +08:00
|
|
|
* lpfc_hdw_queue: Set the number of Hardware Queues the driver
|
scsi: lpfc: Replace io_channels for nvme and fcp with general hdw_queues per cpu
Currently, both nvme and fcp each have their own concept of an io_channel,
which is a combination wq/cq and associated msix. Different cpus would
share an io_channel.
The driver is now moving to per-cpu wq/cq pairs and msix vectors. The
driver will still use separate wq/cq pairs per protocol on each cpu, but
the protocols will share the msix vector.
Given the elimination of the nvme and fcp io channels, the module
parameters will be removed. A new parameter, lpfc_hdw_queue is added which
allows the wq/cq pair allocation per cpu to be overridden and allocated to
lesser value. If lpfc_hdw_queue is zero, the number of pairs allocated will
be based on the number of cpus. If non-zero, the parameter specifies the
number of queues to allocate. At this time, the maximum non-zero value is
64.
To manage this new paradigm, a new hardware queue structure is created to
track queue activity and relationships.
As MSIX vector allocation must be known before setting up the
relationships, msix allocation now occurs before queue datastructures are
allocated. If the number of vectors allocated is less than the desired
hardware queues, the hardware queue counts will be reduced to the number of
vectors
Signed-off-by: Dick Kennedy <dick.kennedy@broadcom.com>
Signed-off-by: James Smart <jsmart2021@gmail.com>
Reviewed-by: Hannes Reinecke <hare@suse.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-01-29 03:14:21 +08:00
|
|
|
* will advertise it supports to the NVME and SCSI layers. This also
|
2019-01-29 03:14:31 +08:00
|
|
|
* will map to the number of CQ/WQ pairs the driver will create.
|
2017-02-13 05:52:30 +08:00
|
|
|
*
|
|
|
|
|
* The NVME Layer will try to create this many, plus 1 administrative
|
|
|
|
|
* hardware queue. The administrative queue will always map to WQ 0
|
2019-01-29 03:14:31 +08:00
|
|
|
* A hardware IO queue maps (qidx) to a specific driver CQ/WQ.
|
2017-02-13 05:52:30 +08:00
|
|
|
*
|
scsi: lpfc: Replace io_channels for nvme and fcp with general hdw_queues per cpu
Currently, both nvme and fcp each have their own concept of an io_channel,
which is a combination wq/cq and associated msix. Different cpus would
share an io_channel.
The driver is now moving to per-cpu wq/cq pairs and msix vectors. The
driver will still use separate wq/cq pairs per protocol on each cpu, but
the protocols will share the msix vector.
Given the elimination of the nvme and fcp io channels, the module
parameters will be removed. A new parameter, lpfc_hdw_queue is added which
allows the wq/cq pair allocation per cpu to be overridden and allocated to
lesser value. If lpfc_hdw_queue is zero, the number of pairs allocated will
be based on the number of cpus. If non-zero, the parameter specifies the
number of queues to allocate. At this time, the maximum non-zero value is
64.
To manage this new paradigm, a new hardware queue structure is created to
track queue activity and relationships.
As MSIX vector allocation must be known before setting up the
relationships, msix allocation now occurs before queue datastructures are
allocated. If the number of vectors allocated is less than the desired
hardware queues, the hardware queue counts will be reduced to the number of
vectors
Signed-off-by: Dick Kennedy <dick.kennedy@broadcom.com>
Signed-off-by: James Smart <jsmart2021@gmail.com>
Reviewed-by: Hannes Reinecke <hare@suse.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-01-29 03:14:21 +08:00
|
|
|
* 0 = Configure the number of hdw queues to the number of active CPUs.
|
2024-06-12 13:13:20 +08:00
|
|
|
* 1,128 = Manually specify how many hdw queues to use.
|
2017-02-13 05:52:30 +08:00
|
|
|
*
|
2024-06-12 13:13:20 +08:00
|
|
|
* Value range is [0,128]. Default value is 0.
|
2017-02-13 05:52:30 +08:00
|
|
|
*/
|
scsi: lpfc: Replace io_channels for nvme and fcp with general hdw_queues per cpu
Currently, both nvme and fcp each have their own concept of an io_channel,
which is a combination wq/cq and associated msix. Different cpus would
share an io_channel.
The driver is now moving to per-cpu wq/cq pairs and msix vectors. The
driver will still use separate wq/cq pairs per protocol on each cpu, but
the protocols will share the msix vector.
Given the elimination of the nvme and fcp io channels, the module
parameters will be removed. A new parameter, lpfc_hdw_queue is added which
allows the wq/cq pair allocation per cpu to be overridden and allocated to
lesser value. If lpfc_hdw_queue is zero, the number of pairs allocated will
be based on the number of cpus. If non-zero, the parameter specifies the
number of queues to allocate. At this time, the maximum non-zero value is
64.
To manage this new paradigm, a new hardware queue structure is created to
track queue activity and relationships.
As MSIX vector allocation must be known before setting up the
relationships, msix allocation now occurs before queue datastructures are
allocated. If the number of vectors allocated is less than the desired
hardware queues, the hardware queue counts will be reduced to the number of
vectors
Signed-off-by: Dick Kennedy <dick.kennedy@broadcom.com>
Signed-off-by: James Smart <jsmart2021@gmail.com>
Reviewed-by: Hannes Reinecke <hare@suse.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-01-29 03:14:21 +08:00
|
|
|
LPFC_ATTR_R(hdw_queue,
|
|
|
|
|
LPFC_HBA_HDWQ_DEF,
|
|
|
|
|
LPFC_HBA_HDWQ_MIN, LPFC_HBA_HDWQ_MAX,
|
|
|
|
|
"Set the number of I/O Hardware Queues");
|
2017-02-13 05:52:30 +08:00
|
|
|
|
2019-01-29 03:14:31 +08:00
|
|
|
/*
|
|
|
|
|
* lpfc_irq_chann: Set the number of IRQ vectors that are available
|
|
|
|
|
* for Hardware Queues to utilize. This also will map to the number
|
|
|
|
|
* of EQ / MSI-X vectors the driver will create. This should never be
|
|
|
|
|
* more than the number of Hardware Queues
|
|
|
|
|
*
|
2024-06-12 13:13:20 +08:00
|
|
|
* 0 = Configure number of IRQ Channels to the number of active CPUs.
|
|
|
|
|
* 1,128 = Manually specify how many IRQ Channels to use.
|
2019-01-29 03:14:31 +08:00
|
|
|
*
|
2024-06-12 13:13:20 +08:00
|
|
|
* Value range is [0,128]. Default value is 0.
|
2019-01-29 03:14:31 +08:00
|
|
|
*/
|
2024-06-12 13:13:20 +08:00
|
|
|
LPFC_ATTR_R(irq_chann,
|
|
|
|
|
LPFC_HBA_HDWQ_DEF,
|
|
|
|
|
LPFC_HBA_HDWQ_MIN, LPFC_HBA_HDWQ_MAX,
|
|
|
|
|
"Set the number of I/O IRQ Channels");
|
2019-01-29 03:14:31 +08:00
|
|
|
|
2008-01-11 14:52:48 +08:00
|
|
|
/*
|
|
|
|
|
# lpfc_enable_hba_reset: Allow or prevent HBA resets to the hardware.
|
|
|
|
|
# 0 = HBA resets disabled
|
|
|
|
|
# 1 = HBA resets enabled (default)
|
2018-12-14 07:17:57 +08:00
|
|
|
# 2 = HBA reset via PCI bus reset enabled
|
|
|
|
|
# Value range is [0,2]. Default value is 1.
|
2008-01-11 14:52:48 +08:00
|
|
|
*/
|
2018-12-14 07:17:57 +08:00
|
|
|
LPFC_ATTR_RW(enable_hba_reset, 1, 0, 2, "Enable HBA resets from the driver.");
|
2006-08-19 05:47:18 +08:00
|
|
|
|
2008-01-11 14:52:48 +08:00
|
|
|
/*
|
2010-11-21 12:12:02 +08:00
|
|
|
# lpfc_enable_hba_heartbeat: Disable HBA heartbeat timer..
|
2008-01-11 14:52:48 +08:00
|
|
|
# 0 = HBA Heartbeat disabled
|
|
|
|
|
# 1 = HBA Heartbeat enabled (default)
|
|
|
|
|
# Value range is [0,1]. Default value is 1.
|
|
|
|
|
*/
|
2010-11-21 12:12:02 +08:00
|
|
|
LPFC_ATTR_R(enable_hba_heartbeat, 0, 0, 1, "Enable HBA Heartbeat.");
|
2007-06-18 08:56:38 +08:00
|
|
|
|
2014-02-20 22:56:45 +08:00
|
|
|
/*
|
|
|
|
|
# lpfc_EnableXLane: Enable Express Lane Feature
|
|
|
|
|
# 0x0 Express Lane Feature disabled
|
|
|
|
|
# 0x1 Express Lane Feature enabled
|
|
|
|
|
# Value range is [0,1]. Default value is 0.
|
|
|
|
|
*/
|
|
|
|
|
LPFC_ATTR_R(EnableXLane, 0, 0, 1, "Enable Express Lane Feature.");
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
# lpfc_XLanePriority: Define CS_CTL priority for Express Lane Feature
|
|
|
|
|
# 0x0 - 0x7f = CS_CTL field in FC header (high 7 bits)
|
|
|
|
|
# Value range is [0x0,0x7f]. Default value is 0
|
|
|
|
|
*/
|
2014-05-21 20:05:28 +08:00
|
|
|
LPFC_ATTR_RW(XLanePriority, 0, 0x0, 0x7f, "CS_CTL for Express Lane Feature.");
|
2014-02-20 22:56:45 +08:00
|
|
|
|
2008-12-05 11:39:46 +08:00
|
|
|
/*
|
|
|
|
|
# lpfc_enable_bg: Enable BlockGuard (Emulex's Implementation of T10-DIF)
|
|
|
|
|
# 0 = BlockGuard disabled (default)
|
|
|
|
|
# 1 = BlockGuard enabled
|
|
|
|
|
# Value range is [0,1]. Default value is 0.
|
|
|
|
|
*/
|
|
|
|
|
LPFC_ATTR_R(enable_bg, 0, 0, 1, "Enable BlockGuard Support");
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
# lpfc_prot_mask: i
|
|
|
|
|
# - Bit mask of host protection capabilities used to register with the
|
|
|
|
|
# SCSI mid-layer
|
2024-06-12 13:13:20 +08:00
|
|
|
# - Only meaningful if BG is turned on (lpfc_enable_bg=1).
|
2008-12-05 11:39:46 +08:00
|
|
|
# - Allows you to ultimately specify which profiles to use
|
|
|
|
|
# - Default will result in registering capabilities for all profiles.
|
2012-09-29 23:29:17 +08:00
|
|
|
# - SHOST_DIF_TYPE1_PROTECTION 1
|
|
|
|
|
# HBA supports T10 DIF Type 1: HBA to Target Type 1 Protection
|
|
|
|
|
# - SHOST_DIX_TYPE0_PROTECTION 8
|
|
|
|
|
# HBA supports DIX Type 0: Host to HBA protection only
|
|
|
|
|
# - SHOST_DIX_TYPE1_PROTECTION 16
|
|
|
|
|
# HBA supports DIX Type 1: Host to HBA Type 1 protection
|
2008-12-05 11:39:46 +08:00
|
|
|
#
|
|
|
|
|
*/
|
2016-10-14 06:06:06 +08:00
|
|
|
LPFC_ATTR(prot_mask,
|
|
|
|
|
(SHOST_DIF_TYPE1_PROTECTION |
|
|
|
|
|
SHOST_DIX_TYPE0_PROTECTION |
|
|
|
|
|
SHOST_DIX_TYPE1_PROTECTION),
|
|
|
|
|
0,
|
|
|
|
|
(SHOST_DIF_TYPE1_PROTECTION |
|
|
|
|
|
SHOST_DIX_TYPE0_PROTECTION |
|
|
|
|
|
SHOST_DIX_TYPE1_PROTECTION),
|
|
|
|
|
"T10-DIF host protection capabilities mask");
|
2008-12-05 11:39:46 +08:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
# lpfc_prot_guard: i
|
|
|
|
|
# - Bit mask of protection guard types to register with the SCSI mid-layer
|
2012-09-29 23:29:17 +08:00
|
|
|
# - Guard types are currently either 1) T10-DIF CRC 2) IP checksum
|
2008-12-05 11:39:46 +08:00
|
|
|
# - Allows you to ultimately specify which profiles to use
|
|
|
|
|
# - Default will result in registering capabilities for all guard types
|
|
|
|
|
#
|
|
|
|
|
*/
|
2016-10-14 06:06:06 +08:00
|
|
|
LPFC_ATTR(prot_guard,
|
|
|
|
|
SHOST_DIX_GUARD_IP, SHOST_DIX_GUARD_CRC, SHOST_DIX_GUARD_IP,
|
|
|
|
|
"T10-DIF host protection guard type");
|
2008-12-05 11:39:46 +08:00
|
|
|
|
2011-02-17 01:39:44 +08:00
|
|
|
/*
|
|
|
|
|
* Delay initial NPort discovery when Clean Address bit is cleared in
|
|
|
|
|
* FLOGI/FDISC accept and FCID/Fabric name/Fabric portname is changed.
|
|
|
|
|
* This parameter can have value 0 or 1.
|
|
|
|
|
* When this parameter is set to 0, no delay is added to the initial
|
|
|
|
|
* discovery.
|
|
|
|
|
* When this parameter is set to non-zero value, initial Nport discovery is
|
|
|
|
|
* delayed by ra_tov seconds when Clean Address bit is cleared in FLOGI/FDISC
|
|
|
|
|
* accept and FCID/Fabric name/Fabric portname is changed.
|
|
|
|
|
* Driver always delay Nport discovery for subsequent FLOGI/FDISC completion
|
|
|
|
|
* when Clean Address bit is cleared in FLOGI/FDISC
|
|
|
|
|
* accept and FCID/Fabric name/Fabric portname is changed.
|
|
|
|
|
* Default value is 0.
|
|
|
|
|
*/
|
2016-07-07 03:36:08 +08:00
|
|
|
LPFC_ATTR(delay_discovery, 0, 0, 1,
|
|
|
|
|
"Delay NPort discovery when Clean Address bit is cleared.");
|
2008-12-05 11:39:46 +08:00
|
|
|
|
2008-01-11 14:53:09 +08:00
|
|
|
/*
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_sg_seg_cnt - Initial Maximum DMA Segment Count
|
2018-09-11 01:30:42 +08:00
|
|
|
* This value can be set to values between 64 and 4096. The default value
|
|
|
|
|
* is 64, but may be increased to allow for larger Max I/O sizes. The scsi
|
|
|
|
|
* and nvme layers will allow I/O sizes up to (MAX_SEG_COUNT * SEG_SIZE).
|
2013-04-18 08:16:15 +08:00
|
|
|
* Because of the additional overhead involved in setting up T10-DIF,
|
|
|
|
|
* this parameter will be limited to 128 if BlockGuard is enabled under SLI4
|
|
|
|
|
* and will be limited to 512 if BlockGuard is enabled under SLI3.
|
2008-01-11 14:53:09 +08:00
|
|
|
*/
|
2018-09-11 01:30:42 +08:00
|
|
|
static uint lpfc_sg_seg_cnt = LPFC_DEFAULT_SG_SEG_CNT;
|
|
|
|
|
module_param(lpfc_sg_seg_cnt, uint, 0444);
|
|
|
|
|
MODULE_PARM_DESC(lpfc_sg_seg_cnt, "Max Scatter Gather Segment Count");
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* lpfc_sg_seg_cnt_show - Display the scatter/gather list sizes
|
|
|
|
|
* configured for the adapter
|
|
|
|
|
* @dev: class converted to a Scsi_host structure.
|
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
|
* @buf: on return contains a string with the list sizes
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
|
|
|
|
static ssize_t
|
|
|
|
|
lpfc_sg_seg_cnt_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
|
|
|
|
{
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
int len;
|
|
|
|
|
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
len = scnprintf(buf, PAGE_SIZE, "SGL sz: %d total SGEs: %d\n",
|
2018-09-11 01:30:42 +08:00
|
|
|
phba->cfg_sg_dma_buf_size, phba->cfg_total_seg_cnt);
|
|
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
len += scnprintf(buf + len, PAGE_SIZE - len,
|
|
|
|
|
"Cfg: %d SCSI: %d NVME: %d\n",
|
2018-09-11 01:30:42 +08:00
|
|
|
phba->cfg_sg_seg_cnt, phba->cfg_scsi_seg_cnt,
|
|
|
|
|
phba->cfg_nvme_seg_cnt);
|
|
|
|
|
return len;
|
|
|
|
|
}
|
|
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
static DEVICE_ATTR_RO(lpfc_sg_seg_cnt);
|
2018-09-11 01:30:42 +08:00
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* lpfc_sg_seg_cnt_init - Set the hba sg_seg_cnt initial value
|
|
|
|
|
* @phba: lpfc_hba pointer.
|
|
|
|
|
* @val: contains the initial value
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* Validates the initial value is within range and assigns it to the
|
|
|
|
|
* adapter. If not in range, an error message is posted and the
|
|
|
|
|
* default value is assigned.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* zero if value is in range and is set
|
|
|
|
|
* -EINVAL if value was out of range
|
|
|
|
|
**/
|
|
|
|
|
static int
|
|
|
|
|
lpfc_sg_seg_cnt_init(struct lpfc_hba *phba, int val)
|
|
|
|
|
{
|
|
|
|
|
if (val >= LPFC_MIN_SG_SEG_CNT && val <= LPFC_MAX_SG_SEG_CNT) {
|
|
|
|
|
phba->cfg_sg_seg_cnt = val;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
|
|
|
|
|
"0409 "LPFC_DRIVER_NAME"_sg_seg_cnt attribute cannot "
|
|
|
|
|
"be set to %d, allowed range is [%d, %d]\n",
|
|
|
|
|
val, LPFC_MIN_SG_SEG_CNT, LPFC_MAX_SG_SEG_CNT);
|
|
|
|
|
phba->cfg_sg_seg_cnt = LPFC_DEFAULT_SG_SEG_CNT;
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
2008-01-11 14:53:09 +08:00
|
|
|
|
2016-07-07 03:36:00 +08:00
|
|
|
/*
|
|
|
|
|
* lpfc_enable_mds_diags: Enable MDS Diagnostics
|
|
|
|
|
* 0 = MDS Diagnostics disabled (default)
|
|
|
|
|
* 1 = MDS Diagnostics enabled
|
|
|
|
|
* Value range is [0,1]. Default value is 0.
|
|
|
|
|
*/
|
2019-08-15 07:57:08 +08:00
|
|
|
LPFC_ATTR_RW(enable_mds_diags, 0, 0, 1, "Enable MDS Diagnostics");
|
2016-07-07 03:36:00 +08:00
|
|
|
|
2018-09-11 01:30:50 +08:00
|
|
|
/*
|
|
|
|
|
* lpfc_ras_fwlog_buffsize: Firmware logging host buffer size
|
|
|
|
|
* 0 = Disable firmware logging (default)
|
|
|
|
|
* [1-4] = Multiple of 1/4th Mb of host memory for FW logging
|
|
|
|
|
* Value range [0..4]. Default value is 0
|
|
|
|
|
*/
|
2024-06-12 13:13:20 +08:00
|
|
|
LPFC_ATTR_RW(ras_fwlog_buffsize, 0, 0, 4, "Host memory for FW logging");
|
2018-09-11 01:30:50 +08:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* lpfc_ras_fwlog_level: Firmware logging verbosity level
|
|
|
|
|
* Valid only if firmware logging is enabled
|
|
|
|
|
* 0(Least Verbosity) 4 (most verbosity)
|
|
|
|
|
* Value range is [0..4]. Default value is 0
|
|
|
|
|
*/
|
|
|
|
|
LPFC_ATTR_RW(ras_fwlog_level, 0, 0, 4, "Firmware Logging Level");
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* lpfc_ras_fwlog_func: Firmware logging enabled on function number
|
|
|
|
|
* Default function which has RAS support : 0
|
|
|
|
|
* Value Range is [0..7].
|
|
|
|
|
* FW logging is a global action and enablement is via a specific
|
|
|
|
|
* port.
|
|
|
|
|
*/
|
|
|
|
|
LPFC_ATTR_RW(ras_fwlog_func, 0, 0, 7, "Firmware Logging Enabled on Function");
|
|
|
|
|
|
2017-08-24 07:55:47 +08:00
|
|
|
/*
|
|
|
|
|
* lpfc_enable_bbcr: Enable BB Credit Recovery
|
|
|
|
|
* 0 = BB Credit Recovery disabled
|
|
|
|
|
* 1 = BB Credit Recovery enabled (default)
|
|
|
|
|
* Value range is [0,1]. Default value is 1.
|
|
|
|
|
*/
|
|
|
|
|
LPFC_BBCR_ATTR_RW(enable_bbcr, 1, 0, 1, "Enable BBC Recovery");
|
|
|
|
|
|
2018-02-23 00:18:43 +08:00
|
|
|
/*
|
|
|
|
|
* lpfc_enable_dpp: Enable DPP on G7
|
|
|
|
|
* 0 = DPP on G7 disabled
|
|
|
|
|
* 1 = DPP on G7 enabled (default)
|
2024-06-12 13:13:20 +08:00
|
|
|
* Value range is [0,1]. Default value is 1.
|
2018-02-23 00:18:43 +08:00
|
|
|
*/
|
|
|
|
|
LPFC_ATTR_RW(enable_dpp, 1, 0, 1, "Enable Direct Packet Push");
|
|
|
|
|
|
2008-02-22 07:13:36 +08:00
|
|
|
struct device_attribute *lpfc_hba_attrs[] = {
|
2017-02-13 05:52:30 +08:00
|
|
|
&dev_attr_nvme_info,
|
2019-01-29 03:14:25 +08:00
|
|
|
&dev_attr_scsi_stat,
|
2008-12-05 11:39:46 +08:00
|
|
|
&dev_attr_bg_info,
|
|
|
|
|
&dev_attr_bg_guard_err,
|
|
|
|
|
&dev_attr_bg_apptag_err,
|
|
|
|
|
&dev_attr_bg_reftag_err,
|
2008-02-22 07:13:36 +08:00
|
|
|
&dev_attr_info,
|
|
|
|
|
&dev_attr_serialnum,
|
|
|
|
|
&dev_attr_modeldesc,
|
|
|
|
|
&dev_attr_modelname,
|
|
|
|
|
&dev_attr_programtype,
|
|
|
|
|
&dev_attr_portnum,
|
|
|
|
|
&dev_attr_fwrev,
|
|
|
|
|
&dev_attr_hdw,
|
|
|
|
|
&dev_attr_option_rom_version,
|
2008-03-18 21:32:28 +08:00
|
|
|
&dev_attr_link_state,
|
2008-02-22 07:13:36 +08:00
|
|
|
&dev_attr_num_discovered_ports,
|
2008-08-25 09:50:06 +08:00
|
|
|
&dev_attr_menlo_mgmt_mode,
|
2008-02-22 07:13:36 +08:00
|
|
|
&dev_attr_lpfc_drvr_version,
|
2009-10-03 03:17:02 +08:00
|
|
|
&dev_attr_lpfc_enable_fip,
|
2008-02-22 07:13:36 +08:00
|
|
|
&dev_attr_lpfc_temp_sensor,
|
|
|
|
|
&dev_attr_lpfc_log_verbose,
|
|
|
|
|
&dev_attr_lpfc_lun_queue_depth,
|
2010-07-15 03:32:10 +08:00
|
|
|
&dev_attr_lpfc_tgt_queue_depth,
|
2008-02-22 07:13:36 +08:00
|
|
|
&dev_attr_lpfc_hba_queue_depth,
|
|
|
|
|
&dev_attr_lpfc_peer_port_login,
|
|
|
|
|
&dev_attr_lpfc_nodev_tmo,
|
|
|
|
|
&dev_attr_lpfc_devloss_tmo,
|
2017-02-13 05:52:30 +08:00
|
|
|
&dev_attr_lpfc_enable_fc4_type,
|
2008-02-22 07:13:36 +08:00
|
|
|
&dev_attr_lpfc_fcp_class,
|
|
|
|
|
&dev_attr_lpfc_use_adisc,
|
2013-07-16 06:35:04 +08:00
|
|
|
&dev_attr_lpfc_first_burst_size,
|
2008-02-22 07:13:36 +08:00
|
|
|
&dev_attr_lpfc_ack0,
|
scsi: lpfc: Adapt partitioned XRI lists to efficient sharing
The XRI get/put lists were partitioned per hardware queue. However, the
adapter rarely had sufficient resources to give a large number of resources
per queue. As such, it became common for a cpu to encounter a lack of XRI
resource and request the upper io stack to retry after returning a BUSY
condition. This occurred even though other cpus were idle and not using
their resources.
Create as efficient a scheme as possible to move resources to the cpus that
need them. Each cpu maintains a small private pool which it allocates from
for io. There is a watermark that the cpu attempts to keep in the private
pool. The private pool, when empty, pulls from a global pool from the
cpu. When the cpu's global pool is empty it will pull from other cpu's
global pool. As there many cpu global pools (1 per cpu or hardware queue
count) and as each cpu selects what cpu to pull from at different rates and
at different times, it creates a radomizing effect that minimizes the
number of cpu's that will contend with each other when the steal XRI's from
another cpu's global pool.
On io completion, a cpu will push the XRI back on to its private pool. A
watermark level is maintained for the private pool such that when it is
exceeded it will move XRI's to the CPU global pool so that other cpu's may
allocate them.
On NVME, as heartbeat commands are critical to get placed on the wire, a
single expedite pool is maintained. When a heartbeat is to be sent, it will
allocate an XRI from the expedite pool rather than the normal cpu
private/global pools. On any io completion, if a reduction in the expedite
pools is seen, it will be replenished before the XRI is placed on the cpu
private pool.
Statistics are added to aid understanding the XRI levels on each cpu and
their behaviors.
Signed-off-by: Dick Kennedy <dick.kennedy@broadcom.com>
Signed-off-by: James Smart <jsmart2021@gmail.com>
Reviewed-by: Hannes Reinecke <hare@suse.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-01-29 03:14:28 +08:00
|
|
|
&dev_attr_lpfc_xri_rebalancing,
|
2008-02-22 07:13:36 +08:00
|
|
|
&dev_attr_lpfc_topology,
|
|
|
|
|
&dev_attr_lpfc_scan_down,
|
|
|
|
|
&dev_attr_lpfc_link_speed,
|
2012-08-04 00:36:42 +08:00
|
|
|
&dev_attr_lpfc_fcp_io_sched,
|
2018-10-24 04:41:10 +08:00
|
|
|
&dev_attr_lpfc_ns_query,
|
2012-11-01 02:44:42 +08:00
|
|
|
&dev_attr_lpfc_fcp2_no_tgt_reset,
|
2008-02-22 07:13:36 +08:00
|
|
|
&dev_attr_lpfc_cr_delay,
|
|
|
|
|
&dev_attr_lpfc_cr_count,
|
|
|
|
|
&dev_attr_lpfc_multi_ring_support,
|
|
|
|
|
&dev_attr_lpfc_multi_ring_rctl,
|
|
|
|
|
&dev_attr_lpfc_multi_ring_type,
|
|
|
|
|
&dev_attr_lpfc_fdmi_on,
|
2015-12-17 07:11:58 +08:00
|
|
|
&dev_attr_lpfc_enable_SmartSAN,
|
2008-02-22 07:13:36 +08:00
|
|
|
&dev_attr_lpfc_max_luns,
|
|
|
|
|
&dev_attr_lpfc_enable_npiv,
|
2011-07-23 06:37:52 +08:00
|
|
|
&dev_attr_lpfc_fcf_failover_policy,
|
2010-11-21 12:11:55 +08:00
|
|
|
&dev_attr_lpfc_enable_rrq,
|
2008-02-22 07:13:36 +08:00
|
|
|
&dev_attr_nport_evt_cnt,
|
|
|
|
|
&dev_attr_board_mode,
|
|
|
|
|
&dev_attr_max_vpi,
|
|
|
|
|
&dev_attr_used_vpi,
|
|
|
|
|
&dev_attr_max_rpi,
|
|
|
|
|
&dev_attr_used_rpi,
|
|
|
|
|
&dev_attr_max_xri,
|
|
|
|
|
&dev_attr_used_xri,
|
|
|
|
|
&dev_attr_npiv_info,
|
|
|
|
|
&dev_attr_issue_reset,
|
|
|
|
|
&dev_attr_lpfc_poll,
|
|
|
|
|
&dev_attr_lpfc_poll_tmo,
|
2013-09-07 00:22:46 +08:00
|
|
|
&dev_attr_lpfc_task_mgmt_tmo,
|
2008-02-22 07:13:36 +08:00
|
|
|
&dev_attr_lpfc_use_msi,
|
2017-02-13 05:52:30 +08:00
|
|
|
&dev_attr_lpfc_nvme_oas,
|
2018-02-23 00:18:50 +08:00
|
|
|
&dev_attr_lpfc_nvme_embed_cmd,
|
2009-05-23 02:51:39 +08:00
|
|
|
&dev_attr_lpfc_fcp_imax,
|
2024-06-12 13:13:20 +08:00
|
|
|
&dev_attr_lpfc_force_rscn,
|
scsi: lpfc: Rework EQ/CQ processing to address interrupt coalescing
When driving high iop counts, auto_imax coalescing kicks in and drives the
performance to extremely small iops levels.
There are two issues:
1) auto_imax is enabled by default. The auto algorithm, when iops gets
high, divides the iops by the hdwq count and uses that value to
calculate EQ_Delay. The EQ_Delay is set uniformly on all EQs whether
they have load or not. The EQ_delay is only manipulated every 5s (a
long time). Thus there were large 5s swings of no interrupt delay
followed by large/maximum delay, before repeating.
2) When processing a CQ, the driver got mixed up on the rate of when
to ring the doorbell to keep the chip appraised of the eqe or cqe
consumption as well as how how long to sit in the thread and
process queue entries. Currently, the driver capped its work at
64 entries (very small) and exited/rearmed the CQ. Thus, on heavy
loads, additional overheads were taken to exit and re-enter the
interrupt handler. Worse, if in the large/maximum coalescing
windows,k it could be a while before getting back to servicing.
The issues are corrected by the following:
- A change in defaults. Auto_imax is turned OFF and fcp_imax is set
to 0. Thus all interrupts are immediate.
- Cleanup of field names and their meanings. Existing names were
non-intuitive or used for duplicate things.
- Added max_proc_limit field, to control the length of time the
handlers would service completions.
- Reworked EQ handling:
Added common routine that walks eq, applying notify interval and max
processing limits. Use queue_claimed to claim ownership of the queue
while processing. Always rearm the queue whenever the common routine
is called.
Rework queue element processing, namely to eliminate hba_index vs
host_index. Only one index is necessary. The queue entry can be
marked invalid and the host_index updated immediately after eqe
processing.
After rework, xx_release routines are now DB write functions. Renamed
the routines as such.
Moved lpfc_sli4_eq_flush(), which does similar action, to same area.
Replaced the 2 individual loops that walk an eq with a call to the
common routine.
Slightly revised lpfc_sli4_hba_handle_eqe() calling syntax.
Added per-cpu counters to detect interrupt rates and scale
interrupt coalescing values.
- Reworked CQ handling:
Added common routine that walks cq, applying notify interval and max
processing limits. Use queue_claimed to claim ownership of the queue
while processing. Always rearm the queue whenever the common routine
is called.
Rework queue element processing, namely to eliminate hba_index vs
host_index. Only one index is necessary. The queue entry can be
marked invalid and the host_index updated immediately after cqe
processing.
After rework, xx_release routines are now DB write functions. Renamed
the routines as such.
Replaced the 3 individual loops that walk a cq with a call to the
common routine.
Redefined lpfc_sli4_sp_handle_mcqe() to commong handler definition with
queue reference. Add increment for mbox completion to handler.
- Added a new module/sysfs attribute: lpfc_cq_max_proc_limit To allow
dynamic changing of the CQ max_proc_limit value being used.
Although this leaves an EQ as an immediate interrupt, that interrupt will
only occur if a CQ bound to it is in an armed state and has cqe's to
process. By staying in the cq processing routine longer, high loads will
avoid generating more interrupts as they will only rearm as the processing
thread exits. The immediately interrupt is also beneficial to idle or
lower-processing CQ's as they get serviced immediately without being
penalized by sharing an EQ with a more loaded CQ.
Signed-off-by: Dick Kennedy <dick.kennedy@broadcom.com>
Signed-off-by: James Smart <jsmart2021@gmail.com>
Reviewed-by: Hannes Reinecke <hare@suse.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-01-29 03:14:33 +08:00
|
|
|
&dev_attr_lpfc_cq_poll_threshold,
|
|
|
|
|
&dev_attr_lpfc_cq_max_proc_limit,
|
2013-04-18 08:19:16 +08:00
|
|
|
&dev_attr_lpfc_fcp_cpu_map,
|
scsi: lpfc: Mitigate high memory pre-allocation by SCSI-MQ
When SCSI-MQ is enabled, the SCSI-MQ layers will do pre-allocation of MQ
resources based on shost values set by the driver. In newer cases of the
driver, which attempts to set nr_hw_queues to the cpu count, the
multipliers become excessive, with a single shost having SCSI-MQ
pre-allocation reaching into the multiple GBytes range. NPIV, which
creates additional shosts, only multiply this overhead. On lower-memory
systems, this can exhaust system memory very quickly, resulting in a system
crash or failures in the driver or elsewhere due to low memory conditions.
After testing several scenarios, the situation can be mitigated by limiting
the value set in shost->nr_hw_queues to 4. Although the shost values were
changed, the driver still had per-cpu hardware queues of its own that
allowed parallelization per-cpu. Testing revealed that even with the
smallish number for nr_hw_queues for SCSI-MQ, performance levels remained
near maximum with the within-driver affiinitization.
A module parameter was created to allow the value set for the nr_hw_queues
to be tunable.
Signed-off-by: Dick Kennedy <dick.kennedy@broadcom.com>
Signed-off-by: James Smart <jsmart2021@gmail.com>
Reviewed-by: Ming Lei <ming.lei@redhat.com>
Reviewed-by: Ewan D. Milne <emilne@redhat.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-08-16 10:36:49 +08:00
|
|
|
&dev_attr_lpfc_fcp_mq_threshold,
|
scsi: lpfc: Replace io_channels for nvme and fcp with general hdw_queues per cpu
Currently, both nvme and fcp each have their own concept of an io_channel,
which is a combination wq/cq and associated msix. Different cpus would
share an io_channel.
The driver is now moving to per-cpu wq/cq pairs and msix vectors. The
driver will still use separate wq/cq pairs per protocol on each cpu, but
the protocols will share the msix vector.
Given the elimination of the nvme and fcp io channels, the module
parameters will be removed. A new parameter, lpfc_hdw_queue is added which
allows the wq/cq pair allocation per cpu to be overridden and allocated to
lesser value. If lpfc_hdw_queue is zero, the number of pairs allocated will
be based on the number of cpus. If non-zero, the parameter specifies the
number of queues to allocate. At this time, the maximum non-zero value is
64.
To manage this new paradigm, a new hardware queue structure is created to
track queue activity and relationships.
As MSIX vector allocation must be known before setting up the
relationships, msix allocation now occurs before queue datastructures are
allocated. If the number of vectors allocated is less than the desired
hardware queues, the hardware queue counts will be reduced to the number of
vectors
Signed-off-by: Dick Kennedy <dick.kennedy@broadcom.com>
Signed-off-by: James Smart <jsmart2021@gmail.com>
Reviewed-by: Hannes Reinecke <hare@suse.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-01-29 03:14:21 +08:00
|
|
|
&dev_attr_lpfc_hdw_queue,
|
2019-01-29 03:14:31 +08:00
|
|
|
&dev_attr_lpfc_irq_chann,
|
2017-02-13 05:52:34 +08:00
|
|
|
&dev_attr_lpfc_suppress_rsp,
|
2017-02-13 05:52:35 +08:00
|
|
|
&dev_attr_lpfc_nvmet_mrq,
|
2018-04-10 05:24:24 +08:00
|
|
|
&dev_attr_lpfc_nvmet_mrq_post,
|
2017-02-13 05:52:30 +08:00
|
|
|
&dev_attr_lpfc_nvme_enable_fb,
|
2017-02-13 05:52:35 +08:00
|
|
|
&dev_attr_lpfc_nvmet_fb_size,
|
2008-12-05 11:39:46 +08:00
|
|
|
&dev_attr_lpfc_enable_bg,
|
2024-06-12 13:13:20 +08:00
|
|
|
&dev_attr_lpfc_soft_wwnn,
|
|
|
|
|
&dev_attr_lpfc_soft_wwpn,
|
|
|
|
|
&dev_attr_lpfc_soft_wwn_enable,
|
2008-02-22 07:13:36 +08:00
|
|
|
&dev_attr_lpfc_enable_hba_reset,
|
|
|
|
|
&dev_attr_lpfc_enable_hba_heartbeat,
|
2014-02-20 22:56:45 +08:00
|
|
|
&dev_attr_lpfc_EnableXLane,
|
|
|
|
|
&dev_attr_lpfc_XLanePriority,
|
|
|
|
|
&dev_attr_lpfc_xlane_lun,
|
|
|
|
|
&dev_attr_lpfc_xlane_tgt,
|
|
|
|
|
&dev_attr_lpfc_xlane_vpt,
|
|
|
|
|
&dev_attr_lpfc_xlane_lun_state,
|
|
|
|
|
&dev_attr_lpfc_xlane_lun_status,
|
2016-07-07 03:36:05 +08:00
|
|
|
&dev_attr_lpfc_xlane_priority,
|
2008-02-22 07:13:36 +08:00
|
|
|
&dev_attr_lpfc_sg_seg_cnt,
|
2008-09-07 23:52:04 +08:00
|
|
|
&dev_attr_lpfc_max_scsicmpl_time,
|
2008-09-07 23:52:10 +08:00
|
|
|
&dev_attr_lpfc_stat_data_ctrl,
|
2009-10-03 03:16:56 +08:00
|
|
|
&dev_attr_lpfc_aer_support,
|
|
|
|
|
&dev_attr_lpfc_aer_state_cleanup,
|
2011-05-24 23:42:11 +08:00
|
|
|
&dev_attr_lpfc_sriov_nr_virtfn,
|
2012-11-01 02:44:33 +08:00
|
|
|
&dev_attr_lpfc_req_fw_upgrade,
|
2010-02-13 03:42:33 +08:00
|
|
|
&dev_attr_lpfc_suppress_link_up,
|
2024-06-12 13:13:20 +08:00
|
|
|
&dev_attr_lpfc_iocb_cnt,
|
2010-06-08 03:24:45 +08:00
|
|
|
&dev_attr_iocb_hw,
|
|
|
|
|
&dev_attr_txq_hw,
|
|
|
|
|
&dev_attr_txcmplq_hw,
|
2024-06-12 13:13:20 +08:00
|
|
|
&dev_attr_lpfc_fips_level,
|
|
|
|
|
&dev_attr_lpfc_fips_rev,
|
|
|
|
|
&dev_attr_lpfc_dss,
|
2011-05-24 23:42:11 +08:00
|
|
|
&dev_attr_lpfc_sriov_hw_max_virtfn,
|
2011-12-14 02:20:45 +08:00
|
|
|
&dev_attr_protocol,
|
2014-02-20 22:56:45 +08:00
|
|
|
&dev_attr_lpfc_xlane_supported,
|
2016-07-07 03:36:00 +08:00
|
|
|
&dev_attr_lpfc_enable_mds_diags,
|
2018-09-11 01:30:50 +08:00
|
|
|
&dev_attr_lpfc_ras_fwlog_buffsize,
|
|
|
|
|
&dev_attr_lpfc_ras_fwlog_level,
|
|
|
|
|
&dev_attr_lpfc_ras_fwlog_func,
|
2017-08-24 07:55:47 +08:00
|
|
|
&dev_attr_lpfc_enable_bbcr,
|
2018-02-23 00:18:43 +08:00
|
|
|
&dev_attr_lpfc_enable_dpp,
|
2005-04-18 05:05:31 +08:00
|
|
|
NULL,
|
|
|
|
|
};
|
|
|
|
|
|
2008-02-22 07:13:36 +08:00
|
|
|
struct device_attribute *lpfc_vport_attrs[] = {
|
|
|
|
|
&dev_attr_info,
|
2008-03-18 21:32:28 +08:00
|
|
|
&dev_attr_link_state,
|
2008-02-22 07:13:36 +08:00
|
|
|
&dev_attr_num_discovered_ports,
|
|
|
|
|
&dev_attr_lpfc_drvr_version,
|
|
|
|
|
&dev_attr_lpfc_log_verbose,
|
|
|
|
|
&dev_attr_lpfc_lun_queue_depth,
|
2010-07-15 03:32:10 +08:00
|
|
|
&dev_attr_lpfc_tgt_queue_depth,
|
2008-02-22 07:13:36 +08:00
|
|
|
&dev_attr_lpfc_nodev_tmo,
|
|
|
|
|
&dev_attr_lpfc_devloss_tmo,
|
|
|
|
|
&dev_attr_lpfc_hba_queue_depth,
|
|
|
|
|
&dev_attr_lpfc_peer_port_login,
|
|
|
|
|
&dev_attr_lpfc_restrict_login,
|
|
|
|
|
&dev_attr_lpfc_fcp_class,
|
|
|
|
|
&dev_attr_lpfc_use_adisc,
|
2013-07-16 06:35:04 +08:00
|
|
|
&dev_attr_lpfc_first_burst_size,
|
2008-02-22 07:13:36 +08:00
|
|
|
&dev_attr_lpfc_max_luns,
|
|
|
|
|
&dev_attr_nport_evt_cnt,
|
|
|
|
|
&dev_attr_npiv_info,
|
|
|
|
|
&dev_attr_lpfc_enable_da_id,
|
2008-09-07 23:52:10 +08:00
|
|
|
&dev_attr_lpfc_max_scsicmpl_time,
|
|
|
|
|
&dev_attr_lpfc_stat_data_ctrl,
|
2009-05-23 02:53:21 +08:00
|
|
|
&dev_attr_lpfc_static_vport,
|
2024-06-12 13:13:20 +08:00
|
|
|
&dev_attr_lpfc_fips_level,
|
|
|
|
|
&dev_attr_lpfc_fips_rev,
|
2007-08-02 23:09:59 +08:00
|
|
|
NULL,
|
|
|
|
|
};
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* sysfs_ctlreg_write - Write method for writing to ctlreg
|
2010-05-13 09:28:57 +08:00
|
|
|
* @filp: open sysfs file
|
2008-08-25 09:49:00 +08:00
|
|
|
* @kobj: kernel kobject that contains the kernel class device.
|
|
|
|
|
* @bin_attr: kernel attributes passed to us.
|
|
|
|
|
* @buf: contains the data to be written to the adapter IOREG space.
|
|
|
|
|
* @off: offset into buffer to beginning of data.
|
|
|
|
|
* @count: bytes to transfer.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* Accessed via /sys/class/scsi_host/hostxxx/ctlreg.
|
|
|
|
|
* Uses the adapter io control registers to send buf contents to the adapter.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* -ERANGE off and count combo out of range
|
|
|
|
|
* -EINVAL off, count or buff address invalid
|
|
|
|
|
* -EPERM adapter is offline
|
|
|
|
|
* value of count, buf contents written
|
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static ssize_t
|
2010-05-13 09:28:57 +08:00
|
|
|
sysfs_ctlreg_write(struct file *filp, struct kobject *kobj,
|
|
|
|
|
struct bin_attribute *bin_attr,
|
2007-06-09 13:57:22 +08:00
|
|
|
char *buf, loff_t off, size_t count)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
|
|
|
|
size_t buf_off;
|
2008-02-22 07:13:36 +08:00
|
|
|
struct device *dev = container_of(kobj, struct device, kobj);
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2009-06-11 05:22:44 +08:00
|
|
|
if (phba->sli_rev >= LPFC_SLI_REV4)
|
|
|
|
|
return -EPERM;
|
|
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
if ((off + count) > FF_REG_AREA_SIZE)
|
|
|
|
|
return -ERANGE;
|
|
|
|
|
|
2011-08-22 09:49:16 +08:00
|
|
|
if (count <= LPFC_REG_WRITE_KEY_SIZE)
|
|
|
|
|
return 0;
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
|
if (off % 4 || count % 4 || (unsigned long)buf % 4)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2011-08-22 09:49:16 +08:00
|
|
|
/* This is to protect HBA registers from accidental writes. */
|
|
|
|
|
if (memcmp(buf, LPFC_REG_WRITE_KEY, LPFC_REG_WRITE_KEY_SIZE))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
if (!(vport->fc_flag & FC_OFFLINE_MODE))
|
2005-04-18 05:05:31 +08:00
|
|
|
return -EPERM;
|
|
|
|
|
|
2007-06-18 08:56:36 +08:00
|
|
|
spin_lock_irq(&phba->hbalock);
|
2011-08-22 09:49:16 +08:00
|
|
|
for (buf_off = 0; buf_off < count - LPFC_REG_WRITE_KEY_SIZE;
|
|
|
|
|
buf_off += sizeof(uint32_t))
|
|
|
|
|
writel(*((uint32_t *)(buf + buf_off + LPFC_REG_WRITE_KEY_SIZE)),
|
2005-04-18 05:05:31 +08:00
|
|
|
phba->ctrl_regs_memmap_p + off + buf_off);
|
|
|
|
|
|
2007-06-18 08:56:36 +08:00
|
|
|
spin_unlock_irq(&phba->hbalock);
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
|
return count;
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* sysfs_ctlreg_read - Read method for reading from ctlreg
|
2010-05-13 09:28:57 +08:00
|
|
|
* @filp: open sysfs file
|
2008-08-25 09:49:00 +08:00
|
|
|
* @kobj: kernel kobject that contains the kernel class device.
|
|
|
|
|
* @bin_attr: kernel attributes passed to us.
|
tree-wide: fix assorted typos all over the place
That is "success", "unknown", "through", "performance", "[re|un]mapping"
, "access", "default", "reasonable", "[con]currently", "temperature"
, "channel", "[un]used", "application", "example","hierarchy", "therefore"
, "[over|under]flow", "contiguous", "threshold", "enough" and others.
Signed-off-by: André Goddard Rosa <andre.goddard@gmail.com>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2009-11-14 23:09:05 +08:00
|
|
|
* @buf: if successful contains the data from the adapter IOREG space.
|
2008-08-25 09:49:00 +08:00
|
|
|
* @off: offset into buffer to beginning of data.
|
|
|
|
|
* @count: bytes to transfer.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* Accessed via /sys/class/scsi_host/hostxxx/ctlreg.
|
|
|
|
|
* Uses the adapter io control registers to read data into buf.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* -ERANGE off and count combo out of range
|
|
|
|
|
* -EINVAL off, count or buff address invalid
|
|
|
|
|
* value of count, buf contents read
|
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static ssize_t
|
2010-05-13 09:28:57 +08:00
|
|
|
sysfs_ctlreg_read(struct file *filp, struct kobject *kobj,
|
|
|
|
|
struct bin_attribute *bin_attr,
|
2007-06-09 13:57:22 +08:00
|
|
|
char *buf, loff_t off, size_t count)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
|
|
|
|
size_t buf_off;
|
|
|
|
|
uint32_t * tmp_ptr;
|
2008-02-22 07:13:36 +08:00
|
|
|
struct device *dev = container_of(kobj, struct device, kobj);
|
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2009-06-11 05:22:44 +08:00
|
|
|
if (phba->sli_rev >= LPFC_SLI_REV4)
|
|
|
|
|
return -EPERM;
|
|
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
if (off > FF_REG_AREA_SIZE)
|
|
|
|
|
return -ERANGE;
|
|
|
|
|
|
|
|
|
|
if ((off + count) > FF_REG_AREA_SIZE)
|
|
|
|
|
count = FF_REG_AREA_SIZE - off;
|
|
|
|
|
|
|
|
|
|
if (count == 0) return 0;
|
|
|
|
|
|
|
|
|
|
if (off % 4 || count % 4 || (unsigned long)buf % 4)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2007-06-18 08:56:36 +08:00
|
|
|
spin_lock_irq(&phba->hbalock);
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
|
for (buf_off = 0; buf_off < count; buf_off += sizeof(uint32_t)) {
|
|
|
|
|
tmp_ptr = (uint32_t *)(buf + buf_off);
|
|
|
|
|
*tmp_ptr = readl(phba->ctrl_regs_memmap_p + off + buf_off);
|
|
|
|
|
}
|
|
|
|
|
|
2007-06-18 08:56:36 +08:00
|
|
|
spin_unlock_irq(&phba->hbalock);
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
|
return count;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct bin_attribute sysfs_ctlreg_attr = {
|
|
|
|
|
.attr = {
|
|
|
|
|
.name = "ctlreg",
|
|
|
|
|
.mode = S_IRUSR | S_IWUSR,
|
|
|
|
|
},
|
|
|
|
|
.size = 256,
|
|
|
|
|
.read = sysfs_ctlreg_read,
|
|
|
|
|
.write = sysfs_ctlreg_write,
|
|
|
|
|
};
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* sysfs_mbox_write - Write method for writing information via mbox
|
2010-05-13 09:28:57 +08:00
|
|
|
* @filp: open sysfs file
|
2008-08-25 09:49:00 +08:00
|
|
|
* @kobj: kernel kobject that contains the kernel class device.
|
|
|
|
|
* @bin_attr: kernel attributes passed to us.
|
|
|
|
|
* @buf: contains the data to be written to sysfs mbox.
|
|
|
|
|
* @off: offset into buffer to beginning of data.
|
|
|
|
|
* @count: bytes to transfer.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
2011-12-14 02:20:45 +08:00
|
|
|
* Deprecated function. All mailbox access from user space is performed via the
|
|
|
|
|
* bsg interface.
|
2008-08-25 09:49:00 +08:00
|
|
|
*
|
|
|
|
|
* Returns:
|
2011-12-14 02:20:45 +08:00
|
|
|
* -EPERM operation not permitted
|
2008-08-25 09:49:00 +08:00
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static ssize_t
|
2010-05-13 09:28:57 +08:00
|
|
|
sysfs_mbox_write(struct file *filp, struct kobject *kobj,
|
|
|
|
|
struct bin_attribute *bin_attr,
|
2007-06-09 13:57:22 +08:00
|
|
|
char *buf, loff_t off, size_t count)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
2011-12-14 02:20:45 +08:00
|
|
|
return -EPERM;
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* sysfs_mbox_read - Read method for reading information via mbox
|
2010-05-13 09:28:57 +08:00
|
|
|
* @filp: open sysfs file
|
2008-08-25 09:49:00 +08:00
|
|
|
* @kobj: kernel kobject that contains the kernel class device.
|
|
|
|
|
* @bin_attr: kernel attributes passed to us.
|
|
|
|
|
* @buf: contains the data to be read from sysfs mbox.
|
|
|
|
|
* @off: offset into buffer to beginning of data.
|
|
|
|
|
* @count: bytes to transfer.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
2011-12-14 02:20:45 +08:00
|
|
|
* Deprecated function. All mailbox access from user space is performed via the
|
|
|
|
|
* bsg interface.
|
2008-08-25 09:49:00 +08:00
|
|
|
*
|
|
|
|
|
* Returns:
|
2011-12-14 02:20:45 +08:00
|
|
|
* -EPERM operation not permitted
|
2008-08-25 09:49:00 +08:00
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static ssize_t
|
2010-05-13 09:28:57 +08:00
|
|
|
sysfs_mbox_read(struct file *filp, struct kobject *kobj,
|
|
|
|
|
struct bin_attribute *bin_attr,
|
2007-06-09 13:57:22 +08:00
|
|
|
char *buf, loff_t off, size_t count)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
2011-12-14 02:20:45 +08:00
|
|
|
return -EPERM;
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct bin_attribute sysfs_mbox_attr = {
|
|
|
|
|
.attr = {
|
|
|
|
|
.name = "mbox",
|
|
|
|
|
.mode = S_IRUSR | S_IWUSR,
|
|
|
|
|
},
|
2011-05-24 23:41:34 +08:00
|
|
|
.size = MAILBOX_SYSFS_MAX,
|
2005-04-18 05:05:31 +08:00
|
|
|
.read = sysfs_mbox_read,
|
|
|
|
|
.write = sysfs_mbox_write,
|
|
|
|
|
};
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_alloc_sysfs_attr - Creates the ctlreg and mbox entries
|
2008-08-25 09:49:00 +08:00
|
|
|
* @vport: address of lpfc vport structure.
|
|
|
|
|
*
|
|
|
|
|
* Return codes:
|
|
|
|
|
* zero on success
|
|
|
|
|
* error return code from sysfs_create_bin_file()
|
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
int
|
2007-06-18 08:56:36 +08:00
|
|
|
lpfc_alloc_sysfs_attr(struct lpfc_vport *vport)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
2007-06-18 08:56:36 +08:00
|
|
|
struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
|
2005-04-18 05:05:31 +08:00
|
|
|
int error;
|
|
|
|
|
|
2008-02-22 07:13:36 +08:00
|
|
|
error = sysfs_create_bin_file(&shost->shost_dev.kobj,
|
2008-12-05 11:39:13 +08:00
|
|
|
&sysfs_drvr_stat_data_attr);
|
|
|
|
|
|
|
|
|
|
/* Virtual ports do not need ctrl_reg and mbox */
|
|
|
|
|
if (error || vport->port_type == LPFC_NPIV_PORT)
|
2005-04-18 05:05:31 +08:00
|
|
|
goto out;
|
|
|
|
|
|
2008-02-22 07:13:36 +08:00
|
|
|
error = sysfs_create_bin_file(&shost->shost_dev.kobj,
|
2008-12-05 11:39:13 +08:00
|
|
|
&sysfs_ctlreg_attr);
|
2005-04-18 05:05:31 +08:00
|
|
|
if (error)
|
2008-12-05 11:39:13 +08:00
|
|
|
goto out_remove_stat_attr;
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2008-09-07 23:52:10 +08:00
|
|
|
error = sysfs_create_bin_file(&shost->shost_dev.kobj,
|
2008-12-05 11:39:13 +08:00
|
|
|
&sysfs_mbox_attr);
|
2008-09-07 23:52:10 +08:00
|
|
|
if (error)
|
2008-12-05 11:39:13 +08:00
|
|
|
goto out_remove_ctlreg_attr;
|
2008-09-07 23:52:10 +08:00
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
return 0;
|
|
|
|
|
out_remove_ctlreg_attr:
|
2008-02-22 07:13:36 +08:00
|
|
|
sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_ctlreg_attr);
|
2008-12-05 11:39:13 +08:00
|
|
|
out_remove_stat_attr:
|
|
|
|
|
sysfs_remove_bin_file(&shost->shost_dev.kobj,
|
|
|
|
|
&sysfs_drvr_stat_data_attr);
|
2005-04-18 05:05:31 +08:00
|
|
|
out:
|
|
|
|
|
return error;
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_free_sysfs_attr - Removes the ctlreg and mbox entries
|
2008-08-25 09:49:00 +08:00
|
|
|
* @vport: address of lpfc vport structure.
|
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
void
|
2007-06-18 08:56:36 +08:00
|
|
|
lpfc_free_sysfs_attr(struct lpfc_vport *vport)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
2007-06-18 08:56:36 +08:00
|
|
|
struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
|
2008-09-07 23:52:10 +08:00
|
|
|
sysfs_remove_bin_file(&shost->shost_dev.kobj,
|
|
|
|
|
&sysfs_drvr_stat_data_attr);
|
2008-12-05 11:39:13 +08:00
|
|
|
/* Virtual ports do not need ctrl_reg and mbox */
|
|
|
|
|
if (vport->port_type == LPFC_NPIV_PORT)
|
|
|
|
|
return;
|
2008-02-22 07:13:36 +08:00
|
|
|
sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_mbox_attr);
|
|
|
|
|
sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_ctlreg_attr);
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Dynamic FC Host Attributes Support
|
|
|
|
|
*/
|
|
|
|
|
|
2016-12-20 07:07:24 +08:00
|
|
|
/**
|
|
|
|
|
* lpfc_get_host_symbolic_name - Copy symbolic name into the scsi host
|
|
|
|
|
* @shost: kernel scsi host pointer.
|
|
|
|
|
**/
|
|
|
|
|
static void
|
|
|
|
|
lpfc_get_host_symbolic_name(struct Scsi_Host *shost)
|
|
|
|
|
{
|
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
|
|
|
|
|
|
|
|
|
|
lpfc_vport_symbolic_node_name(vport, fc_host_symbolic_name(shost),
|
|
|
|
|
sizeof fc_host_symbolic_name(shost));
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_get_host_port_id - Copy the vport DID into the scsi host port id
|
2008-08-25 09:49:00 +08:00
|
|
|
* @shost: kernel scsi host pointer.
|
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static void
|
|
|
|
|
lpfc_get_host_port_id(struct Scsi_Host *shost)
|
|
|
|
|
{
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
/* note: fc_myDID already in cpu endianness */
|
2007-06-18 08:56:36 +08:00
|
|
|
fc_host_port_id(shost) = vport->fc_myDID;
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_get_host_port_type - Set the value of the scsi host port type
|
2008-08-25 09:49:00 +08:00
|
|
|
* @shost: kernel scsi host pointer.
|
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static void
|
|
|
|
|
lpfc_get_host_port_type(struct Scsi_Host *shost)
|
|
|
|
|
{
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
|
spin_lock_irq(shost->host_lock);
|
|
|
|
|
|
2007-06-18 08:56:38 +08:00
|
|
|
if (vport->port_type == LPFC_NPIV_PORT) {
|
|
|
|
|
fc_host_port_type(shost) = FC_PORTTYPE_NPIV;
|
|
|
|
|
} else if (lpfc_is_link_up(phba)) {
|
2010-11-21 12:11:48 +08:00
|
|
|
if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
|
2007-06-18 08:56:36 +08:00
|
|
|
if (vport->fc_flag & FC_PUBLIC_LOOP)
|
2005-04-18 05:05:31 +08:00
|
|
|
fc_host_port_type(shost) = FC_PORTTYPE_NLPORT;
|
|
|
|
|
else
|
|
|
|
|
fc_host_port_type(shost) = FC_PORTTYPE_LPORT;
|
|
|
|
|
} else {
|
2007-06-18 08:56:36 +08:00
|
|
|
if (vport->fc_flag & FC_FABRIC)
|
2005-04-18 05:05:31 +08:00
|
|
|
fc_host_port_type(shost) = FC_PORTTYPE_NPORT;
|
|
|
|
|
else
|
|
|
|
|
fc_host_port_type(shost) = FC_PORTTYPE_PTP;
|
|
|
|
|
}
|
|
|
|
|
} else
|
|
|
|
|
fc_host_port_type(shost) = FC_PORTTYPE_UNKNOWN;
|
|
|
|
|
|
|
|
|
|
spin_unlock_irq(shost->host_lock);
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_get_host_port_state - Set the value of the scsi host port state
|
2008-08-25 09:49:00 +08:00
|
|
|
* @shost: kernel scsi host pointer.
|
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static void
|
|
|
|
|
lpfc_get_host_port_state(struct Scsi_Host *shost)
|
|
|
|
|
{
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
|
spin_lock_irq(shost->host_lock);
|
|
|
|
|
|
2007-06-18 08:56:36 +08:00
|
|
|
if (vport->fc_flag & FC_OFFLINE_MODE)
|
2005-04-18 05:05:31 +08:00
|
|
|
fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
|
|
|
|
|
else {
|
2007-06-18 08:56:36 +08:00
|
|
|
switch (phba->link_state) {
|
|
|
|
|
case LPFC_LINK_UNKNOWN:
|
2005-04-18 05:05:31 +08:00
|
|
|
case LPFC_LINK_DOWN:
|
|
|
|
|
fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
|
|
|
|
|
break;
|
|
|
|
|
case LPFC_LINK_UP:
|
|
|
|
|
case LPFC_CLEAR_LA:
|
|
|
|
|
case LPFC_HBA_READY:
|
2011-12-14 02:20:45 +08:00
|
|
|
/* Links up, reports port state accordingly */
|
|
|
|
|
if (vport->port_state < LPFC_VPORT_READY)
|
|
|
|
|
fc_host_port_state(shost) =
|
|
|
|
|
FC_PORTSTATE_BYPASSED;
|
|
|
|
|
else
|
|
|
|
|
fc_host_port_state(shost) =
|
|
|
|
|
FC_PORTSTATE_ONLINE;
|
2005-04-18 05:05:31 +08:00
|
|
|
break;
|
|
|
|
|
case LPFC_HBA_ERROR:
|
|
|
|
|
fc_host_port_state(shost) = FC_PORTSTATE_ERROR;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
spin_unlock_irq(shost->host_lock);
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_get_host_speed - Set the value of the scsi host speed
|
2008-08-25 09:49:00 +08:00
|
|
|
* @shost: kernel scsi host pointer.
|
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static void
|
|
|
|
|
lpfc_get_host_speed(struct Scsi_Host *shost)
|
|
|
|
|
{
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
|
spin_lock_irq(shost->host_lock);
|
|
|
|
|
|
2015-12-17 07:12:02 +08:00
|
|
|
if ((lpfc_is_link_up(phba)) && (!(phba->hba_flag & HBA_FCOE_MODE))) {
|
2005-04-18 05:05:31 +08:00
|
|
|
switch(phba->fc_linkspeed) {
|
2010-11-21 12:11:48 +08:00
|
|
|
case LPFC_LINK_SPEED_1GHZ:
|
|
|
|
|
fc_host_speed(shost) = FC_PORTSPEED_1GBIT;
|
2005-04-18 05:05:31 +08:00
|
|
|
break;
|
2010-11-21 12:11:48 +08:00
|
|
|
case LPFC_LINK_SPEED_2GHZ:
|
|
|
|
|
fc_host_speed(shost) = FC_PORTSPEED_2GBIT;
|
2005-04-18 05:05:31 +08:00
|
|
|
break;
|
2010-11-21 12:11:48 +08:00
|
|
|
case LPFC_LINK_SPEED_4GHZ:
|
|
|
|
|
fc_host_speed(shost) = FC_PORTSPEED_4GBIT;
|
2005-04-18 05:05:31 +08:00
|
|
|
break;
|
2010-11-21 12:11:48 +08:00
|
|
|
case LPFC_LINK_SPEED_8GHZ:
|
|
|
|
|
fc_host_speed(shost) = FC_PORTSPEED_8GBIT;
|
2007-04-25 21:53:28 +08:00
|
|
|
break;
|
2010-11-21 12:11:48 +08:00
|
|
|
case LPFC_LINK_SPEED_10GHZ:
|
|
|
|
|
fc_host_speed(shost) = FC_PORTSPEED_10GBIT;
|
2009-05-23 02:53:12 +08:00
|
|
|
break;
|
2010-11-21 12:11:48 +08:00
|
|
|
case LPFC_LINK_SPEED_16GHZ:
|
|
|
|
|
fc_host_speed(shost) = FC_PORTSPEED_16GBIT;
|
|
|
|
|
break;
|
2015-09-01 04:48:17 +08:00
|
|
|
case LPFC_LINK_SPEED_32GHZ:
|
|
|
|
|
fc_host_speed(shost) = FC_PORTSPEED_32GBIT;
|
|
|
|
|
break;
|
2018-02-23 00:18:45 +08:00
|
|
|
case LPFC_LINK_SPEED_64GHZ:
|
|
|
|
|
fc_host_speed(shost) = FC_PORTSPEED_64GBIT;
|
|
|
|
|
break;
|
2018-10-24 04:41:11 +08:00
|
|
|
case LPFC_LINK_SPEED_128GHZ:
|
|
|
|
|
fc_host_speed(shost) = FC_PORTSPEED_128GBIT;
|
|
|
|
|
break;
|
2010-11-21 12:11:48 +08:00
|
|
|
default:
|
|
|
|
|
fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
|
2005-04-18 05:05:31 +08:00
|
|
|
break;
|
|
|
|
|
}
|
2024-06-12 13:13:20 +08:00
|
|
|
} else if (lpfc_is_link_up(phba) && (phba->hba_flag & HBA_FCOE_MODE)) {
|
2018-08-01 08:23:19 +08:00
|
|
|
switch (phba->fc_linkspeed) {
|
|
|
|
|
case LPFC_ASYNC_LINK_SPEED_10GBPS:
|
|
|
|
|
fc_host_speed(shost) = FC_PORTSPEED_10GBIT;
|
|
|
|
|
break;
|
|
|
|
|
case LPFC_ASYNC_LINK_SPEED_25GBPS:
|
|
|
|
|
fc_host_speed(shost) = FC_PORTSPEED_25GBIT;
|
|
|
|
|
break;
|
|
|
|
|
case LPFC_ASYNC_LINK_SPEED_40GBPS:
|
|
|
|
|
fc_host_speed(shost) = FC_PORTSPEED_40GBIT;
|
|
|
|
|
break;
|
|
|
|
|
case LPFC_ASYNC_LINK_SPEED_100GBPS:
|
|
|
|
|
fc_host_speed(shost) = FC_PORTSPEED_100GBIT;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
|
|
|
|
|
break;
|
|
|
|
|
}
|
2008-01-11 14:52:54 +08:00
|
|
|
} else
|
|
|
|
|
fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
|
spin_unlock_irq(shost->host_lock);
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_get_host_fabric_name - Set the value of the scsi host fabric name
|
2008-08-25 09:49:00 +08:00
|
|
|
* @shost: kernel scsi host pointer.
|
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static void
|
|
|
|
|
lpfc_get_host_fabric_name (struct Scsi_Host *shost)
|
|
|
|
|
{
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
2005-09-01 06:23:12 +08:00
|
|
|
u64 node_name;
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
|
spin_lock_irq(shost->host_lock);
|
|
|
|
|
|
2011-10-11 09:32:10 +08:00
|
|
|
if ((vport->port_state > LPFC_FLOGI) &&
|
|
|
|
|
((vport->fc_flag & FC_FABRIC) ||
|
|
|
|
|
((phba->fc_topology == LPFC_TOPOLOGY_LOOP) &&
|
|
|
|
|
(vport->fc_flag & FC_PUBLIC_LOOP))))
|
2005-09-22 00:46:54 +08:00
|
|
|
node_name = wwn_to_u64(phba->fc_fabparam.nodeName.u.wwn);
|
2005-04-18 05:05:31 +08:00
|
|
|
else
|
|
|
|
|
/* fabric is local port if there is no F/FL_Port */
|
2008-01-11 14:52:54 +08:00
|
|
|
node_name = 0;
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
|
spin_unlock_irq(shost->host_lock);
|
|
|
|
|
|
2005-09-01 06:23:12 +08:00
|
|
|
fc_host_fabric_name(shost) = node_name;
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_get_stats - Return statistical information about the adapter
|
2008-08-25 09:49:00 +08:00
|
|
|
* @shost: kernel scsi host pointer.
|
|
|
|
|
*
|
|
|
|
|
* Notes:
|
|
|
|
|
* NULL on error for link down, no mbox pool, sli2 active,
|
|
|
|
|
* management not allowed, memory allocation error, or mbox error.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* NULL for error
|
|
|
|
|
* address of the adapter host statistics
|
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static struct fc_host_statistics *
|
|
|
|
|
lpfc_get_stats(struct Scsi_Host *shost)
|
|
|
|
|
{
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
struct lpfc_sli *psli = &phba->sli;
|
2005-08-11 03:03:01 +08:00
|
|
|
struct fc_host_statistics *hs = &phba->link_stats;
|
2006-08-03 03:24:34 +08:00
|
|
|
struct lpfc_lnk_stat * lso = &psli->lnk_stat_offsets;
|
2005-04-18 05:05:31 +08:00
|
|
|
LPFC_MBOXQ_t *pmboxq;
|
|
|
|
|
MAILBOX_t *pmb;
|
2005-10-29 08:28:56 +08:00
|
|
|
int rc = 0;
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2007-06-18 08:56:38 +08:00
|
|
|
/*
|
|
|
|
|
* prevent udev from issuing mailbox commands until the port is
|
|
|
|
|
* configured.
|
|
|
|
|
*/
|
2007-06-18 08:56:36 +08:00
|
|
|
if (phba->link_state < LPFC_LINK_DOWN ||
|
|
|
|
|
!phba->mbox_mem_pool ||
|
2009-05-23 02:53:12 +08:00
|
|
|
(phba->sli.sli_flag & LPFC_SLI_ACTIVE) == 0)
|
2007-06-18 08:56:38 +08:00
|
|
|
return NULL;
|
2007-06-18 08:56:36 +08:00
|
|
|
|
|
|
|
|
if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
|
2007-04-25 21:51:45 +08:00
|
|
|
return NULL;
|
|
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
|
|
|
|
|
if (!pmboxq)
|
|
|
|
|
return NULL;
|
|
|
|
|
memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
|
|
|
|
|
|
2009-05-23 02:52:52 +08:00
|
|
|
pmb = &pmboxq->u.mb;
|
2005-04-18 05:05:31 +08:00
|
|
|
pmb->mbxCommand = MBX_READ_STATUS;
|
|
|
|
|
pmb->mbxOwner = OWN_HOST;
|
2018-11-30 08:09:29 +08:00
|
|
|
pmboxq->ctx_buf = NULL;
|
2007-06-18 08:56:38 +08:00
|
|
|
pmboxq->vport = vport;
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
if (vport->fc_flag & FC_OFFLINE_MODE) {
|
2005-04-18 05:05:31 +08:00
|
|
|
rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
|
2024-06-12 13:13:20 +08:00
|
|
|
if (rc != MBX_SUCCESS) {
|
2005-10-29 08:28:56 +08:00
|
|
|
mempool_free(pmboxq, phba->mbox_mem_pool);
|
2024-06-12 13:13:20 +08:00
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
|
|
|
|
|
if (rc != MBX_SUCCESS) {
|
|
|
|
|
if (rc != MBX_TIMEOUT)
|
|
|
|
|
mempool_free(pmboxq, phba->mbox_mem_pool);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
|
2005-08-11 03:03:01 +08:00
|
|
|
memset(hs, 0, sizeof (struct fc_host_statistics));
|
|
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
hs->tx_frames = pmb->un.varRdStatus.xmitFrameCnt;
|
2011-10-11 09:32:10 +08:00
|
|
|
/*
|
|
|
|
|
* The MBX_READ_STATUS returns tx_k_bytes which has to
|
|
|
|
|
* converted to words
|
|
|
|
|
*/
|
|
|
|
|
hs->tx_words = (uint64_t)
|
|
|
|
|
((uint64_t)pmb->un.varRdStatus.xmitByteCnt
|
|
|
|
|
* (uint64_t)256);
|
2005-04-18 05:05:31 +08:00
|
|
|
hs->rx_frames = pmb->un.varRdStatus.rcvFrameCnt;
|
2011-10-11 09:32:10 +08:00
|
|
|
hs->rx_words = (uint64_t)
|
|
|
|
|
((uint64_t)pmb->un.varRdStatus.rcvByteCnt
|
|
|
|
|
* (uint64_t)256);
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2005-10-29 08:28:56 +08:00
|
|
|
memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
|
2005-04-18 05:05:31 +08:00
|
|
|
pmb->mbxCommand = MBX_READ_LNK_STAT;
|
|
|
|
|
pmb->mbxOwner = OWN_HOST;
|
2018-11-30 08:09:29 +08:00
|
|
|
pmboxq->ctx_buf = NULL;
|
2007-06-18 08:56:38 +08:00
|
|
|
pmboxq->vport = vport;
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
if (vport->fc_flag & FC_OFFLINE_MODE) {
|
2005-04-18 05:05:31 +08:00
|
|
|
rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
|
2024-06-12 13:13:20 +08:00
|
|
|
if (rc != MBX_SUCCESS) {
|
2007-06-18 08:56:38 +08:00
|
|
|
mempool_free(pmboxq, phba->mbox_mem_pool);
|
2024-06-12 13:13:20 +08:00
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
|
|
|
|
|
if (rc != MBX_SUCCESS) {
|
|
|
|
|
if (rc != MBX_TIMEOUT)
|
|
|
|
|
mempool_free(pmboxq, phba->mbox_mem_pool);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
hs->link_failure_count = pmb->un.varRdLnk.linkFailureCnt;
|
|
|
|
|
hs->loss_of_sync_count = pmb->un.varRdLnk.lossSyncCnt;
|
|
|
|
|
hs->loss_of_signal_count = pmb->un.varRdLnk.lossSignalCnt;
|
|
|
|
|
hs->prim_seq_protocol_err_count = pmb->un.varRdLnk.primSeqErrCnt;
|
|
|
|
|
hs->invalid_tx_word_count = pmb->un.varRdLnk.invalidXmitWord;
|
|
|
|
|
hs->invalid_crc_count = pmb->un.varRdLnk.crcCnt;
|
|
|
|
|
hs->error_frames = pmb->un.varRdLnk.crcCnt;
|
|
|
|
|
|
2006-08-03 03:24:34 +08:00
|
|
|
hs->link_failure_count -= lso->link_failure_count;
|
|
|
|
|
hs->loss_of_sync_count -= lso->loss_of_sync_count;
|
|
|
|
|
hs->loss_of_signal_count -= lso->loss_of_signal_count;
|
|
|
|
|
hs->prim_seq_protocol_err_count -= lso->prim_seq_protocol_err_count;
|
|
|
|
|
hs->invalid_tx_word_count -= lso->invalid_tx_word_count;
|
|
|
|
|
hs->invalid_crc_count -= lso->invalid_crc_count;
|
|
|
|
|
hs->error_frames -= lso->error_frames;
|
|
|
|
|
|
2010-11-21 12:11:48 +08:00
|
|
|
if (phba->hba_flag & HBA_FCOE_MODE) {
|
2009-10-03 03:16:39 +08:00
|
|
|
hs->lip_count = -1;
|
|
|
|
|
hs->nos_count = (phba->link_events >> 1);
|
|
|
|
|
hs->nos_count -= lso->link_events;
|
2010-11-21 12:11:48 +08:00
|
|
|
} else if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
|
2005-04-18 05:05:31 +08:00
|
|
|
hs->lip_count = (phba->fc_eventTag >> 1);
|
2006-08-03 03:24:34 +08:00
|
|
|
hs->lip_count -= lso->link_events;
|
2005-04-18 05:05:31 +08:00
|
|
|
hs->nos_count = -1;
|
|
|
|
|
} else {
|
|
|
|
|
hs->lip_count = -1;
|
|
|
|
|
hs->nos_count = (phba->fc_eventTag >> 1);
|
2006-08-03 03:24:34 +08:00
|
|
|
hs->nos_count -= lso->link_events;
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
hs->dumped_frames = -1;
|
|
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
hs->seconds_since_last_reset = ktime_get_seconds() - psli->stats_start;
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2007-04-25 21:51:30 +08:00
|
|
|
mempool_free(pmboxq, phba->mbox_mem_pool);
|
|
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
return hs;
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_reset_stats - Copy the adapter link stats information
|
2008-08-25 09:49:00 +08:00
|
|
|
* @shost: kernel scsi host pointer.
|
|
|
|
|
**/
|
2006-08-03 03:24:34 +08:00
|
|
|
static void
|
|
|
|
|
lpfc_reset_stats(struct Scsi_Host *shost)
|
|
|
|
|
{
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
struct lpfc_sli *psli = &phba->sli;
|
|
|
|
|
struct lpfc_lnk_stat *lso = &psli->lnk_stat_offsets;
|
2006-08-03 03:24:34 +08:00
|
|
|
LPFC_MBOXQ_t *pmboxq;
|
|
|
|
|
MAILBOX_t *pmb;
|
|
|
|
|
int rc = 0;
|
|
|
|
|
|
2007-06-18 08:56:36 +08:00
|
|
|
if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
|
2007-04-25 21:51:45 +08:00
|
|
|
return;
|
|
|
|
|
|
2006-08-03 03:24:34 +08:00
|
|
|
pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
|
|
|
|
|
if (!pmboxq)
|
|
|
|
|
return;
|
|
|
|
|
memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
|
|
|
|
|
|
2009-05-23 02:52:52 +08:00
|
|
|
pmb = &pmboxq->u.mb;
|
2006-08-03 03:24:34 +08:00
|
|
|
pmb->mbxCommand = MBX_READ_STATUS;
|
|
|
|
|
pmb->mbxOwner = OWN_HOST;
|
|
|
|
|
pmb->un.varWords[0] = 0x1; /* reset request */
|
2018-11-30 08:09:29 +08:00
|
|
|
pmboxq->ctx_buf = NULL;
|
2007-06-18 08:56:38 +08:00
|
|
|
pmboxq->vport = vport;
|
2006-08-03 03:24:34 +08:00
|
|
|
|
2007-06-18 08:56:36 +08:00
|
|
|
if ((vport->fc_flag & FC_OFFLINE_MODE) ||
|
2024-06-12 13:13:20 +08:00
|
|
|
(!(psli->sli_flag & LPFC_SLI_ACTIVE))) {
|
2006-08-03 03:24:34 +08:00
|
|
|
rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
|
2024-06-12 13:13:20 +08:00
|
|
|
if (rc != MBX_SUCCESS) {
|
2006-08-03 03:24:34 +08:00
|
|
|
mempool_free(pmboxq, phba->mbox_mem_pool);
|
2024-06-12 13:13:20 +08:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
|
|
|
|
|
if (rc != MBX_SUCCESS) {
|
|
|
|
|
if (rc != MBX_TIMEOUT)
|
|
|
|
|
mempool_free(pmboxq, phba->mbox_mem_pool);
|
|
|
|
|
return;
|
|
|
|
|
}
|
2006-08-03 03:24:34 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
|
|
|
|
|
pmb->mbxCommand = MBX_READ_LNK_STAT;
|
|
|
|
|
pmb->mbxOwner = OWN_HOST;
|
2018-11-30 08:09:29 +08:00
|
|
|
pmboxq->ctx_buf = NULL;
|
2007-06-18 08:56:38 +08:00
|
|
|
pmboxq->vport = vport;
|
2006-08-03 03:24:34 +08:00
|
|
|
|
2007-06-18 08:56:36 +08:00
|
|
|
if ((vport->fc_flag & FC_OFFLINE_MODE) ||
|
2024-06-12 13:13:20 +08:00
|
|
|
(!(psli->sli_flag & LPFC_SLI_ACTIVE))) {
|
2006-08-03 03:24:34 +08:00
|
|
|
rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
|
2024-06-12 13:13:20 +08:00
|
|
|
if (rc != MBX_SUCCESS) {
|
|
|
|
|
mempool_free(pmboxq, phba->mbox_mem_pool);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
2006-08-03 03:24:34 +08:00
|
|
|
rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
|
2024-06-12 13:13:20 +08:00
|
|
|
if (rc != MBX_SUCCESS) {
|
|
|
|
|
if (rc != MBX_TIMEOUT)
|
|
|
|
|
mempool_free(pmboxq, phba->mbox_mem_pool);
|
|
|
|
|
return;
|
|
|
|
|
}
|
2006-08-03 03:24:34 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
lso->link_failure_count = pmb->un.varRdLnk.linkFailureCnt;
|
|
|
|
|
lso->loss_of_sync_count = pmb->un.varRdLnk.lossSyncCnt;
|
|
|
|
|
lso->loss_of_signal_count = pmb->un.varRdLnk.lossSignalCnt;
|
|
|
|
|
lso->prim_seq_protocol_err_count = pmb->un.varRdLnk.primSeqErrCnt;
|
|
|
|
|
lso->invalid_tx_word_count = pmb->un.varRdLnk.invalidXmitWord;
|
|
|
|
|
lso->invalid_crc_count = pmb->un.varRdLnk.crcCnt;
|
|
|
|
|
lso->error_frames = pmb->un.varRdLnk.crcCnt;
|
2010-11-21 12:11:48 +08:00
|
|
|
if (phba->hba_flag & HBA_FCOE_MODE)
|
2009-10-03 03:16:39 +08:00
|
|
|
lso->link_events = (phba->link_events >> 1);
|
|
|
|
|
else
|
|
|
|
|
lso->link_events = (phba->fc_eventTag >> 1);
|
2006-08-03 03:24:34 +08:00
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
psli->stats_start = ktime_get_seconds();
|
2006-08-03 03:24:34 +08:00
|
|
|
|
2007-04-25 21:51:30 +08:00
|
|
|
mempool_free(pmboxq, phba->mbox_mem_pool);
|
|
|
|
|
|
2006-08-03 03:24:34 +08:00
|
|
|
return;
|
|
|
|
|
}
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* The LPFC driver treats linkdown handling as target loss events so there
|
|
|
|
|
* are no sysfs handlers for link_down_tmo.
|
|
|
|
|
*/
|
2007-04-25 21:53:08 +08:00
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_get_node_by_target - Return the nodelist for a target
|
2008-08-25 09:49:00 +08:00
|
|
|
* @starget: kernel scsi target pointer.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* address of the node list if found
|
|
|
|
|
* NULL target not found
|
|
|
|
|
**/
|
2007-04-25 21:53:08 +08:00
|
|
|
static struct lpfc_nodelist *
|
|
|
|
|
lpfc_get_node_by_target(struct scsi_target *starget)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
2007-06-18 08:56:36 +08:00
|
|
|
struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
|
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
2007-04-25 21:53:08 +08:00
|
|
|
struct lpfc_nodelist *ndlp;
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
|
spin_lock_irq(shost->host_lock);
|
2007-04-25 21:53:08 +08:00
|
|
|
/* Search for this, mapped, target ID */
|
2007-06-18 08:56:36 +08:00
|
|
|
list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
|
2008-02-09 07:49:26 +08:00
|
|
|
if (NLP_CHK_NODE_ACT(ndlp) &&
|
|
|
|
|
ndlp->nlp_state == NLP_STE_MAPPED_NODE &&
|
2007-04-25 21:53:08 +08:00
|
|
|
starget->id == ndlp->nlp_sid) {
|
|
|
|
|
spin_unlock_irq(shost->host_lock);
|
|
|
|
|
return ndlp;
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
spin_unlock_irq(shost->host_lock);
|
2007-04-25 21:53:08 +08:00
|
|
|
return NULL;
|
|
|
|
|
}
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_get_starget_port_id - Set the target port id to the ndlp DID or -1
|
2008-08-25 09:49:00 +08:00
|
|
|
* @starget: kernel scsi target pointer.
|
|
|
|
|
**/
|
2007-04-25 21:53:08 +08:00
|
|
|
static void
|
|
|
|
|
lpfc_get_starget_port_id(struct scsi_target *starget)
|
|
|
|
|
{
|
|
|
|
|
struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
|
|
|
|
|
|
|
|
|
|
fc_starget_port_id(starget) = ndlp ? ndlp->nlp_DID : -1;
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_get_starget_node_name - Set the target node name
|
2008-08-25 09:49:00 +08:00
|
|
|
* @starget: kernel scsi target pointer.
|
|
|
|
|
*
|
|
|
|
|
* Description: Set the target node name to the ndlp node name wwn or zero.
|
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static void
|
|
|
|
|
lpfc_get_starget_node_name(struct scsi_target *starget)
|
|
|
|
|
{
|
2007-04-25 21:53:08 +08:00
|
|
|
struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2007-04-25 21:53:08 +08:00
|
|
|
fc_starget_node_name(starget) =
|
|
|
|
|
ndlp ? wwn_to_u64(ndlp->nlp_nodename.u.wwn) : 0;
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_get_starget_port_name - Set the target port name
|
2008-08-25 09:49:00 +08:00
|
|
|
* @starget: kernel scsi target pointer.
|
|
|
|
|
*
|
|
|
|
|
* Description: set the target port name to the ndlp port name wwn or zero.
|
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static void
|
|
|
|
|
lpfc_get_starget_port_name(struct scsi_target *starget)
|
|
|
|
|
{
|
2007-04-25 21:53:08 +08:00
|
|
|
struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2007-04-25 21:53:08 +08:00
|
|
|
fc_starget_port_name(starget) =
|
|
|
|
|
ndlp ? wwn_to_u64(ndlp->nlp_portname.u.wwn) : 0;
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_set_rport_loss_tmo - Set the rport dev loss tmo
|
2008-08-25 09:49:00 +08:00
|
|
|
* @rport: fc rport address.
|
|
|
|
|
* @timeout: new value for dev loss tmo.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* If timeout is non zero set the dev_loss_tmo to timeout, else set
|
|
|
|
|
* dev_loss_tmo to one.
|
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static void
|
|
|
|
|
lpfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout)
|
|
|
|
|
{
|
2019-08-15 07:56:48 +08:00
|
|
|
struct lpfc_rport_data *rdata = rport->dd_data;
|
|
|
|
|
struct lpfc_nodelist *ndlp = rdata->pnode;
|
2024-06-12 13:13:20 +08:00
|
|
|
#if (IS_ENABLED(CONFIG_NVME_FC))
|
2019-08-15 07:56:48 +08:00
|
|
|
struct lpfc_nvme_rport *nrport = NULL;
|
|
|
|
|
#endif
|
|
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
if (timeout)
|
2006-08-19 05:47:08 +08:00
|
|
|
rport->dev_loss_tmo = timeout;
|
2005-04-18 05:05:31 +08:00
|
|
|
else
|
2006-08-19 05:47:08 +08:00
|
|
|
rport->dev_loss_tmo = 1;
|
2019-08-15 07:56:48 +08:00
|
|
|
|
|
|
|
|
if (!ndlp || !NLP_CHK_NODE_ACT(ndlp)) {
|
|
|
|
|
dev_info(&rport->dev, "Cannot find remote node to "
|
|
|
|
|
"set rport dev loss tmo, port_id x%x\n",
|
|
|
|
|
rport->port_id);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
#if (IS_ENABLED(CONFIG_NVME_FC))
|
2019-08-15 07:56:48 +08:00
|
|
|
nrport = lpfc_ndlp_get_nrport(ndlp);
|
|
|
|
|
|
|
|
|
|
if (nrport && nrport->remoteport)
|
|
|
|
|
nvme_fc_set_remoteport_devloss(nrport->remoteport,
|
|
|
|
|
rport->dev_loss_tmo);
|
|
|
|
|
#endif
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_rport_show_function - Return rport target information
|
2008-08-25 09:49:00 +08:00
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* Macro that uses field to generate a function with the name lpfc_show_rport_
|
|
|
|
|
*
|
|
|
|
|
* lpfc_show_rport_##field: returns the bytes formatted in buf
|
|
|
|
|
* @cdev: class converted to an fc_rport.
|
|
|
|
|
* @buf: on return contains the target_field or zero.
|
|
|
|
|
*
|
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
#define lpfc_rport_show_function(field, format_string, sz, cast) \
|
|
|
|
|
static ssize_t \
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_show_rport_##field (struct device *dev, \
|
|
|
|
|
struct device_attribute *attr, \
|
|
|
|
|
char *buf) \
|
2005-04-18 05:05:31 +08:00
|
|
|
{ \
|
2008-02-22 07:13:36 +08:00
|
|
|
struct fc_rport *rport = transport_class_to_rport(dev); \
|
2005-04-18 05:05:31 +08:00
|
|
|
struct lpfc_rport_data *rdata = rport->hostdata; \
|
scsi: lpfc: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: James Smart <james.smart@broadcom.com>
Cc: Dick Kennedy <dick.kennedy@broadcom.com>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-03-22 00:44:32 +08:00
|
|
|
return scnprintf(buf, sz, format_string, \
|
2005-04-18 05:05:31 +08:00
|
|
|
(rdata->target) ? cast rdata->target->field : 0); \
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#define lpfc_rport_rd_attr(field, format_string, sz) \
|
|
|
|
|
lpfc_rport_show_function(field, format_string, sz, ) \
|
|
|
|
|
static FC_RPORT_ATTR(field, S_IRUGO, lpfc_show_rport_##field, NULL)
|
|
|
|
|
|
2008-12-05 11:39:13 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_set_vport_symbolic_name - Set the vport's symbolic name
|
2008-12-05 11:39:13 +08:00
|
|
|
* @fc_vport: The fc_vport who's symbolic name has been changed.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* This function is called by the transport after the @fc_vport's symbolic name
|
|
|
|
|
* has been changed. This function re-registers the symbolic name with the
|
2011-03-31 09:57:33 +08:00
|
|
|
* switch to propagate the change into the fabric if the vport is active.
|
2008-12-05 11:39:13 +08:00
|
|
|
**/
|
|
|
|
|
static void
|
|
|
|
|
lpfc_set_vport_symbolic_name(struct fc_vport *fc_vport)
|
|
|
|
|
{
|
|
|
|
|
struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data;
|
|
|
|
|
|
|
|
|
|
if (vport->port_state == LPFC_VPORT_READY)
|
|
|
|
|
lpfc_ns_cmd(vport, SLI_CTNS_RSPN_ID, 0, 0);
|
|
|
|
|
}
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2009-05-23 02:53:12 +08:00
|
|
|
/**
|
|
|
|
|
* lpfc_hba_log_verbose_init - Set hba's log verbose level
|
|
|
|
|
* @phba: Pointer to lpfc_hba struct.
|
|
|
|
|
*
|
|
|
|
|
* This function is called by the lpfc_get_cfgparam() routine to set the
|
|
|
|
|
* module lpfc_log_verbose into the @phba cfg_log_verbose for use with
|
2011-05-10 16:16:21 +08:00
|
|
|
* log message according to the module's lpfc_log_verbose parameter setting
|
2009-05-23 02:53:12 +08:00
|
|
|
* before hba port or vport created.
|
|
|
|
|
**/
|
|
|
|
|
static void
|
|
|
|
|
lpfc_hba_log_verbose_init(struct lpfc_hba *phba, uint32_t verbose)
|
|
|
|
|
{
|
|
|
|
|
phba->cfg_log_verbose = verbose;
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
struct fc_function_template lpfc_transport_functions = {
|
|
|
|
|
/* fixed attributes the driver supports */
|
|
|
|
|
.show_host_node_name = 1,
|
|
|
|
|
.show_host_port_name = 1,
|
|
|
|
|
.show_host_supported_classes = 1,
|
|
|
|
|
.show_host_supported_fc4s = 1,
|
|
|
|
|
.show_host_supported_speeds = 1,
|
|
|
|
|
.show_host_maxframe_size = 1,
|
2016-12-20 07:07:24 +08:00
|
|
|
|
|
|
|
|
.get_host_symbolic_name = lpfc_get_host_symbolic_name,
|
2008-12-05 11:39:13 +08:00
|
|
|
.show_host_symbolic_name = 1,
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
|
/* dynamic attributes the driver supports */
|
|
|
|
|
.get_host_port_id = lpfc_get_host_port_id,
|
|
|
|
|
.show_host_port_id = 1,
|
|
|
|
|
|
|
|
|
|
.get_host_port_type = lpfc_get_host_port_type,
|
|
|
|
|
.show_host_port_type = 1,
|
|
|
|
|
|
|
|
|
|
.get_host_port_state = lpfc_get_host_port_state,
|
|
|
|
|
.show_host_port_state = 1,
|
|
|
|
|
|
|
|
|
|
/* active_fc4s is shown but doesn't change (thus no get function) */
|
|
|
|
|
.show_host_active_fc4s = 1,
|
|
|
|
|
|
|
|
|
|
.get_host_speed = lpfc_get_host_speed,
|
|
|
|
|
.show_host_speed = 1,
|
|
|
|
|
|
|
|
|
|
.get_host_fabric_name = lpfc_get_host_fabric_name,
|
|
|
|
|
.show_host_fabric_name = 1,
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* The LPFC driver treats linkdown handling as target loss events
|
|
|
|
|
* so there are no sysfs handlers for link_down_tmo.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
.get_fc_host_stats = lpfc_get_stats,
|
2006-08-03 03:24:34 +08:00
|
|
|
.reset_fc_host_stats = lpfc_reset_stats,
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
|
.dd_fcrport_size = sizeof(struct lpfc_rport_data),
|
|
|
|
|
.show_rport_maxframe_size = 1,
|
|
|
|
|
.show_rport_supported_classes = 1,
|
|
|
|
|
|
|
|
|
|
.set_rport_dev_loss_tmo = lpfc_set_rport_loss_tmo,
|
|
|
|
|
.show_rport_dev_loss_tmo = 1,
|
|
|
|
|
|
|
|
|
|
.get_starget_port_id = lpfc_get_starget_port_id,
|
|
|
|
|
.show_starget_port_id = 1,
|
|
|
|
|
|
|
|
|
|
.get_starget_node_name = lpfc_get_starget_node_name,
|
|
|
|
|
.show_starget_node_name = 1,
|
|
|
|
|
|
|
|
|
|
.get_starget_port_name = lpfc_get_starget_port_name,
|
|
|
|
|
.show_starget_port_name = 1,
|
2005-10-28 07:03:37 +08:00
|
|
|
|
|
|
|
|
.issue_fc_host_lip = lpfc_issue_lip,
|
2006-08-19 05:47:08 +08:00
|
|
|
.dev_loss_tmo_callbk = lpfc_dev_loss_tmo_callbk,
|
|
|
|
|
.terminate_rport_io = lpfc_terminate_rport_io,
|
2007-06-18 08:56:38 +08:00
|
|
|
|
|
|
|
|
.dd_fcvport_size = sizeof(struct lpfc_vport *),
|
2008-12-05 11:39:13 +08:00
|
|
|
|
|
|
|
|
.vport_disable = lpfc_vport_disable,
|
|
|
|
|
|
|
|
|
|
.set_vport_symbolic_name = lpfc_set_vport_symbolic_name,
|
2009-07-19 22:01:32 +08:00
|
|
|
|
|
|
|
|
.bsg_request = lpfc_bsg_request,
|
|
|
|
|
.bsg_timeout = lpfc_bsg_timeout,
|
2007-06-18 08:56:38 +08:00
|
|
|
};
|
|
|
|
|
|
2007-10-28 01:37:33 +08:00
|
|
|
struct fc_function_template lpfc_vport_transport_functions = {
|
|
|
|
|
/* fixed attributes the driver supports */
|
|
|
|
|
.show_host_node_name = 1,
|
|
|
|
|
.show_host_port_name = 1,
|
|
|
|
|
.show_host_supported_classes = 1,
|
|
|
|
|
.show_host_supported_fc4s = 1,
|
|
|
|
|
.show_host_supported_speeds = 1,
|
|
|
|
|
.show_host_maxframe_size = 1,
|
2016-12-20 07:07:24 +08:00
|
|
|
|
|
|
|
|
.get_host_symbolic_name = lpfc_get_host_symbolic_name,
|
2008-12-05 11:39:13 +08:00
|
|
|
.show_host_symbolic_name = 1,
|
2007-10-28 01:37:33 +08:00
|
|
|
|
|
|
|
|
/* dynamic attributes the driver supports */
|
|
|
|
|
.get_host_port_id = lpfc_get_host_port_id,
|
|
|
|
|
.show_host_port_id = 1,
|
|
|
|
|
|
|
|
|
|
.get_host_port_type = lpfc_get_host_port_type,
|
|
|
|
|
.show_host_port_type = 1,
|
|
|
|
|
|
|
|
|
|
.get_host_port_state = lpfc_get_host_port_state,
|
|
|
|
|
.show_host_port_state = 1,
|
|
|
|
|
|
|
|
|
|
/* active_fc4s is shown but doesn't change (thus no get function) */
|
|
|
|
|
.show_host_active_fc4s = 1,
|
|
|
|
|
|
|
|
|
|
.get_host_speed = lpfc_get_host_speed,
|
|
|
|
|
.show_host_speed = 1,
|
|
|
|
|
|
|
|
|
|
.get_host_fabric_name = lpfc_get_host_fabric_name,
|
|
|
|
|
.show_host_fabric_name = 1,
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* The LPFC driver treats linkdown handling as target loss events
|
|
|
|
|
* so there are no sysfs handlers for link_down_tmo.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
.get_fc_host_stats = lpfc_get_stats,
|
|
|
|
|
.reset_fc_host_stats = lpfc_reset_stats,
|
|
|
|
|
|
|
|
|
|
.dd_fcrport_size = sizeof(struct lpfc_rport_data),
|
|
|
|
|
.show_rport_maxframe_size = 1,
|
|
|
|
|
.show_rport_supported_classes = 1,
|
|
|
|
|
|
|
|
|
|
.set_rport_dev_loss_tmo = lpfc_set_rport_loss_tmo,
|
|
|
|
|
.show_rport_dev_loss_tmo = 1,
|
|
|
|
|
|
|
|
|
|
.get_starget_port_id = lpfc_get_starget_port_id,
|
|
|
|
|
.show_starget_port_id = 1,
|
|
|
|
|
|
|
|
|
|
.get_starget_node_name = lpfc_get_starget_node_name,
|
|
|
|
|
.show_starget_node_name = 1,
|
|
|
|
|
|
|
|
|
|
.get_starget_port_name = lpfc_get_starget_port_name,
|
|
|
|
|
.show_starget_port_name = 1,
|
|
|
|
|
|
|
|
|
|
.dev_loss_tmo_callbk = lpfc_dev_loss_tmo_callbk,
|
|
|
|
|
.terminate_rport_io = lpfc_terminate_rport_io,
|
|
|
|
|
|
|
|
|
|
.vport_disable = lpfc_vport_disable,
|
2008-12-05 11:39:13 +08:00
|
|
|
|
|
|
|
|
.set_vport_symbolic_name = lpfc_set_vport_symbolic_name,
|
2007-10-28 01:37:33 +08:00
|
|
|
};
|
|
|
|
|
|
2019-08-15 07:57:02 +08:00
|
|
|
/**
|
|
|
|
|
* lpfc_get_hba_function_mode - Used to determine the HBA function in FCoE
|
|
|
|
|
* Mode
|
|
|
|
|
* @phba: lpfc_hba pointer.
|
|
|
|
|
**/
|
|
|
|
|
static void
|
|
|
|
|
lpfc_get_hba_function_mode(struct lpfc_hba *phba)
|
|
|
|
|
{
|
|
|
|
|
/* If it's a SkyHawk FCoE adapter */
|
|
|
|
|
if (phba->pcidev->device == PCI_DEVICE_ID_SKYHAWK)
|
|
|
|
|
phba->hba_flag |= HBA_FCOE_MODE;
|
|
|
|
|
else
|
|
|
|
|
phba->hba_flag &= ~HBA_FCOE_MODE;
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_get_cfgparam - Used during probe_one to init the adapter structure
|
2008-08-25 09:49:00 +08:00
|
|
|
* @phba: lpfc_hba pointer.
|
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
void
|
|
|
|
|
lpfc_get_cfgparam(struct lpfc_hba *phba)
|
|
|
|
|
{
|
2012-08-04 00:36:42 +08:00
|
|
|
lpfc_fcp_io_sched_init(phba, lpfc_fcp_io_sched);
|
2018-10-24 04:41:10 +08:00
|
|
|
lpfc_ns_query_init(phba, lpfc_ns_query);
|
2012-11-01 02:44:42 +08:00
|
|
|
lpfc_fcp2_no_tgt_reset_init(phba, lpfc_fcp2_no_tgt_reset);
|
2005-10-29 08:29:13 +08:00
|
|
|
lpfc_cr_delay_init(phba, lpfc_cr_delay);
|
|
|
|
|
lpfc_cr_count_init(phba, lpfc_cr_count);
|
2006-03-01 11:33:08 +08:00
|
|
|
lpfc_multi_ring_support_init(phba, lpfc_multi_ring_support);
|
2006-12-03 02:34:16 +08:00
|
|
|
lpfc_multi_ring_rctl_init(phba, lpfc_multi_ring_rctl);
|
|
|
|
|
lpfc_multi_ring_type_init(phba, lpfc_multi_ring_type);
|
2005-10-29 08:29:13 +08:00
|
|
|
lpfc_ack0_init(phba, lpfc_ack0);
|
scsi: lpfc: Adapt partitioned XRI lists to efficient sharing
The XRI get/put lists were partitioned per hardware queue. However, the
adapter rarely had sufficient resources to give a large number of resources
per queue. As such, it became common for a cpu to encounter a lack of XRI
resource and request the upper io stack to retry after returning a BUSY
condition. This occurred even though other cpus were idle and not using
their resources.
Create as efficient a scheme as possible to move resources to the cpus that
need them. Each cpu maintains a small private pool which it allocates from
for io. There is a watermark that the cpu attempts to keep in the private
pool. The private pool, when empty, pulls from a global pool from the
cpu. When the cpu's global pool is empty it will pull from other cpu's
global pool. As there many cpu global pools (1 per cpu or hardware queue
count) and as each cpu selects what cpu to pull from at different rates and
at different times, it creates a radomizing effect that minimizes the
number of cpu's that will contend with each other when the steal XRI's from
another cpu's global pool.
On io completion, a cpu will push the XRI back on to its private pool. A
watermark level is maintained for the private pool such that when it is
exceeded it will move XRI's to the CPU global pool so that other cpu's may
allocate them.
On NVME, as heartbeat commands are critical to get placed on the wire, a
single expedite pool is maintained. When a heartbeat is to be sent, it will
allocate an XRI from the expedite pool rather than the normal cpu
private/global pools. On any io completion, if a reduction in the expedite
pools is seen, it will be replenished before the XRI is placed on the cpu
private pool.
Statistics are added to aid understanding the XRI levels on each cpu and
their behaviors.
Signed-off-by: Dick Kennedy <dick.kennedy@broadcom.com>
Signed-off-by: James Smart <jsmart2021@gmail.com>
Reviewed-by: Hannes Reinecke <hare@suse.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-01-29 03:14:28 +08:00
|
|
|
lpfc_xri_rebalancing_init(phba, lpfc_xri_rebalancing);
|
2005-10-29 08:29:13 +08:00
|
|
|
lpfc_topology_init(phba, lpfc_topology);
|
|
|
|
|
lpfc_link_speed_init(phba, lpfc_link_speed);
|
[SCSI] lpfc 8.1.1 : Add polled-mode support
- Add functionality to run in polled mode only. Includes run time
attribute to enable mode.
- Enable runtime writable hba settings for coallescing and delay parameters
Customers have requested a mode in the driver to run strictly polled.
This is generally to support an environment where the server is extremely
loaded and is looking to reclaim some cpu cycles from adapter interrupt
handling.
This patch adds a new "poll" attribute, and the following behavior:
if value is 0 (default):
The driver uses the normal method for i/o completion. It uses the
firmware feature of interrupt coalesing. The firmware allows a
minimum number of i/o completions before an interrupt, or a maximum
time delay between interrupts. By default, the driver sets these
to no delay (disabled) or 1 i/o - meaning coalescing is disabled.
Attributes were provided to change the coalescing values, but it was
a module-load time only and global across all adapters.
This patch allows them to be writable on a per-adapter basis.
if value is 1 :
Interrupts are left enabled, expecting that the user has tuned the
interrupt coalescing values. When this setting is enabled, the driver
will attempt to service completed i/o whenever new i/o is submitted
to the adapter. If the coalescing values are large, and the i/o
generation rate steady, an interrupt will be avoided by servicing
completed i/o prior to the coalescing thresholds kicking in. However,
if the i/o completion load is high enough or i/o generation slow, the
coalescion values will ensure that completed i/o is serviced in a timely
fashion.
if value is 3 :
Turns off FCP i/o interrupts altogether. The coalescing values now have
no effect. A new attribute "poll_tmo" (default 10ms) exists to set
the polling interval for i/o completion. When this setting is enabled,
the driver will attempt to service completed i/o and restart the
interval timer whenever new i/o is submitted. This behavior allows for
servicing of completed i/o sooner than the interval timer, but ensures
that if no i/o is being issued, then the interval timer will kick in
to service the outstanding i/o.
Signed-off-by: James Smart <James.Smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-11-30 05:32:13 +08:00
|
|
|
lpfc_poll_tmo_init(phba, lpfc_poll_tmo);
|
2013-09-07 00:22:46 +08:00
|
|
|
lpfc_task_mgmt_tmo_init(phba, lpfc_task_mgmt_tmo);
|
2007-08-02 23:10:21 +08:00
|
|
|
lpfc_enable_npiv_init(phba, lpfc_enable_npiv);
|
2011-07-23 06:37:52 +08:00
|
|
|
lpfc_fcf_failover_policy_init(phba, lpfc_fcf_failover_policy);
|
2010-11-21 12:11:55 +08:00
|
|
|
lpfc_enable_rrq_init(phba, lpfc_enable_rrq);
|
2015-12-17 07:11:58 +08:00
|
|
|
lpfc_fdmi_on_init(phba, lpfc_fdmi_on);
|
|
|
|
|
lpfc_enable_SmartSAN_init(phba, lpfc_enable_SmartSAN);
|
2006-12-03 02:34:56 +08:00
|
|
|
lpfc_use_msi_init(phba, lpfc_use_msi);
|
2017-02-13 05:52:30 +08:00
|
|
|
lpfc_nvme_oas_init(phba, lpfc_nvme_oas);
|
2018-02-23 00:18:50 +08:00
|
|
|
lpfc_nvme_embed_cmd_init(phba, lpfc_nvme_embed_cmd);
|
2009-05-23 02:51:39 +08:00
|
|
|
lpfc_fcp_imax_init(phba, lpfc_fcp_imax);
|
2024-06-12 13:13:20 +08:00
|
|
|
lpfc_force_rscn_init(phba, lpfc_force_rscn);
|
scsi: lpfc: Rework EQ/CQ processing to address interrupt coalescing
When driving high iop counts, auto_imax coalescing kicks in and drives the
performance to extremely small iops levels.
There are two issues:
1) auto_imax is enabled by default. The auto algorithm, when iops gets
high, divides the iops by the hdwq count and uses that value to
calculate EQ_Delay. The EQ_Delay is set uniformly on all EQs whether
they have load or not. The EQ_delay is only manipulated every 5s (a
long time). Thus there were large 5s swings of no interrupt delay
followed by large/maximum delay, before repeating.
2) When processing a CQ, the driver got mixed up on the rate of when
to ring the doorbell to keep the chip appraised of the eqe or cqe
consumption as well as how how long to sit in the thread and
process queue entries. Currently, the driver capped its work at
64 entries (very small) and exited/rearmed the CQ. Thus, on heavy
loads, additional overheads were taken to exit and re-enter the
interrupt handler. Worse, if in the large/maximum coalescing
windows,k it could be a while before getting back to servicing.
The issues are corrected by the following:
- A change in defaults. Auto_imax is turned OFF and fcp_imax is set
to 0. Thus all interrupts are immediate.
- Cleanup of field names and their meanings. Existing names were
non-intuitive or used for duplicate things.
- Added max_proc_limit field, to control the length of time the
handlers would service completions.
- Reworked EQ handling:
Added common routine that walks eq, applying notify interval and max
processing limits. Use queue_claimed to claim ownership of the queue
while processing. Always rearm the queue whenever the common routine
is called.
Rework queue element processing, namely to eliminate hba_index vs
host_index. Only one index is necessary. The queue entry can be
marked invalid and the host_index updated immediately after eqe
processing.
After rework, xx_release routines are now DB write functions. Renamed
the routines as such.
Moved lpfc_sli4_eq_flush(), which does similar action, to same area.
Replaced the 2 individual loops that walk an eq with a call to the
common routine.
Slightly revised lpfc_sli4_hba_handle_eqe() calling syntax.
Added per-cpu counters to detect interrupt rates and scale
interrupt coalescing values.
- Reworked CQ handling:
Added common routine that walks cq, applying notify interval and max
processing limits. Use queue_claimed to claim ownership of the queue
while processing. Always rearm the queue whenever the common routine
is called.
Rework queue element processing, namely to eliminate hba_index vs
host_index. Only one index is necessary. The queue entry can be
marked invalid and the host_index updated immediately after cqe
processing.
After rework, xx_release routines are now DB write functions. Renamed
the routines as such.
Replaced the 3 individual loops that walk a cq with a call to the
common routine.
Redefined lpfc_sli4_sp_handle_mcqe() to commong handler definition with
queue reference. Add increment for mbox completion to handler.
- Added a new module/sysfs attribute: lpfc_cq_max_proc_limit To allow
dynamic changing of the CQ max_proc_limit value being used.
Although this leaves an EQ as an immediate interrupt, that interrupt will
only occur if a CQ bound to it is in an armed state and has cqe's to
process. By staying in the cq processing routine longer, high loads will
avoid generating more interrupts as they will only rearm as the processing
thread exits. The immediately interrupt is also beneficial to idle or
lower-processing CQ's as they get serviced immediately without being
penalized by sharing an EQ with a more loaded CQ.
Signed-off-by: Dick Kennedy <dick.kennedy@broadcom.com>
Signed-off-by: James Smart <jsmart2021@gmail.com>
Reviewed-by: Hannes Reinecke <hare@suse.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-01-29 03:14:33 +08:00
|
|
|
lpfc_cq_poll_threshold_init(phba, lpfc_cq_poll_threshold);
|
|
|
|
|
lpfc_cq_max_proc_limit_init(phba, lpfc_cq_max_proc_limit);
|
2013-04-18 08:19:16 +08:00
|
|
|
lpfc_fcp_cpu_map_init(phba, lpfc_fcp_cpu_map);
|
2008-01-11 14:52:48 +08:00
|
|
|
lpfc_enable_hba_reset_init(phba, lpfc_enable_hba_reset);
|
|
|
|
|
lpfc_enable_hba_heartbeat_init(phba, lpfc_enable_hba_heartbeat);
|
2017-02-13 05:52:27 +08:00
|
|
|
|
2014-02-20 22:56:45 +08:00
|
|
|
lpfc_EnableXLane_init(phba, lpfc_EnableXLane);
|
2024-06-12 13:13:20 +08:00
|
|
|
if (phba->sli_rev != LPFC_SLI_REV4)
|
|
|
|
|
phba->cfg_EnableXLane = 0;
|
2014-02-20 22:56:45 +08:00
|
|
|
lpfc_XLanePriority_init(phba, lpfc_XLanePriority);
|
2017-02-13 05:52:27 +08:00
|
|
|
|
2014-02-20 22:56:45 +08:00
|
|
|
memset(phba->cfg_oas_tgt_wwpn, 0, (8 * sizeof(uint8_t)));
|
|
|
|
|
memset(phba->cfg_oas_vpt_wwpn, 0, (8 * sizeof(uint8_t)));
|
|
|
|
|
phba->cfg_oas_lun_state = 0;
|
|
|
|
|
phba->cfg_oas_lun_status = 0;
|
|
|
|
|
phba->cfg_oas_flags = 0;
|
2016-07-07 03:36:05 +08:00
|
|
|
phba->cfg_oas_priority = 0;
|
2008-12-05 11:39:46 +08:00
|
|
|
lpfc_enable_bg_init(phba, lpfc_enable_bg);
|
2016-10-14 06:06:06 +08:00
|
|
|
lpfc_prot_mask_init(phba, lpfc_prot_mask);
|
|
|
|
|
lpfc_prot_guard_init(phba, lpfc_prot_guard);
|
2024-06-12 13:13:20 +08:00
|
|
|
if (phba->sli_rev == LPFC_SLI_REV4)
|
2024-06-11 20:26:44 +08:00
|
|
|
phba->cfg_poll = 0;
|
2024-06-12 13:13:20 +08:00
|
|
|
else
|
|
|
|
|
phba->cfg_poll = lpfc_poll;
|
2018-03-06 04:04:08 +08:00
|
|
|
|
2019-08-15 07:57:02 +08:00
|
|
|
/* Get the function mode */
|
|
|
|
|
lpfc_get_hba_function_mode(phba);
|
|
|
|
|
|
|
|
|
|
/* BlockGuard allowed for FC only. */
|
2024-06-12 13:13:20 +08:00
|
|
|
if (phba->cfg_enable_bg && phba->hba_flag & HBA_FCOE_MODE) {
|
2019-08-15 07:57:02 +08:00
|
|
|
lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
|
|
|
|
|
"0581 BlockGuard feature not supported\n");
|
|
|
|
|
/* If set, clear the BlockGuard support param */
|
|
|
|
|
phba->cfg_enable_bg = 0;
|
2024-06-12 13:13:20 +08:00
|
|
|
} else if (phba->cfg_enable_bg) {
|
2018-03-06 04:04:08 +08:00
|
|
|
phba->sli3_options |= LPFC_SLI3_BG_ENABLED;
|
2024-06-12 13:13:20 +08:00
|
|
|
}
|
|
|
|
|
|
2017-02-13 05:52:34 +08:00
|
|
|
lpfc_suppress_rsp_init(phba, lpfc_suppress_rsp);
|
2015-12-17 07:11:58 +08:00
|
|
|
|
2017-02-13 05:52:30 +08:00
|
|
|
lpfc_enable_fc4_type_init(phba, lpfc_enable_fc4_type);
|
2017-02-13 05:52:35 +08:00
|
|
|
lpfc_nvmet_mrq_init(phba, lpfc_nvmet_mrq);
|
2018-04-10 05:24:24 +08:00
|
|
|
lpfc_nvmet_mrq_post_init(phba, lpfc_nvmet_mrq_post);
|
2017-02-13 05:52:30 +08:00
|
|
|
|
|
|
|
|
/* Initialize first burst. Target vs Initiator are different. */
|
|
|
|
|
lpfc_nvme_enable_fb_init(phba, lpfc_nvme_enable_fb);
|
2017-02-13 05:52:35 +08:00
|
|
|
lpfc_nvmet_fb_size_init(phba, lpfc_nvmet_fb_size);
|
scsi: lpfc: Mitigate high memory pre-allocation by SCSI-MQ
When SCSI-MQ is enabled, the SCSI-MQ layers will do pre-allocation of MQ
resources based on shost values set by the driver. In newer cases of the
driver, which attempts to set nr_hw_queues to the cpu count, the
multipliers become excessive, with a single shost having SCSI-MQ
pre-allocation reaching into the multiple GBytes range. NPIV, which
creates additional shosts, only multiply this overhead. On lower-memory
systems, this can exhaust system memory very quickly, resulting in a system
crash or failures in the driver or elsewhere due to low memory conditions.
After testing several scenarios, the situation can be mitigated by limiting
the value set in shost->nr_hw_queues to 4. Although the shost values were
changed, the driver still had per-cpu hardware queues of its own that
allowed parallelization per-cpu. Testing revealed that even with the
smallish number for nr_hw_queues for SCSI-MQ, performance levels remained
near maximum with the within-driver affiinitization.
A module parameter was created to allow the value set for the nr_hw_queues
to be tunable.
Signed-off-by: Dick Kennedy <dick.kennedy@broadcom.com>
Signed-off-by: James Smart <jsmart2021@gmail.com>
Reviewed-by: Ming Lei <ming.lei@redhat.com>
Reviewed-by: Ewan D. Milne <emilne@redhat.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-08-16 10:36:49 +08:00
|
|
|
lpfc_fcp_mq_threshold_init(phba, lpfc_fcp_mq_threshold);
|
scsi: lpfc: Replace io_channels for nvme and fcp with general hdw_queues per cpu
Currently, both nvme and fcp each have their own concept of an io_channel,
which is a combination wq/cq and associated msix. Different cpus would
share an io_channel.
The driver is now moving to per-cpu wq/cq pairs and msix vectors. The
driver will still use separate wq/cq pairs per protocol on each cpu, but
the protocols will share the msix vector.
Given the elimination of the nvme and fcp io channels, the module
parameters will be removed. A new parameter, lpfc_hdw_queue is added which
allows the wq/cq pair allocation per cpu to be overridden and allocated to
lesser value. If lpfc_hdw_queue is zero, the number of pairs allocated will
be based on the number of cpus. If non-zero, the parameter specifies the
number of queues to allocate. At this time, the maximum non-zero value is
64.
To manage this new paradigm, a new hardware queue structure is created to
track queue activity and relationships.
As MSIX vector allocation must be known before setting up the
relationships, msix allocation now occurs before queue datastructures are
allocated. If the number of vectors allocated is less than the desired
hardware queues, the hardware queue counts will be reduced to the number of
vectors
Signed-off-by: Dick Kennedy <dick.kennedy@broadcom.com>
Signed-off-by: James Smart <jsmart2021@gmail.com>
Reviewed-by: Hannes Reinecke <hare@suse.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-01-29 03:14:21 +08:00
|
|
|
lpfc_hdw_queue_init(phba, lpfc_hdw_queue);
|
2019-01-29 03:14:31 +08:00
|
|
|
lpfc_irq_chann_init(phba, lpfc_irq_chann);
|
2017-08-24 07:55:47 +08:00
|
|
|
lpfc_enable_bbcr_init(phba, lpfc_enable_bbcr);
|
2018-02-23 00:18:43 +08:00
|
|
|
lpfc_enable_dpp_init(phba, lpfc_enable_dpp);
|
2017-02-13 05:52:30 +08:00
|
|
|
|
|
|
|
|
if (phba->sli_rev != LPFC_SLI_REV4) {
|
|
|
|
|
/* NVME only supported on SLI4 */
|
|
|
|
|
phba->nvmet_support = 0;
|
2019-03-13 07:30:10 +08:00
|
|
|
phba->cfg_nvmet_mrq = 0;
|
2017-02-13 05:52:30 +08:00
|
|
|
phba->cfg_enable_fc4_type = LPFC_ENABLE_FCP;
|
2017-08-24 07:55:47 +08:00
|
|
|
phba->cfg_enable_bbcr = 0;
|
scsi: lpfc: Adapt partitioned XRI lists to efficient sharing
The XRI get/put lists were partitioned per hardware queue. However, the
adapter rarely had sufficient resources to give a large number of resources
per queue. As such, it became common for a cpu to encounter a lack of XRI
resource and request the upper io stack to retry after returning a BUSY
condition. This occurred even though other cpus were idle and not using
their resources.
Create as efficient a scheme as possible to move resources to the cpus that
need them. Each cpu maintains a small private pool which it allocates from
for io. There is a watermark that the cpu attempts to keep in the private
pool. The private pool, when empty, pulls from a global pool from the
cpu. When the cpu's global pool is empty it will pull from other cpu's
global pool. As there many cpu global pools (1 per cpu or hardware queue
count) and as each cpu selects what cpu to pull from at different rates and
at different times, it creates a radomizing effect that minimizes the
number of cpu's that will contend with each other when the steal XRI's from
another cpu's global pool.
On io completion, a cpu will push the XRI back on to its private pool. A
watermark level is maintained for the private pool such that when it is
exceeded it will move XRI's to the CPU global pool so that other cpu's may
allocate them.
On NVME, as heartbeat commands are critical to get placed on the wire, a
single expedite pool is maintained. When a heartbeat is to be sent, it will
allocate an XRI from the expedite pool rather than the normal cpu
private/global pools. On any io completion, if a reduction in the expedite
pools is seen, it will be replenished before the XRI is placed on the cpu
private pool.
Statistics are added to aid understanding the XRI levels on each cpu and
their behaviors.
Signed-off-by: Dick Kennedy <dick.kennedy@broadcom.com>
Signed-off-by: James Smart <jsmart2021@gmail.com>
Reviewed-by: Hannes Reinecke <hare@suse.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-01-29 03:14:28 +08:00
|
|
|
phba->cfg_xri_rebalancing = 0;
|
2017-02-13 05:52:30 +08:00
|
|
|
} else {
|
|
|
|
|
/* We MUST have FCP support */
|
|
|
|
|
if (!(phba->cfg_enable_fc4_type & LPFC_ENABLE_FCP))
|
|
|
|
|
phba->cfg_enable_fc4_type |= LPFC_ENABLE_FCP;
|
|
|
|
|
}
|
|
|
|
|
|
scsi: lpfc: Rework EQ/CQ processing to address interrupt coalescing
When driving high iop counts, auto_imax coalescing kicks in and drives the
performance to extremely small iops levels.
There are two issues:
1) auto_imax is enabled by default. The auto algorithm, when iops gets
high, divides the iops by the hdwq count and uses that value to
calculate EQ_Delay. The EQ_Delay is set uniformly on all EQs whether
they have load or not. The EQ_delay is only manipulated every 5s (a
long time). Thus there were large 5s swings of no interrupt delay
followed by large/maximum delay, before repeating.
2) When processing a CQ, the driver got mixed up on the rate of when
to ring the doorbell to keep the chip appraised of the eqe or cqe
consumption as well as how how long to sit in the thread and
process queue entries. Currently, the driver capped its work at
64 entries (very small) and exited/rearmed the CQ. Thus, on heavy
loads, additional overheads were taken to exit and re-enter the
interrupt handler. Worse, if in the large/maximum coalescing
windows,k it could be a while before getting back to servicing.
The issues are corrected by the following:
- A change in defaults. Auto_imax is turned OFF and fcp_imax is set
to 0. Thus all interrupts are immediate.
- Cleanup of field names and their meanings. Existing names were
non-intuitive or used for duplicate things.
- Added max_proc_limit field, to control the length of time the
handlers would service completions.
- Reworked EQ handling:
Added common routine that walks eq, applying notify interval and max
processing limits. Use queue_claimed to claim ownership of the queue
while processing. Always rearm the queue whenever the common routine
is called.
Rework queue element processing, namely to eliminate hba_index vs
host_index. Only one index is necessary. The queue entry can be
marked invalid and the host_index updated immediately after eqe
processing.
After rework, xx_release routines are now DB write functions. Renamed
the routines as such.
Moved lpfc_sli4_eq_flush(), which does similar action, to same area.
Replaced the 2 individual loops that walk an eq with a call to the
common routine.
Slightly revised lpfc_sli4_hba_handle_eqe() calling syntax.
Added per-cpu counters to detect interrupt rates and scale
interrupt coalescing values.
- Reworked CQ handling:
Added common routine that walks cq, applying notify interval and max
processing limits. Use queue_claimed to claim ownership of the queue
while processing. Always rearm the queue whenever the common routine
is called.
Rework queue element processing, namely to eliminate hba_index vs
host_index. Only one index is necessary. The queue entry can be
marked invalid and the host_index updated immediately after cqe
processing.
After rework, xx_release routines are now DB write functions. Renamed
the routines as such.
Replaced the 3 individual loops that walk a cq with a call to the
common routine.
Redefined lpfc_sli4_sp_handle_mcqe() to commong handler definition with
queue reference. Add increment for mbox completion to handler.
- Added a new module/sysfs attribute: lpfc_cq_max_proc_limit To allow
dynamic changing of the CQ max_proc_limit value being used.
Although this leaves an EQ as an immediate interrupt, that interrupt will
only occur if a CQ bound to it is in an armed state and has cqe's to
process. By staying in the cq processing routine longer, high loads will
avoid generating more interrupts as they will only rearm as the processing
thread exits. The immediately interrupt is also beneficial to idle or
lower-processing CQ's as they get serviced immediately without being
penalized by sharing an EQ with a more loaded CQ.
Signed-off-by: Dick Kennedy <dick.kennedy@broadcom.com>
Signed-off-by: James Smart <jsmart2021@gmail.com>
Reviewed-by: Hannes Reinecke <hare@suse.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-01-29 03:14:33 +08:00
|
|
|
phba->cfg_auto_imax = (phba->cfg_fcp_imax) ? 0 : 1;
|
2024-06-12 13:13:20 +08:00
|
|
|
|
2018-08-01 08:23:24 +08:00
|
|
|
phba->cfg_enable_pbde = 0;
|
|
|
|
|
|
2017-02-13 05:52:30 +08:00
|
|
|
/* A value of 0 means use the number of CPUs found in the system */
|
scsi: lpfc: Replace io_channels for nvme and fcp with general hdw_queues per cpu
Currently, both nvme and fcp each have their own concept of an io_channel,
which is a combination wq/cq and associated msix. Different cpus would
share an io_channel.
The driver is now moving to per-cpu wq/cq pairs and msix vectors. The
driver will still use separate wq/cq pairs per protocol on each cpu, but
the protocols will share the msix vector.
Given the elimination of the nvme and fcp io channels, the module
parameters will be removed. A new parameter, lpfc_hdw_queue is added which
allows the wq/cq pair allocation per cpu to be overridden and allocated to
lesser value. If lpfc_hdw_queue is zero, the number of pairs allocated will
be based on the number of cpus. If non-zero, the parameter specifies the
number of queues to allocate. At this time, the maximum non-zero value is
64.
To manage this new paradigm, a new hardware queue structure is created to
track queue activity and relationships.
As MSIX vector allocation must be known before setting up the
relationships, msix allocation now occurs before queue datastructures are
allocated. If the number of vectors allocated is less than the desired
hardware queues, the hardware queue counts will be reduced to the number of
vectors
Signed-off-by: Dick Kennedy <dick.kennedy@broadcom.com>
Signed-off-by: James Smart <jsmart2021@gmail.com>
Reviewed-by: Hannes Reinecke <hare@suse.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-01-29 03:14:21 +08:00
|
|
|
if (phba->cfg_hdw_queue == 0)
|
|
|
|
|
phba->cfg_hdw_queue = phba->sli4_hba.num_present_cpu;
|
2019-01-29 03:14:31 +08:00
|
|
|
if (phba->cfg_irq_chann == 0)
|
|
|
|
|
phba->cfg_irq_chann = phba->sli4_hba.num_present_cpu;
|
|
|
|
|
if (phba->cfg_irq_chann > phba->cfg_hdw_queue)
|
|
|
|
|
phba->cfg_irq_chann = phba->cfg_hdw_queue;
|
2015-12-17 07:11:58 +08:00
|
|
|
|
2024-06-12 13:13:20 +08:00
|
|
|
phba->cfg_soft_wwnn = 0L;
|
|
|
|
|
phba->cfg_soft_wwpn = 0L;
|
2008-01-11 14:53:09 +08:00
|
|
|
lpfc_sg_seg_cnt_init(phba, lpfc_sg_seg_cnt);
|
2007-04-25 21:52:34 +08:00
|
|
|
lpfc_hba_queue_depth_init(phba, lpfc_hba_queue_depth);
|
2024-06-12 13:13:20 +08:00
|
|
|
lpfc_hba_log_verbose_init(phba, lpfc_log_verbose);
|
2009-10-03 03:16:56 +08:00
|
|
|
lpfc_aer_support_init(phba, lpfc_aer_support);
|
2011-05-24 23:42:11 +08:00
|
|
|
lpfc_sriov_nr_virtfn_init(phba, lpfc_sriov_nr_virtfn);
|
2012-11-01 02:44:33 +08:00
|
|
|
lpfc_request_firmware_upgrade_init(phba, lpfc_req_fw_upgrade);
|
2010-02-13 03:42:33 +08:00
|
|
|
lpfc_suppress_link_up_init(phba, lpfc_suppress_link_up);
|
2024-06-12 13:13:20 +08:00
|
|
|
lpfc_iocb_cnt_init(phba, lpfc_iocb_cnt);
|
2016-07-07 03:36:08 +08:00
|
|
|
lpfc_delay_discovery_init(phba, lpfc_delay_discovery);
|
2016-07-07 03:36:09 +08:00
|
|
|
lpfc_sli_mode_init(phba, lpfc_sli_mode);
|
2024-06-12 13:13:20 +08:00
|
|
|
phba->cfg_enable_dss = 1;
|
2016-07-07 03:36:00 +08:00
|
|
|
lpfc_enable_mds_diags_init(phba, lpfc_enable_mds_diags);
|
2018-09-11 01:30:50 +08:00
|
|
|
lpfc_ras_fwlog_buffsize_init(phba, lpfc_ras_fwlog_buffsize);
|
|
|
|
|
lpfc_ras_fwlog_level_init(phba, lpfc_ras_fwlog_level);
|
|
|
|
|
lpfc_ras_fwlog_func_init(phba, lpfc_ras_fwlog_func);
|
|
|
|
|
|
2007-08-02 23:09:59 +08:00
|
|
|
return;
|
|
|
|
|
}
|
2006-03-01 08:25:21 +08:00
|
|
|
|
2017-02-13 05:52:30 +08:00
|
|
|
/**
|
|
|
|
|
* lpfc_nvme_mod_param_dep - Adjust module parameter value based on
|
|
|
|
|
* dependencies between protocols and roles.
|
|
|
|
|
* @phba: lpfc_hba pointer.
|
|
|
|
|
**/
|
|
|
|
|
void
|
|
|
|
|
lpfc_nvme_mod_param_dep(struct lpfc_hba *phba)
|
|
|
|
|
{
|
2024-06-12 13:13:20 +08:00
|
|
|
if (phba->cfg_hdw_queue > phba->sli4_hba.num_present_cpu)
|
scsi: lpfc: Replace io_channels for nvme and fcp with general hdw_queues per cpu
Currently, both nvme and fcp each have their own concept of an io_channel,
which is a combination wq/cq and associated msix. Different cpus would
share an io_channel.
The driver is now moving to per-cpu wq/cq pairs and msix vectors. The
driver will still use separate wq/cq pairs per protocol on each cpu, but
the protocols will share the msix vector.
Given the elimination of the nvme and fcp io channels, the module
parameters will be removed. A new parameter, lpfc_hdw_queue is added which
allows the wq/cq pair allocation per cpu to be overridden and allocated to
lesser value. If lpfc_hdw_queue is zero, the number of pairs allocated will
be based on the number of cpus. If non-zero, the parameter specifies the
number of queues to allocate. At this time, the maximum non-zero value is
64.
To manage this new paradigm, a new hardware queue structure is created to
track queue activity and relationships.
As MSIX vector allocation must be known before setting up the
relationships, msix allocation now occurs before queue datastructures are
allocated. If the number of vectors allocated is less than the desired
hardware queues, the hardware queue counts will be reduced to the number of
vectors
Signed-off-by: Dick Kennedy <dick.kennedy@broadcom.com>
Signed-off-by: James Smart <jsmart2021@gmail.com>
Reviewed-by: Hannes Reinecke <hare@suse.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-01-29 03:14:21 +08:00
|
|
|
phba->cfg_hdw_queue = phba->sli4_hba.num_present_cpu;
|
2024-06-12 13:13:20 +08:00
|
|
|
if (phba->cfg_irq_chann > phba->sli4_hba.num_present_cpu)
|
2019-01-29 03:14:31 +08:00
|
|
|
phba->cfg_irq_chann = phba->sli4_hba.num_present_cpu;
|
2024-06-12 13:13:20 +08:00
|
|
|
if (phba->cfg_irq_chann > phba->cfg_hdw_queue)
|
2019-01-29 03:14:31 +08:00
|
|
|
phba->cfg_irq_chann = phba->cfg_hdw_queue;
|
2017-02-13 05:52:30 +08:00
|
|
|
|
2017-02-13 05:52:34 +08:00
|
|
|
if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME &&
|
|
|
|
|
phba->nvmet_support) {
|
|
|
|
|
phba->cfg_enable_fc4_type &= ~LPFC_ENABLE_FCP;
|
2017-02-13 05:52:35 +08:00
|
|
|
|
|
|
|
|
lpfc_printf_log(phba, KERN_INFO, LOG_NVME_DISC,
|
|
|
|
|
"6013 %s x%x fb_size x%x, fb_max x%x\n",
|
|
|
|
|
"NVME Target PRLI ACC enable_fb ",
|
|
|
|
|
phba->cfg_nvme_enable_fb,
|
|
|
|
|
phba->cfg_nvmet_fb_size,
|
|
|
|
|
LPFC_NVMET_FB_SZ_MAX);
|
|
|
|
|
|
|
|
|
|
if (phba->cfg_nvme_enable_fb == 0)
|
|
|
|
|
phba->cfg_nvmet_fb_size = 0;
|
|
|
|
|
else {
|
|
|
|
|
if (phba->cfg_nvmet_fb_size > LPFC_NVMET_FB_SZ_MAX)
|
|
|
|
|
phba->cfg_nvmet_fb_size = LPFC_NVMET_FB_SZ_MAX;
|
|
|
|
|
}
|
|
|
|
|
|
2017-11-21 08:00:36 +08:00
|
|
|
if (!phba->cfg_nvmet_mrq)
|
2024-06-12 13:13:20 +08:00
|
|
|
phba->cfg_nvmet_mrq = phba->cfg_irq_chann;
|
2017-11-21 08:00:36 +08:00
|
|
|
|
2017-02-13 05:52:35 +08:00
|
|
|
/* Adjust lpfc_nvmet_mrq to avoid running out of WQE slots */
|
2024-06-12 13:13:20 +08:00
|
|
|
if (phba->cfg_nvmet_mrq > phba->cfg_irq_chann) {
|
|
|
|
|
phba->cfg_nvmet_mrq = phba->cfg_irq_chann;
|
2017-02-13 05:52:35 +08:00
|
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_NVME_DISC,
|
|
|
|
|
"6018 Adjust lpfc_nvmet_mrq to %d\n",
|
|
|
|
|
phba->cfg_nvmet_mrq);
|
|
|
|
|
}
|
2017-11-21 08:00:36 +08:00
|
|
|
if (phba->cfg_nvmet_mrq > LPFC_NVMET_MRQ_MAX)
|
|
|
|
|
phba->cfg_nvmet_mrq = LPFC_NVMET_MRQ_MAX;
|
|
|
|
|
|
2017-02-13 05:52:35 +08:00
|
|
|
} else {
|
2017-02-13 05:52:34 +08:00
|
|
|
/* Not NVME Target mode. Turn off Target parameters. */
|
|
|
|
|
phba->nvmet_support = 0;
|
2019-03-13 07:30:10 +08:00
|
|
|
phba->cfg_nvmet_mrq = 0;
|
2017-02-13 05:52:35 +08:00
|
|
|
phba->cfg_nvmet_fb_size = 0;
|
|
|
|
|
}
|
2017-02-13 05:52:30 +08:00
|
|
|
}
|
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2009-04-07 06:47:14 +08:00
|
|
|
* lpfc_get_vport_cfgparam - Used during port create, init the vport structure
|
2008-08-25 09:49:00 +08:00
|
|
|
* @vport: lpfc_vport pointer.
|
|
|
|
|
**/
|
2007-08-02 23:09:59 +08:00
|
|
|
void
|
|
|
|
|
lpfc_get_vport_cfgparam(struct lpfc_vport *vport)
|
|
|
|
|
{
|
2007-08-02 23:10:09 +08:00
|
|
|
lpfc_log_verbose_init(vport, lpfc_log_verbose);
|
2007-08-02 23:09:59 +08:00
|
|
|
lpfc_lun_queue_depth_init(vport, lpfc_lun_queue_depth);
|
2010-07-15 03:32:10 +08:00
|
|
|
lpfc_tgt_queue_depth_init(vport, lpfc_tgt_queue_depth);
|
2007-08-02 23:09:59 +08:00
|
|
|
lpfc_devloss_tmo_init(vport, lpfc_devloss_tmo);
|
|
|
|
|
lpfc_nodev_tmo_init(vport, lpfc_nodev_tmo);
|
|
|
|
|
lpfc_peer_port_login_init(vport, lpfc_peer_port_login);
|
|
|
|
|
lpfc_restrict_login_init(vport, lpfc_restrict_login);
|
|
|
|
|
lpfc_fcp_class_init(vport, lpfc_fcp_class);
|
|
|
|
|
lpfc_use_adisc_init(vport, lpfc_use_adisc);
|
2013-07-16 06:35:04 +08:00
|
|
|
lpfc_first_burst_size_init(vport, lpfc_first_burst_size);
|
2008-09-07 23:52:04 +08:00
|
|
|
lpfc_max_scsicmpl_time_init(vport, lpfc_max_scsicmpl_time);
|
2007-08-02 23:09:59 +08:00
|
|
|
lpfc_discovery_threads_init(vport, lpfc_discovery_threads);
|
|
|
|
|
lpfc_max_luns_init(vport, lpfc_max_luns);
|
|
|
|
|
lpfc_scan_down_init(vport, lpfc_scan_down);
|
2007-10-28 01:37:17 +08:00
|
|
|
lpfc_enable_da_id_init(vport, lpfc_enable_da_id);
|
2005-04-18 05:05:31 +08:00
|
|
|
return;
|
|
|
|
|
}
|