blob: c714482bf4c5587b90b607c8d5ec4f62cf5b628e [file] [log] [blame]
James Smart92d7f7b2007-06-17 19:56:38 -05001/*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
3 * Fibre Channel Host Bus Adapters. *
James Smartd080abe2017-02-12 13:52:39 -08004 * Copyright (C) 2017 Broadcom. All Rights Reserved. The term *
5 * “Broadcom” refers to Broadcom Limited and/or its subsidiaries. *
James Smart50611572016-03-31 14:12:34 -07006 * Copyright (C) 2004-2016 Emulex. All rights reserved. *
James Smart92d7f7b2007-06-17 19:56:38 -05007 * EMULEX and SLI are trademarks of Emulex. *
James Smartd080abe2017-02-12 13:52:39 -08008 * www.broadcom.com *
James Smart92d7f7b2007-06-17 19:56:38 -05009 * Portions Copyright (C) 2004-2005 Christoph Hellwig *
10 * *
11 * This program is free software; you can redistribute it and/or *
12 * modify it under the terms of version 2 of the GNU General *
13 * Public License as published by the Free Software Foundation. *
14 * This program is distributed in the hope that it will be useful. *
15 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND *
16 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, *
17 * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE *
18 * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
19 * TO BE LEGALLY INVALID. See the GNU General Public License for *
20 * more details, a copy of which can be found in the file COPYING *
21 * included with this package. *
22 *******************************************************************/
23
24#include <linux/blkdev.h>
25#include <linux/delay.h>
26#include <linux/dma-mapping.h>
27#include <linux/idr.h>
28#include <linux/interrupt.h>
29#include <linux/kthread.h>
30#include <linux/pci.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090031#include <linux/slab.h>
James Smart92d7f7b2007-06-17 19:56:38 -050032#include <linux/spinlock.h>
Ingo Molnar174cd4b2017-02-02 19:15:33 +010033#include <linux/sched/signal.h>
James Smart92d7f7b2007-06-17 19:56:38 -050034
35#include <scsi/scsi.h>
36#include <scsi/scsi_device.h>
37#include <scsi/scsi_host.h>
38#include <scsi/scsi_transport_fc.h>
James Smart2ea259e2017-02-12 13:52:27 -080039
James Smartda0436e2009-05-22 14:51:39 -040040#include "lpfc_hw4.h"
James Smart92d7f7b2007-06-17 19:56:38 -050041#include "lpfc_hw.h"
42#include "lpfc_sli.h"
James Smartda0436e2009-05-22 14:51:39 -040043#include "lpfc_sli4.h"
James Smartea2151b2008-09-07 11:52:10 -040044#include "lpfc_nl.h"
James Smart92d7f7b2007-06-17 19:56:38 -050045#include "lpfc_disc.h"
46#include "lpfc_scsi.h"
47#include "lpfc.h"
48#include "lpfc_logmsg.h"
49#include "lpfc_crtn.h"
50#include "lpfc_version.h"
51#include "lpfc_vport.h"
52
53inline void lpfc_vport_set_state(struct lpfc_vport *vport,
54 enum fc_vport_state new_state)
55{
56 struct fc_vport *fc_vport = vport->fc_vport;
57
58 if (fc_vport) {
59 /*
60 * When the transport defines fc_vport_set state we will replace
61 * this code with the following line
62 */
63 /* fc_vport_set_state(fc_vport, new_state); */
64 if (new_state != FC_VPORT_INITIALIZING)
65 fc_vport->vport_last_state = fc_vport->vport_state;
66 fc_vport->vport_state = new_state;
67 }
68
69 /* for all the error states we will set the invternal state to FAILED */
70 switch (new_state) {
71 case FC_VPORT_NO_FABRIC_SUPP:
72 case FC_VPORT_NO_FABRIC_RSCS:
73 case FC_VPORT_FABRIC_LOGOUT:
74 case FC_VPORT_FABRIC_REJ_WWN:
75 case FC_VPORT_FAILED:
76 vport->port_state = LPFC_VPORT_FAILED;
77 break;
78 case FC_VPORT_LINKDOWN:
79 vport->port_state = LPFC_VPORT_UNKNOWN;
80 break;
81 default:
82 /* do nothing */
83 break;
84 }
85}
86
James Smart16a3a202013-04-17 20:14:38 -040087int
James Smart92d7f7b2007-06-17 19:56:38 -050088lpfc_alloc_vpi(struct lpfc_hba *phba)
89{
James Smart6d368e52011-05-24 11:44:12 -040090 unsigned long vpi;
James Smart92d7f7b2007-06-17 19:56:38 -050091
92 spin_lock_irq(&phba->hbalock);
James Smart858c9f62007-06-17 19:56:39 -050093 /* Start at bit 1 because vpi zero is reserved for the physical port */
94 vpi = find_next_zero_bit(phba->vpi_bmask, (phba->max_vpi + 1), 1);
James Smart92d7f7b2007-06-17 19:56:38 -050095 if (vpi > phba->max_vpi)
96 vpi = 0;
97 else
98 set_bit(vpi, phba->vpi_bmask);
James Smartda0436e2009-05-22 14:51:39 -040099 if (phba->sli_rev == LPFC_SLI_REV4)
100 phba->sli4_hba.max_cfg_param.vpi_used++;
James Smart92d7f7b2007-06-17 19:56:38 -0500101 spin_unlock_irq(&phba->hbalock);
102 return vpi;
103}
104
105static void
106lpfc_free_vpi(struct lpfc_hba *phba, int vpi)
107{
James Smartda0436e2009-05-22 14:51:39 -0400108 if (vpi == 0)
109 return;
James Smart92d7f7b2007-06-17 19:56:38 -0500110 spin_lock_irq(&phba->hbalock);
111 clear_bit(vpi, phba->vpi_bmask);
James Smartda0436e2009-05-22 14:51:39 -0400112 if (phba->sli_rev == LPFC_SLI_REV4)
113 phba->sli4_hba.max_cfg_param.vpi_used--;
James Smart92d7f7b2007-06-17 19:56:38 -0500114 spin_unlock_irq(&phba->hbalock);
115}
116
117static int
118lpfc_vport_sparm(struct lpfc_hba *phba, struct lpfc_vport *vport)
119{
120 LPFC_MBOXQ_t *pmb;
121 MAILBOX_t *mb;
122 struct lpfc_dmabuf *mp;
123 int rc;
124
125 pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
126 if (!pmb) {
127 return -ENOMEM;
128 }
James Smartf4b4c682009-05-22 14:53:12 -0400129 mb = &pmb->u.mb;
James Smart92d7f7b2007-06-17 19:56:38 -0500130
James Smart9f1177a2010-02-26 14:12:57 -0500131 rc = lpfc_read_sparam(phba, pmb, vport->vpi);
132 if (rc) {
133 mempool_free(pmb, phba->mbox_mem_pool);
134 return -ENOMEM;
135 }
136
James Smart92d7f7b2007-06-17 19:56:38 -0500137 /*
138 * Grab buffer pointer and clear context1 so we can use
139 * lpfc_sli_issue_box_wait
140 */
141 mp = (struct lpfc_dmabuf *) pmb->context1;
142 pmb->context1 = NULL;
143
144 pmb->vport = vport;
145 rc = lpfc_sli_issue_mbox_wait(phba, pmb, phba->fc_ratov * 2);
146 if (rc != MBX_SUCCESS) {
James Smart98c9ea52007-10-27 13:37:33 -0400147 if (signal_pending(current)) {
148 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT | LOG_VPORT,
149 "1830 Signal aborted mbxCmd x%x\n",
150 mb->mbxCommand);
151 lpfc_mbuf_free(phba, mp->virt, mp->phys);
152 kfree(mp);
153 if (rc != MBX_TIMEOUT)
154 mempool_free(pmb, phba->mbox_mem_pool);
155 return -EINTR;
156 } else {
157 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT | LOG_VPORT,
158 "1818 VPort failed init, mbxCmd x%x "
159 "READ_SPARM mbxStatus x%x, rc = x%x\n",
160 mb->mbxCommand, mb->mbxStatus, rc);
161 lpfc_mbuf_free(phba, mp->virt, mp->phys);
162 kfree(mp);
163 if (rc != MBX_TIMEOUT)
164 mempool_free(pmb, phba->mbox_mem_pool);
165 return -EIO;
166 }
James Smart92d7f7b2007-06-17 19:56:38 -0500167 }
168
169 memcpy(&vport->fc_sparam, mp->virt, sizeof (struct serv_parm));
170 memcpy(&vport->fc_nodename, &vport->fc_sparam.nodeName,
171 sizeof (struct lpfc_name));
172 memcpy(&vport->fc_portname, &vport->fc_sparam.portName,
173 sizeof (struct lpfc_name));
174
175 lpfc_mbuf_free(phba, mp->virt, mp->phys);
176 kfree(mp);
177 mempool_free(pmb, phba->mbox_mem_pool);
178
179 return 0;
180}
181
182static int
183lpfc_valid_wwn_format(struct lpfc_hba *phba, struct lpfc_name *wwn,
184 const char *name_type)
185{
186 /* ensure that IEEE format 1 addresses
187 * contain zeros in bits 59-48
188 */
189 if (!((wwn->u.wwn[0] >> 4) == 1 &&
190 ((wwn->u.wwn[0] & 0xf) != 0 || (wwn->u.wwn[1] & 0xf) != 0)))
191 return 1;
192
193 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
James Smarte8b62012007-08-02 11:10:09 -0400194 "1822 Invalid %s: %02x:%02x:%02x:%02x:"
James Smart92d7f7b2007-06-17 19:56:38 -0500195 "%02x:%02x:%02x:%02x\n",
James Smarte8b62012007-08-02 11:10:09 -0400196 name_type,
James Smart92d7f7b2007-06-17 19:56:38 -0500197 wwn->u.wwn[0], wwn->u.wwn[1],
198 wwn->u.wwn[2], wwn->u.wwn[3],
199 wwn->u.wwn[4], wwn->u.wwn[5],
200 wwn->u.wwn[6], wwn->u.wwn[7]);
201 return 0;
202}
203
204static int
205lpfc_unique_wwpn(struct lpfc_hba *phba, struct lpfc_vport *new_vport)
206{
207 struct lpfc_vport *vport;
James Smart549e55c2007-08-02 11:09:51 -0400208 unsigned long flags;
James Smart92d7f7b2007-06-17 19:56:38 -0500209
James Smart549e55c2007-08-02 11:09:51 -0400210 spin_lock_irqsave(&phba->hbalock, flags);
James Smart92d7f7b2007-06-17 19:56:38 -0500211 list_for_each_entry(vport, &phba->port_list, listentry) {
212 if (vport == new_vport)
213 continue;
214 /* If they match, return not unique */
215 if (memcmp(&vport->fc_sparam.portName,
James Smart549e55c2007-08-02 11:09:51 -0400216 &new_vport->fc_sparam.portName,
217 sizeof(struct lpfc_name)) == 0) {
218 spin_unlock_irqrestore(&phba->hbalock, flags);
James Smart92d7f7b2007-06-17 19:56:38 -0500219 return 0;
James Smart549e55c2007-08-02 11:09:51 -0400220 }
James Smart92d7f7b2007-06-17 19:56:38 -0500221 }
James Smart549e55c2007-08-02 11:09:51 -0400222 spin_unlock_irqrestore(&phba->hbalock, flags);
James Smart92d7f7b2007-06-17 19:56:38 -0500223 return 1;
224}
225
James Smart90160e02008-08-24 21:49:45 -0400226/**
James Smart3621a712009-04-06 18:47:14 -0400227 * lpfc_discovery_wait - Wait for driver discovery to quiesce
James Smart90160e02008-08-24 21:49:45 -0400228 * @vport: The virtual port for which this call is being executed.
229 *
230 * This driver calls this routine specifically from lpfc_vport_delete
231 * to enforce a synchronous execution of vport
232 * delete relative to discovery activities. The
233 * lpfc_vport_delete routine should not return until it
234 * can reasonably guarantee that discovery has quiesced.
235 * Post FDISC LOGO, the driver must wait until its SAN teardown is
236 * complete and all resources recovered before allowing
237 * cleanup.
238 *
239 * This routine does not require any locks held.
240 **/
241static void lpfc_discovery_wait(struct lpfc_vport *vport)
242{
243 struct lpfc_hba *phba = vport->phba;
244 uint32_t wait_flags = 0;
245 unsigned long wait_time_max;
246 unsigned long start_time;
247
248 wait_flags = FC_RSCN_MODE | FC_RSCN_DISCOVERY | FC_NLP_MORE |
249 FC_RSCN_DEFERRED | FC_NDISC_ACTIVE | FC_DISC_TMO;
250
251 /*
252 * The time constraint on this loop is a balance between the
253 * fabric RA_TOV value and dev_loss tmo. The driver's
254 * devloss_tmo is 10 giving this loop a 3x multiplier minimally.
255 */
256 wait_time_max = msecs_to_jiffies(((phba->fc_ratov * 3) + 3) * 1000);
257 wait_time_max += jiffies;
258 start_time = jiffies;
259 while (time_before(jiffies, wait_time_max)) {
260 if ((vport->num_disc_nodes > 0) ||
261 (vport->fc_flag & wait_flags) ||
262 ((vport->port_state > LPFC_VPORT_FAILED) &&
263 (vport->port_state < LPFC_VPORT_READY))) {
James Smart21e9a0a2009-05-22 14:53:21 -0400264 lpfc_printf_vlog(vport, KERN_INFO, LOG_VPORT,
James Smart90160e02008-08-24 21:49:45 -0400265 "1833 Vport discovery quiesce Wait:"
James Smart21e9a0a2009-05-22 14:53:21 -0400266 " state x%x fc_flags x%x"
James Smart90160e02008-08-24 21:49:45 -0400267 " num_nodes x%x, waiting 1000 msecs"
268 " total wait msecs x%x\n",
James Smart21e9a0a2009-05-22 14:53:21 -0400269 vport->port_state, vport->fc_flag,
270 vport->num_disc_nodes,
James Smart90160e02008-08-24 21:49:45 -0400271 jiffies_to_msecs(jiffies - start_time));
272 msleep(1000);
273 } else {
274 /* Base case. Wait variants satisfied. Break out */
James Smart21e9a0a2009-05-22 14:53:21 -0400275 lpfc_printf_vlog(vport, KERN_INFO, LOG_VPORT,
James Smart90160e02008-08-24 21:49:45 -0400276 "1834 Vport discovery quiesced:"
James Smart21e9a0a2009-05-22 14:53:21 -0400277 " state x%x fc_flags x%x"
James Smart90160e02008-08-24 21:49:45 -0400278 " wait msecs x%x\n",
James Smart21e9a0a2009-05-22 14:53:21 -0400279 vport->port_state, vport->fc_flag,
James Smart90160e02008-08-24 21:49:45 -0400280 jiffies_to_msecs(jiffies
281 - start_time));
282 break;
283 }
284 }
285
286 if (time_after(jiffies, wait_time_max))
James Smart21e9a0a2009-05-22 14:53:21 -0400287 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
James Smart90160e02008-08-24 21:49:45 -0400288 "1835 Vport discovery quiesce failed:"
James Smart21e9a0a2009-05-22 14:53:21 -0400289 " state x%x fc_flags x%x wait msecs x%x\n",
290 vport->port_state, vport->fc_flag,
James Smart90160e02008-08-24 21:49:45 -0400291 jiffies_to_msecs(jiffies - start_time));
292}
293
James Smart92d7f7b2007-06-17 19:56:38 -0500294int
295lpfc_vport_create(struct fc_vport *fc_vport, bool disable)
296{
297 struct lpfc_nodelist *ndlp;
James Smart3de2a652007-08-02 11:09:59 -0400298 struct Scsi_Host *shost = fc_vport->shost;
299 struct lpfc_vport *pport = (struct lpfc_vport *) shost->hostdata;
James Smart92d7f7b2007-06-17 19:56:38 -0500300 struct lpfc_hba *phba = pport->phba;
301 struct lpfc_vport *vport = NULL;
302 int instance;
303 int vpi;
304 int rc = VPORT_ERROR;
James Smart98c9ea52007-10-27 13:37:33 -0400305 int status;
James Smart92d7f7b2007-06-17 19:56:38 -0500306
James Smarteada2722008-12-04 22:39:13 -0500307 if ((phba->sli_rev < 3) || !(phba->cfg_enable_npiv)) {
James Smart92d7f7b2007-06-17 19:56:38 -0500308 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
James Smarte8b62012007-08-02 11:10:09 -0400309 "1808 Create VPORT failed: "
James Smart92d7f7b2007-06-17 19:56:38 -0500310 "NPIV is not enabled: SLImode:%d\n",
James Smarte8b62012007-08-02 11:10:09 -0400311 phba->sli_rev);
James Smart92d7f7b2007-06-17 19:56:38 -0500312 rc = VPORT_INVAL;
313 goto error_out;
314 }
315
316 vpi = lpfc_alloc_vpi(phba);
317 if (vpi == 0) {
318 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
James Smarte8b62012007-08-02 11:10:09 -0400319 "1809 Create VPORT failed: "
James Smart92d7f7b2007-06-17 19:56:38 -0500320 "Max VPORTs (%d) exceeded\n",
James Smarte8b62012007-08-02 11:10:09 -0400321 phba->max_vpi);
James Smart92d7f7b2007-06-17 19:56:38 -0500322 rc = VPORT_NORESOURCES;
323 goto error_out;
324 }
325
James Smart92d7f7b2007-06-17 19:56:38 -0500326 /* Assign an unused board number */
327 if ((instance = lpfc_get_instance()) < 0) {
328 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
James Smarte8b62012007-08-02 11:10:09 -0400329 "1810 Create VPORT failed: Cannot get "
330 "instance number\n");
James Smart92d7f7b2007-06-17 19:56:38 -0500331 lpfc_free_vpi(phba, vpi);
332 rc = VPORT_NORESOURCES;
333 goto error_out;
334 }
335
James Smart3de2a652007-08-02 11:09:59 -0400336 vport = lpfc_create_port(phba, instance, &fc_vport->dev);
James Smart92d7f7b2007-06-17 19:56:38 -0500337 if (!vport) {
338 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
James Smarte8b62012007-08-02 11:10:09 -0400339 "1811 Create VPORT failed: vpi x%x\n", vpi);
James Smart92d7f7b2007-06-17 19:56:38 -0500340 lpfc_free_vpi(phba, vpi);
341 rc = VPORT_NORESOURCES;
342 goto error_out;
343 }
344
345 vport->vpi = vpi;
James Smart858c9f62007-06-17 19:56:39 -0500346 lpfc_debugfs_initialize(vport);
347
James Smart98c9ea52007-10-27 13:37:33 -0400348 if ((status = lpfc_vport_sparm(phba, vport))) {
349 if (status == -EINTR) {
350 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
351 "1831 Create VPORT Interrupted.\n");
352 rc = VPORT_ERROR;
353 } else {
354 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
355 "1813 Create VPORT failed. "
356 "Cannot get sparam\n");
357 rc = VPORT_NORESOURCES;
358 }
James Smart92d7f7b2007-06-17 19:56:38 -0500359 lpfc_free_vpi(phba, vpi);
360 destroy_port(vport);
James Smart92d7f7b2007-06-17 19:56:38 -0500361 goto error_out;
362 }
363
James Smart1c6834a2009-07-19 10:01:26 -0400364 u64_to_wwn(fc_vport->node_name, vport->fc_nodename.u.wwn);
365 u64_to_wwn(fc_vport->port_name, vport->fc_portname.u.wwn);
James Smart92d7f7b2007-06-17 19:56:38 -0500366
367 memcpy(&vport->fc_sparam.portName, vport->fc_portname.u.wwn, 8);
368 memcpy(&vport->fc_sparam.nodeName, vport->fc_nodename.u.wwn, 8);
369
370 if (!lpfc_valid_wwn_format(phba, &vport->fc_sparam.nodeName, "WWNN") ||
371 !lpfc_valid_wwn_format(phba, &vport->fc_sparam.portName, "WWPN")) {
James Smarte8b62012007-08-02 11:10:09 -0400372 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
373 "1821 Create VPORT failed. "
374 "Invalid WWN format\n");
James Smart92d7f7b2007-06-17 19:56:38 -0500375 lpfc_free_vpi(phba, vpi);
376 destroy_port(vport);
377 rc = VPORT_INVAL;
378 goto error_out;
379 }
380
381 if (!lpfc_unique_wwpn(phba, vport)) {
James Smarte8b62012007-08-02 11:10:09 -0400382 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
383 "1823 Create VPORT failed. "
384 "Duplicate WWN on HBA\n");
James Smart92d7f7b2007-06-17 19:56:38 -0500385 lpfc_free_vpi(phba, vpi);
386 destroy_port(vport);
387 rc = VPORT_INVAL;
388 goto error_out;
389 }
390
James Smarteada2722008-12-04 22:39:13 -0500391 /* Create binary sysfs attribute for vport */
392 lpfc_alloc_sysfs_attr(vport);
393
James Smart572709e2013-07-15 18:32:43 -0400394 /* Set the DFT_LUN_Q_DEPTH accordingly */
395 vport->cfg_lun_queue_depth = phba->pport->cfg_lun_queue_depth;
396
James Smart92d7f7b2007-06-17 19:56:38 -0500397 *(struct lpfc_vport **)fc_vport->dd_data = vport;
398 vport->fc_vport = fc_vport;
399
James Smart4258e982015-12-16 18:11:58 -0500400 /* At this point we are fully registered with SCSI Layer. */
401 vport->load_flag |= FC_ALLOW_FDMI;
James Smart8663cbb2016-03-31 14:12:33 -0700402 if (phba->cfg_enable_SmartSAN ||
403 (phba->cfg_fdmi_on == LPFC_FDMI_SUPPORT)) {
James Smart4258e982015-12-16 18:11:58 -0500404 /* Setup appropriate attribute masks */
405 vport->fdmi_hba_mask = phba->pport->fdmi_hba_mask;
406 vport->fdmi_port_mask = phba->pport->fdmi_port_mask;
407 }
408
James Smart01649562017-02-12 13:52:32 -0800409 if ((phba->nvmet_support == 0) &&
410 ((phba->cfg_enable_fc4_type == LPFC_ENABLE_BOTH) ||
411 (phba->cfg_enable_fc4_type == LPFC_ENABLE_NVME))) {
412 /* Create NVME binding with nvme_fc_transport. This
413 * ensures the vport is initialized.
414 */
415 rc = lpfc_nvme_create_localport(vport);
416 if (rc) {
417 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
418 "6003 %s status x%x\n",
419 "NVME registration failed, ",
420 rc);
421 goto error_out;
422 }
423 }
James Smart895427b2017-02-12 13:52:30 -0800424
James Smart1c6834a2009-07-19 10:01:26 -0400425 /*
426 * In SLI4, the vpi must be activated before it can be used
427 * by the port.
428 */
429 if ((phba->sli_rev == LPFC_SLI_REV4) &&
James Smart76a95d72010-11-20 23:11:48 -0500430 (pport->fc_flag & FC_VFI_REGISTERED)) {
431 rc = lpfc_sli4_init_vpi(vport);
James Smart1c6834a2009-07-19 10:01:26 -0400432 if (rc) {
433 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
434 "1838 Failed to INIT_VPI on vpi %d "
435 "status %d\n", vpi, rc);
436 rc = VPORT_NORESOURCES;
437 lpfc_free_vpi(phba, vpi);
438 goto error_out;
439 }
440 } else if (phba->sli_rev == LPFC_SLI_REV4) {
441 /*
442 * Driver cannot INIT_VPI now. Set the flags to
443 * init_vpi when reg_vfi complete.
444 */
445 vport->fc_flag |= FC_VPORT_NEEDS_INIT_VPI;
446 lpfc_vport_set_state(vport, FC_VPORT_LINKDOWN);
447 rc = VPORT_OK;
448 goto out;
449 }
450
James Smart92d7f7b2007-06-17 19:56:38 -0500451 if ((phba->link_state < LPFC_LINK_UP) ||
James Smart1c6834a2009-07-19 10:01:26 -0400452 (pport->port_state < LPFC_FABRIC_CFG_LINK) ||
James Smart76a95d72010-11-20 23:11:48 -0500453 (phba->fc_topology == LPFC_TOPOLOGY_LOOP)) {
James Smart92d7f7b2007-06-17 19:56:38 -0500454 lpfc_vport_set_state(vport, FC_VPORT_LINKDOWN);
455 rc = VPORT_OK;
456 goto out;
457 }
458
459 if (disable) {
James Smarteada2722008-12-04 22:39:13 -0500460 lpfc_vport_set_state(vport, FC_VPORT_DISABLED);
James Smart92d7f7b2007-06-17 19:56:38 -0500461 rc = VPORT_OK;
462 goto out;
463 }
464
465 /* Use the Physical nodes Fabric NDLP to determine if the link is
466 * up and ready to FDISC.
467 */
468 ndlp = lpfc_findnode_did(phba->pport, Fabric_DID);
James Smarte47c9092008-02-08 18:49:26 -0500469 if (ndlp && NLP_CHK_NODE_ACT(ndlp) &&
470 ndlp->nlp_state == NLP_STE_UNMAPPED_NODE) {
James Smart858c9f62007-06-17 19:56:39 -0500471 if (phba->link_flag & LS_NPIV_FAB_SUPPORTED) {
472 lpfc_set_disctmo(vport);
473 lpfc_initial_fdisc(vport);
474 } else {
475 lpfc_vport_set_state(vport, FC_VPORT_NO_FABRIC_SUPP);
James Smarte8b62012007-08-02 11:10:09 -0400476 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
477 "0262 No NPIV Fabric support\n");
James Smart858c9f62007-06-17 19:56:39 -0500478 }
James Smart92d7f7b2007-06-17 19:56:38 -0500479 } else {
480 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
481 }
482 rc = VPORT_OK;
483
484out:
James Smarta58cbd52007-08-02 11:09:43 -0400485 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
486 "1825 Vport Created.\n");
James Smart92d7f7b2007-06-17 19:56:38 -0500487 lpfc_host_attrib_init(lpfc_shost_from_vport(vport));
488error_out:
489 return rc;
490}
491
James Smart311464e2007-08-02 11:10:37 -0400492static int
James Smart92d7f7b2007-06-17 19:56:38 -0500493disable_vport(struct fc_vport *fc_vport)
494{
495 struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data;
496 struct lpfc_hba *phba = vport->phba;
497 struct lpfc_nodelist *ndlp = NULL, *next_ndlp = NULL;
498 long timeout;
James Smartfedd3b72011-02-16 12:39:24 -0500499 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
James Smart92d7f7b2007-06-17 19:56:38 -0500500
501 ndlp = lpfc_findnode_did(vport, Fabric_DID);
James Smarte47c9092008-02-08 18:49:26 -0500502 if (ndlp && NLP_CHK_NODE_ACT(ndlp)
503 && phba->link_state >= LPFC_LINK_UP) {
James Smart92d7f7b2007-06-17 19:56:38 -0500504 vport->unreg_vpi_cmpl = VPORT_INVAL;
505 timeout = msecs_to_jiffies(phba->fc_ratov * 2000);
506 if (!lpfc_issue_els_npiv_logo(vport, ndlp))
507 while (vport->unreg_vpi_cmpl == VPORT_INVAL && timeout)
508 timeout = schedule_timeout(timeout);
509 }
510
511 lpfc_sli_host_down(vport);
512
513 /* Mark all nodes for discovery so we can remove them by
514 * calling lpfc_cleanup_rpis(vport, 1)
515 */
516 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
James Smarte47c9092008-02-08 18:49:26 -0500517 if (!NLP_CHK_NODE_ACT(ndlp))
518 continue;
James Smart92d7f7b2007-06-17 19:56:38 -0500519 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
520 continue;
521 lpfc_disc_state_machine(vport, ndlp, NULL,
522 NLP_EVT_DEVICE_RECOVERY);
523 }
524 lpfc_cleanup_rpis(vport, 1);
525
526 lpfc_stop_vport_timers(vport);
527 lpfc_unreg_all_rpis(vport);
528 lpfc_unreg_default_rpis(vport);
529 /*
530 * Completion of unreg_vpi (lpfc_mbx_cmpl_unreg_vpi) does the
531 * scsi_host_put() to release the vport.
532 */
533 lpfc_mbx_unreg_vpi(vport);
James Smartfedd3b72011-02-16 12:39:24 -0500534 spin_lock_irq(shost->host_lock);
535 vport->fc_flag |= FC_VPORT_NEEDS_INIT_VPI;
536 spin_unlock_irq(shost->host_lock);
James Smart92d7f7b2007-06-17 19:56:38 -0500537
538 lpfc_vport_set_state(vport, FC_VPORT_DISABLED);
James Smarta58cbd52007-08-02 11:09:43 -0400539 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
540 "1826 Vport Disabled.\n");
James Smart92d7f7b2007-06-17 19:56:38 -0500541 return VPORT_OK;
542}
543
James Smart311464e2007-08-02 11:10:37 -0400544static int
James Smart92d7f7b2007-06-17 19:56:38 -0500545enable_vport(struct fc_vport *fc_vport)
546{
547 struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data;
548 struct lpfc_hba *phba = vport->phba;
549 struct lpfc_nodelist *ndlp = NULL;
James Smart72100cc2010-02-12 14:43:01 -0500550 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
James Smart92d7f7b2007-06-17 19:56:38 -0500551
552 if ((phba->link_state < LPFC_LINK_UP) ||
James Smart76a95d72010-11-20 23:11:48 -0500553 (phba->fc_topology == LPFC_TOPOLOGY_LOOP)) {
James Smart92d7f7b2007-06-17 19:56:38 -0500554 lpfc_vport_set_state(vport, FC_VPORT_LINKDOWN);
555 return VPORT_OK;
556 }
557
James Smart72100cc2010-02-12 14:43:01 -0500558 spin_lock_irq(shost->host_lock);
James Smart92d7f7b2007-06-17 19:56:38 -0500559 vport->load_flag |= FC_LOADING;
James Smart104450e2016-12-19 15:07:25 -0800560 if (vport->fc_flag & FC_VPORT_NEEDS_INIT_VPI) {
561 spin_unlock_irq(shost->host_lock);
562 lpfc_issue_init_vpi(vport);
563 goto out;
564 }
565
James Smart92d7f7b2007-06-17 19:56:38 -0500566 vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
James Smart72100cc2010-02-12 14:43:01 -0500567 spin_unlock_irq(shost->host_lock);
James Smart92d7f7b2007-06-17 19:56:38 -0500568
569 /* Use the Physical nodes Fabric NDLP to determine if the link is
570 * up and ready to FDISC.
571 */
572 ndlp = lpfc_findnode_did(phba->pport, Fabric_DID);
James Smarte47c9092008-02-08 18:49:26 -0500573 if (ndlp && NLP_CHK_NODE_ACT(ndlp)
574 && ndlp->nlp_state == NLP_STE_UNMAPPED_NODE) {
James Smart858c9f62007-06-17 19:56:39 -0500575 if (phba->link_flag & LS_NPIV_FAB_SUPPORTED) {
576 lpfc_set_disctmo(vport);
577 lpfc_initial_fdisc(vport);
578 } else {
579 lpfc_vport_set_state(vport, FC_VPORT_NO_FABRIC_SUPP);
James Smarte8b62012007-08-02 11:10:09 -0400580 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
581 "0264 No NPIV Fabric support\n");
James Smart858c9f62007-06-17 19:56:39 -0500582 }
James Smart92d7f7b2007-06-17 19:56:38 -0500583 } else {
584 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
585 }
James Smart104450e2016-12-19 15:07:25 -0800586
587out:
James Smarta58cbd52007-08-02 11:09:43 -0400588 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
589 "1827 Vport Enabled.\n");
James Smart92d7f7b2007-06-17 19:56:38 -0500590 return VPORT_OK;
591}
592
593int
594lpfc_vport_disable(struct fc_vport *fc_vport, bool disable)
595{
596 if (disable)
597 return disable_vport(fc_vport);
598 else
599 return enable_vport(fc_vport);
600}
601
602
603int
604lpfc_vport_delete(struct fc_vport *fc_vport)
605{
606 struct lpfc_nodelist *ndlp = NULL;
James Smart92d7f7b2007-06-17 19:56:38 -0500607 struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data;
James Smartcc823552015-05-21 13:55:26 -0400608 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
James Smart92d7f7b2007-06-17 19:56:38 -0500609 struct lpfc_hba *phba = vport->phba;
610 long timeout;
James Smart16a3a202013-04-17 20:14:38 -0400611 bool ns_ndlp_referenced = false;
James Smart92d7f7b2007-06-17 19:56:38 -0500612
James Smart51ef4c22007-08-02 11:10:31 -0400613 if (vport->port_type == LPFC_PHYSICAL_PORT) {
614 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
615 "1812 vport_delete failed: Cannot delete "
616 "physical host\n");
617 return VPORT_ERROR;
618 }
James Smart21e9a0a2009-05-22 14:53:21 -0400619
620 /* If the vport is a static vport fail the deletion. */
621 if ((vport->vport_flag & STATIC_VPORT) &&
622 !(phba->pport->load_flag & FC_UNLOADING)) {
623 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
624 "1837 vport_delete failed: Cannot delete "
625 "static vport.\n");
626 return VPORT_ERROR;
627 }
James Smartd439d282010-09-29 11:18:45 -0400628 spin_lock_irq(&phba->hbalock);
629 vport->load_flag |= FC_UNLOADING;
630 spin_unlock_irq(&phba->hbalock);
James Smart51ef4c22007-08-02 11:10:31 -0400631 /*
632 * If we are not unloading the driver then prevent the vport_delete
633 * from happening until after this vport's discovery is finished.
634 */
635 if (!(phba->pport->load_flag & FC_UNLOADING)) {
636 int check_count = 0;
637 while (check_count < ((phba->fc_ratov * 3) + 3) &&
638 vport->port_state > LPFC_VPORT_FAILED &&
639 vport->port_state < LPFC_VPORT_READY) {
640 check_count++;
641 msleep(1000);
642 }
643 if (vport->port_state > LPFC_VPORT_FAILED &&
644 vport->port_state < LPFC_VPORT_READY)
645 return -EAGAIN;
646 }
James Smart92d7f7b2007-06-17 19:56:38 -0500647 /*
648 * This is a bit of a mess. We want to ensure the shost doesn't get
649 * torn down until we're done with the embedded lpfc_vport structure.
650 *
651 * Beyond holding a reference for this function, we also need a
652 * reference for outstanding I/O requests we schedule during delete
653 * processing. But once we scsi_remove_host() we can no longer obtain
654 * a reference through scsi_host_get().
655 *
656 * So we take two references here. We release one reference at the
657 * bottom of the function -- after delinking the vport. And we
658 * release the other at the completion of the unreg_vpi that get's
659 * initiated after we've disposed of all other resources associated
660 * with the port.
661 */
James Smartd7c255b2008-08-24 21:50:00 -0400662 if (!scsi_host_get(shost))
James Smart92d7f7b2007-06-17 19:56:38 -0500663 return VPORT_INVAL;
James Smartd7c255b2008-08-24 21:50:00 -0400664 if (!scsi_host_get(shost)) {
665 scsi_host_put(shost);
666 return VPORT_INVAL;
667 }
James Smarteada2722008-12-04 22:39:13 -0500668 lpfc_free_sysfs_attr(vport);
669
James Smart858c9f62007-06-17 19:56:39 -0500670 lpfc_debugfs_terminate(vport);
James Smarteada2722008-12-04 22:39:13 -0500671
James Smart16a3a202013-04-17 20:14:38 -0400672 /*
673 * The call to fc_remove_host might release the NameServer ndlp. Since
674 * we might need to use the ndlp to send the DA_ID CT command,
675 * increment the reference for the NameServer ndlp to prevent it from
676 * being released.
677 */
678 ndlp = lpfc_findnode_did(vport, NameServer_DID);
679 if (ndlp && NLP_CHK_NODE_ACT(ndlp)) {
680 lpfc_nlp_get(ndlp);
681 ns_ndlp_referenced = true;
682 }
683
James Smarteada2722008-12-04 22:39:13 -0500684 /* Remove FC host and then SCSI host with the vport */
James Smartcc823552015-05-21 13:55:26 -0400685 fc_remove_host(shost);
686 scsi_remove_host(shost);
James Smart92d7f7b2007-06-17 19:56:38 -0500687
688 ndlp = lpfc_findnode_did(phba->pport, Fabric_DID);
James Smarte47c9092008-02-08 18:49:26 -0500689
690 /* In case of driver unload, we shall not perform fabric logo as the
691 * worker thread already stopped at this stage and, in this case, we
692 * can safely skip the fabric logo.
693 */
694 if (phba->pport->load_flag & FC_UNLOADING) {
695 if (ndlp && NLP_CHK_NODE_ACT(ndlp) &&
696 ndlp->nlp_state == NLP_STE_UNMAPPED_NODE &&
697 phba->link_state >= LPFC_LINK_UP) {
698 /* First look for the Fabric ndlp */
699 ndlp = lpfc_findnode_did(vport, Fabric_DID);
700 if (!ndlp)
701 goto skip_logo;
702 else if (!NLP_CHK_NODE_ACT(ndlp)) {
703 ndlp = lpfc_enable_node(vport, ndlp,
704 NLP_STE_UNUSED_NODE);
705 if (!ndlp)
706 goto skip_logo;
707 }
708 /* Remove ndlp from vport npld list */
709 lpfc_dequeue_node(vport, ndlp);
710
711 /* Indicate free memory when release */
712 spin_lock_irq(&phba->ndlp_lock);
713 NLP_SET_FREE_REQ(ndlp);
714 spin_unlock_irq(&phba->ndlp_lock);
715 /* Kick off release ndlp when it can be safely done */
716 lpfc_nlp_put(ndlp);
717 }
718 goto skip_logo;
719 }
720
721 /* Otherwise, we will perform fabric logo as needed */
722 if (ndlp && NLP_CHK_NODE_ACT(ndlp) &&
723 ndlp->nlp_state == NLP_STE_UNMAPPED_NODE &&
James Smart58da1ff2008-04-07 10:15:56 -0400724 phba->link_state >= LPFC_LINK_UP &&
James Smart76a95d72010-11-20 23:11:48 -0500725 phba->fc_topology != LPFC_TOPOLOGY_LOOP) {
James Smart7ee5d432007-10-27 13:37:17 -0400726 if (vport->cfg_enable_da_id) {
727 timeout = msecs_to_jiffies(phba->fc_ratov * 2000);
728 if (!lpfc_ns_cmd(vport, SLI_CTNS_DA_ID, 0, 0))
729 while (vport->ct_flags && timeout)
730 timeout = schedule_timeout(timeout);
731 else
732 lpfc_printf_log(vport->phba, KERN_WARNING,
733 LOG_VPORT,
734 "1829 CT command failed to "
James Smarte4e74272009-07-19 10:01:38 -0400735 "delete objects on fabric\n");
James Smart7ee5d432007-10-27 13:37:17 -0400736 }
James Smart92d7f7b2007-06-17 19:56:38 -0500737 /* First look for the Fabric ndlp */
738 ndlp = lpfc_findnode_did(vport, Fabric_DID);
739 if (!ndlp) {
740 /* Cannot find existing Fabric ndlp, allocate one */
James Smart9d3d3402017-04-21 16:05:00 -0700741 ndlp = lpfc_nlp_init(vport, Fabric_DID);
James Smart92d7f7b2007-06-17 19:56:38 -0500742 if (!ndlp)
743 goto skip_logo;
James Smarte47c9092008-02-08 18:49:26 -0500744 /* Indicate free memory when release */
745 NLP_SET_FREE_REQ(ndlp);
James Smart92d7f7b2007-06-17 19:56:38 -0500746 } else {
James Smart73d91e52011-10-10 21:32:10 -0400747 if (!NLP_CHK_NODE_ACT(ndlp)) {
James Smarte47c9092008-02-08 18:49:26 -0500748 ndlp = lpfc_enable_node(vport, ndlp,
749 NLP_STE_UNUSED_NODE);
750 if (!ndlp)
751 goto skip_logo;
James Smart73d91e52011-10-10 21:32:10 -0400752 }
James Smarte47c9092008-02-08 18:49:26 -0500753
James Smart73d91e52011-10-10 21:32:10 -0400754 /* Remove ndlp from vport list */
James Smart92d7f7b2007-06-17 19:56:38 -0500755 lpfc_dequeue_node(vport, ndlp);
James Smarte47c9092008-02-08 18:49:26 -0500756 spin_lock_irq(&phba->ndlp_lock);
757 if (!NLP_CHK_FREE_REQ(ndlp))
758 /* Indicate free memory when release */
759 NLP_SET_FREE_REQ(ndlp);
760 else {
761 /* Skip this if ndlp is already in free mode */
762 spin_unlock_irq(&phba->ndlp_lock);
763 goto skip_logo;
764 }
765 spin_unlock_irq(&phba->ndlp_lock);
James Smart92d7f7b2007-06-17 19:56:38 -0500766 }
James Smart73d91e52011-10-10 21:32:10 -0400767
768 /*
769 * If the vpi is not registered, then a valid FDISC doesn't
770 * exist and there is no need for a ELS LOGO. Just cleanup
771 * the ndlp.
772 */
773 if (!(vport->vpi_state & LPFC_VPI_REGISTERED)) {
774 lpfc_nlp_put(ndlp);
James Smart5ffc2662009-11-18 15:39:44 -0500775 goto skip_logo;
James Smart73d91e52011-10-10 21:32:10 -0400776 }
777
James Smart92d7f7b2007-06-17 19:56:38 -0500778 vport->unreg_vpi_cmpl = VPORT_INVAL;
779 timeout = msecs_to_jiffies(phba->fc_ratov * 2000);
780 if (!lpfc_issue_els_npiv_logo(vport, ndlp))
781 while (vport->unreg_vpi_cmpl == VPORT_INVAL && timeout)
782 timeout = schedule_timeout(timeout);
783 }
784
James Smart90160e02008-08-24 21:49:45 -0400785 if (!(phba->pport->load_flag & FC_UNLOADING))
786 lpfc_discovery_wait(vport);
787
James Smart92d7f7b2007-06-17 19:56:38 -0500788skip_logo:
James Smart16a3a202013-04-17 20:14:38 -0400789
790 /*
791 * If the NameServer ndlp has been incremented to allow the DA_ID CT
792 * command to be sent, decrement the ndlp now.
793 */
794 if (ns_ndlp_referenced) {
795 ndlp = lpfc_findnode_did(vport, NameServer_DID);
796 lpfc_nlp_put(ndlp);
797 }
798
James Smart87af33f2007-10-27 13:37:43 -0400799 lpfc_cleanup(vport);
James Smart92d7f7b2007-06-17 19:56:38 -0500800 lpfc_sli_host_down(vport);
801
James Smart92d7f7b2007-06-17 19:56:38 -0500802 lpfc_stop_vport_timers(vport);
James Smart87af33f2007-10-27 13:37:43 -0400803
804 if (!(phba->pport->load_flag & FC_UNLOADING)) {
James Smarte47c9092008-02-08 18:49:26 -0500805 lpfc_unreg_all_rpis(vport);
James Smart87af33f2007-10-27 13:37:43 -0400806 lpfc_unreg_default_rpis(vport);
807 /*
808 * Completion of unreg_vpi (lpfc_mbx_cmpl_unreg_vpi)
809 * does the scsi_host_put() to release the vport.
810 */
James Smartcc823552015-05-21 13:55:26 -0400811 if (!(vport->vpi_state & LPFC_VPI_REGISTERED) ||
812 lpfc_mbx_unreg_vpi(vport))
James Smartd7c255b2008-08-24 21:50:00 -0400813 scsi_host_put(shost);
814 } else
815 scsi_host_put(shost);
James Smart92d7f7b2007-06-17 19:56:38 -0500816
817 lpfc_free_vpi(phba, vport->vpi);
818 vport->work_port_events = 0;
819 spin_lock_irq(&phba->hbalock);
820 list_del_init(&vport->listentry);
821 spin_unlock_irq(&phba->hbalock);
James Smarta58cbd52007-08-02 11:09:43 -0400822 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
823 "1828 Vport Deleted.\n");
James Smart92d7f7b2007-06-17 19:56:38 -0500824 scsi_host_put(shost);
James Smart51ef4c22007-08-02 11:10:31 -0400825 return VPORT_OK;
James Smart92d7f7b2007-06-17 19:56:38 -0500826}
827
James Smart549e55c2007-08-02 11:09:51 -0400828struct lpfc_vport **
829lpfc_create_vport_work_array(struct lpfc_hba *phba)
830{
831 struct lpfc_vport *port_iterator;
832 struct lpfc_vport **vports;
833 int index = 0;
James Smart21e9a0a2009-05-22 14:53:21 -0400834 vports = kzalloc((phba->max_vports + 1) * sizeof(struct lpfc_vport *),
James Smart549e55c2007-08-02 11:09:51 -0400835 GFP_KERNEL);
836 if (vports == NULL)
837 return NULL;
838 spin_lock_irq(&phba->hbalock);
839 list_for_each_entry(port_iterator, &phba->port_list, listentry) {
James Smartdf9e1b52011-12-13 13:22:17 -0500840 if (port_iterator->load_flag & FC_UNLOADING)
841 continue;
James Smarte8b62012007-08-02 11:10:09 -0400842 if (!scsi_host_get(lpfc_shost_from_vport(port_iterator))) {
James Smartdf9e1b52011-12-13 13:22:17 -0500843 lpfc_printf_vlog(port_iterator, KERN_ERR, LOG_VPORT,
James Smarte8b62012007-08-02 11:10:09 -0400844 "1801 Create vport work array FAILED: "
845 "cannot do scsi_host_get\n");
James Smart549e55c2007-08-02 11:09:51 -0400846 continue;
James Smarte8b62012007-08-02 11:10:09 -0400847 }
James Smart549e55c2007-08-02 11:09:51 -0400848 vports[index++] = port_iterator;
849 }
850 spin_unlock_irq(&phba->hbalock);
851 return vports;
852}
853
854void
James Smart09372822008-01-11 01:52:54 -0500855lpfc_destroy_vport_work_array(struct lpfc_hba *phba, struct lpfc_vport **vports)
James Smart549e55c2007-08-02 11:09:51 -0400856{
857 int i;
858 if (vports == NULL)
859 return;
James Smart98fc5dd2010-06-07 15:24:29 -0400860 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++)
James Smart549e55c2007-08-02 11:09:51 -0400861 scsi_host_put(lpfc_shost_from_vport(vports[i]));
862 kfree(vports);
863}
James Smartea2151b2008-09-07 11:52:10 -0400864
865
866/**
James Smart3621a712009-04-06 18:47:14 -0400867 * lpfc_vport_reset_stat_data - Reset the statistical data for the vport
James Smartea2151b2008-09-07 11:52:10 -0400868 * @vport: Pointer to vport object.
869 *
870 * This function resets the statistical data for the vport. This function
871 * is called with the host_lock held
872 **/
873void
874lpfc_vport_reset_stat_data(struct lpfc_vport *vport)
875{
876 struct lpfc_nodelist *ndlp = NULL, *next_ndlp = NULL;
877
878 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
879 if (!NLP_CHK_NODE_ACT(ndlp))
880 continue;
881 if (ndlp->lat_data)
882 memset(ndlp->lat_data, 0, LPFC_MAX_BUCKET_COUNT *
883 sizeof(struct lpfc_scsicmd_bkt));
884 }
885}
886
887
888/**
James Smart3621a712009-04-06 18:47:14 -0400889 * lpfc_alloc_bucket - Allocate data buffer required for statistical data
James Smartea2151b2008-09-07 11:52:10 -0400890 * @vport: Pointer to vport object.
891 *
892 * This function allocates data buffer required for all the FC
893 * nodes of the vport to collect statistical data.
894 **/
895void
896lpfc_alloc_bucket(struct lpfc_vport *vport)
897{
898 struct lpfc_nodelist *ndlp = NULL, *next_ndlp = NULL;
899
900 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
901 if (!NLP_CHK_NODE_ACT(ndlp))
902 continue;
903
904 kfree(ndlp->lat_data);
905 ndlp->lat_data = NULL;
906
907 if (ndlp->nlp_state == NLP_STE_MAPPED_NODE) {
908 ndlp->lat_data = kcalloc(LPFC_MAX_BUCKET_COUNT,
909 sizeof(struct lpfc_scsicmd_bkt),
910 GFP_ATOMIC);
911
912 if (!ndlp->lat_data)
913 lpfc_printf_vlog(vport, KERN_ERR, LOG_NODE,
914 "0287 lpfc_alloc_bucket failed to "
915 "allocate statistical data buffer DID "
916 "0x%x\n", ndlp->nlp_DID);
917 }
918 }
919}
920
921/**
James Smart3621a712009-04-06 18:47:14 -0400922 * lpfc_free_bucket - Free data buffer required for statistical data
James Smartea2151b2008-09-07 11:52:10 -0400923 * @vport: Pointer to vport object.
924 *
925 * Th function frees statistical data buffer of all the FC
926 * nodes of the vport.
927 **/
928void
929lpfc_free_bucket(struct lpfc_vport *vport)
930{
931 struct lpfc_nodelist *ndlp = NULL, *next_ndlp = NULL;
932
933 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
934 if (!NLP_CHK_NODE_ACT(ndlp))
935 continue;
936
937 kfree(ndlp->lat_data);
938 ndlp->lat_data = NULL;
939 }
940}