1 /*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
3 * Fibre Channel Host Bus Adapters. *
4 * Copyright (C) 2017-2023 Broadcom. All Rights Reserved. The term *
5 * “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. *
6 * Copyright (C) 2004-2016 Emulex. All rights reserved. *
7 * EMULEX and SLI are trademarks of Emulex. *
8 * www.broadcom.com *
9 * 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/interrupt.h>
25 #include <linux/dma-direction.h>
26
27 #include <scsi/scsi_transport_fc.h>
28
29 #include "lpfc_hw4.h"
30 #include "lpfc_hw.h"
31 #include "lpfc_sli.h"
32 #include "lpfc_sli4.h"
33 #include "lpfc_nl.h"
34 #include "lpfc_disc.h"
35 #include "lpfc.h"
36 #include "lpfc_crtn.h"
37
38
39 /*
40 * lpfc_get_vmid_from_hashtable - search the UUID in the hash table
41 * @vport: The virtual port for which this call is being executed.
42 * @hash: calculated hash value
43 * @buf: uuid associated with the VE
44 * Return the VMID entry associated with the UUID
45 * Make sure to acquire the appropriate lock before invoking this routine.
46 */
lpfc_get_vmid_from_hashtable(struct lpfc_vport * vport,u32 hash,u8 * buf)47 struct lpfc_vmid *lpfc_get_vmid_from_hashtable(struct lpfc_vport *vport,
48 u32 hash, u8 *buf)
49 {
50 struct lpfc_vmid *vmp;
51
52 hash_for_each_possible(vport->hash_table, vmp, hnode, hash) {
53 if (memcmp(&vmp->host_vmid[0], buf, 16) == 0)
54 return vmp;
55 }
56 return NULL;
57 }
58
59 /*
60 * lpfc_put_vmid_in_hashtable - put the VMID in the hash table
61 * @vport: The virtual port for which this call is being executed.
62 * @hash - calculated hash value
63 * @vmp: Pointer to a VMID entry representing a VM sending I/O
64 *
65 * This routine will insert the newly acquired VMID entity in the hash table.
66 * Make sure to acquire the appropriate lock before invoking this routine.
67 */
68 static void
lpfc_put_vmid_in_hashtable(struct lpfc_vport * vport,u32 hash,struct lpfc_vmid * vmp)69 lpfc_put_vmid_in_hashtable(struct lpfc_vport *vport, u32 hash,
70 struct lpfc_vmid *vmp)
71 {
72 hash_add(vport->hash_table, &vmp->hnode, hash);
73 }
74
75 /*
76 * lpfc_vmid_hash_fn - create a hash value of the UUID
77 * @vmid: uuid associated with the VE
78 * @len: length of the VMID string
79 * Returns the calculated hash value
80 */
lpfc_vmid_hash_fn(const char * vmid,int len)81 int lpfc_vmid_hash_fn(const char *vmid, int len)
82 {
83 int c;
84 int hash = 0;
85
86 if (len == 0)
87 return 0;
88 while (len--) {
89 c = *vmid++;
90 if (c >= 'A' && c <= 'Z')
91 c += 'a' - 'A';
92
93 hash = (hash + (c << LPFC_VMID_HASH_SHIFT) +
94 (c >> LPFC_VMID_HASH_SHIFT)) * 19;
95 }
96
97 return hash & LPFC_VMID_HASH_MASK;
98 }
99
100 /*
101 * lpfc_vmid_update_entry - update the vmid entry in the hash table
102 * @vport: The virtual port for which this call is being executed.
103 * @iodir: io direction
104 * @vmp: Pointer to a VMID entry representing a VM sending I/O
105 * @tag: VMID tag
106 */
lpfc_vmid_update_entry(struct lpfc_vport * vport,enum dma_data_direction iodir,struct lpfc_vmid * vmp,union lpfc_vmid_io_tag * tag)107 static void lpfc_vmid_update_entry(struct lpfc_vport *vport,
108 enum dma_data_direction iodir,
109 struct lpfc_vmid *vmp,
110 union lpfc_vmid_io_tag *tag)
111 {
112 u64 *lta;
113
114 if (vport->phba->pport->vmid_flag & LPFC_VMID_TYPE_PRIO)
115 tag->cs_ctl_vmid = vmp->un.cs_ctl_vmid;
116 else if (vport->phba->cfg_vmid_app_header)
117 tag->app_id = vmp->un.app_id;
118
119 if (iodir == DMA_TO_DEVICE)
120 vmp->io_wr_cnt++;
121 else if (iodir == DMA_FROM_DEVICE)
122 vmp->io_rd_cnt++;
123
124 /* update the last access timestamp in the table */
125 lta = per_cpu_ptr(vmp->last_io_time, raw_smp_processor_id());
126 *lta = jiffies;
127 }
128
lpfc_vmid_assign_cs_ctl(struct lpfc_vport * vport,struct lpfc_vmid * vmid)129 static void lpfc_vmid_assign_cs_ctl(struct lpfc_vport *vport,
130 struct lpfc_vmid *vmid)
131 {
132 u32 hash;
133 struct lpfc_vmid *pvmid;
134
135 if (vport->port_type == LPFC_PHYSICAL_PORT) {
136 vmid->un.cs_ctl_vmid = lpfc_vmid_get_cs_ctl(vport);
137 } else {
138 hash = lpfc_vmid_hash_fn(vmid->host_vmid, vmid->vmid_len);
139 pvmid =
140 lpfc_get_vmid_from_hashtable(vport->phba->pport, hash,
141 vmid->host_vmid);
142 if (pvmid)
143 vmid->un.cs_ctl_vmid = pvmid->un.cs_ctl_vmid;
144 else
145 vmid->un.cs_ctl_vmid = lpfc_vmid_get_cs_ctl(vport);
146 }
147 }
148
149 /*
150 * lpfc_vmid_get_appid - get the VMID associated with the UUID
151 * @vport: The virtual port for which this call is being executed.
152 * @uuid: UUID associated with the VE
153 * @cmd: address of scsi_cmd descriptor
154 * @iodir: io direction
155 * @tag: VMID tag
156 * Returns status of the function
157 */
lpfc_vmid_get_appid(struct lpfc_vport * vport,char * uuid,enum dma_data_direction iodir,union lpfc_vmid_io_tag * tag)158 int lpfc_vmid_get_appid(struct lpfc_vport *vport, char *uuid,
159 enum dma_data_direction iodir,
160 union lpfc_vmid_io_tag *tag)
161 {
162 struct lpfc_vmid *vmp = NULL;
163 int hash, len, rc = -EPERM, i;
164
165 /* check if QFPA is complete */
166 if (lpfc_vmid_is_type_priority_tag(vport) &&
167 !(vport->vmid_flag & LPFC_VMID_QFPA_CMPL) &&
168 (vport->vmid_flag & LPFC_VMID_ISSUE_QFPA)) {
169 vport->work_port_events |= WORKER_CHECK_VMID_ISSUE_QFPA;
170 return -EAGAIN;
171 }
172
173 /* search if the UUID has already been mapped to the VMID */
174 len = strlen(uuid);
175 hash = lpfc_vmid_hash_fn(uuid, len);
176
177 /* search for the VMID in the table */
178 read_lock(&vport->vmid_lock);
179 vmp = lpfc_get_vmid_from_hashtable(vport, hash, uuid);
180
181 /* if found, check if its already registered */
182 if (vmp && vmp->flag & LPFC_VMID_REGISTERED) {
183 read_unlock(&vport->vmid_lock);
184 lpfc_vmid_update_entry(vport, iodir, vmp, tag);
185 rc = 0;
186 } else if (vmp && (vmp->flag & LPFC_VMID_REQ_REGISTER ||
187 vmp->flag & LPFC_VMID_DE_REGISTER)) {
188 /* else if register or dereg request has already been sent */
189 /* Hence VMID tag will not be added for this I/O */
190 read_unlock(&vport->vmid_lock);
191 rc = -EBUSY;
192 } else {
193 /* The VMID was not found in the hashtable. At this point, */
194 /* drop the read lock first before proceeding further */
195 read_unlock(&vport->vmid_lock);
196 /* start the process to obtain one as per the */
197 /* type of the VMID indicated */
198 write_lock(&vport->vmid_lock);
199 vmp = lpfc_get_vmid_from_hashtable(vport, hash, uuid);
200
201 /* while the read lock was released, in case the entry was */
202 /* added by other context or is in process of being added */
203 if (vmp && vmp->flag & LPFC_VMID_REGISTERED) {
204 lpfc_vmid_update_entry(vport, iodir, vmp, tag);
205 write_unlock(&vport->vmid_lock);
206 return 0;
207 } else if (vmp && vmp->flag & LPFC_VMID_REQ_REGISTER) {
208 write_unlock(&vport->vmid_lock);
209 return -EBUSY;
210 }
211
212 /* else search and allocate a free slot in the hash table */
213 if (vport->cur_vmid_cnt < vport->max_vmid) {
214 for (i = 0; i < vport->max_vmid; i++) {
215 vmp = vport->vmid + i;
216 if (vmp->flag == LPFC_VMID_SLOT_FREE)
217 break;
218 }
219 if (i == vport->max_vmid)
220 vmp = NULL;
221 } else {
222 vmp = NULL;
223 }
224
225 if (!vmp) {
226 write_unlock(&vport->vmid_lock);
227 return -ENOMEM;
228 }
229
230 /* Add the vmid and register */
231 lpfc_put_vmid_in_hashtable(vport, hash, vmp);
232 vmp->vmid_len = len;
233 memcpy(vmp->host_vmid, uuid, vmp->vmid_len);
234 vmp->io_rd_cnt = 0;
235 vmp->io_wr_cnt = 0;
236 vmp->flag = LPFC_VMID_SLOT_USED;
237
238 vmp->delete_inactive =
239 vport->vmid_inactivity_timeout ? 1 : 0;
240
241 /* if type priority tag, get next available VMID */
242 if (vport->phba->pport->vmid_flag & LPFC_VMID_TYPE_PRIO)
243 lpfc_vmid_assign_cs_ctl(vport, vmp);
244
245 /* allocate the per cpu variable for holding */
246 /* the last access time stamp only if VMID is enabled */
247 if (!vmp->last_io_time)
248 vmp->last_io_time = alloc_percpu_gfp(u64, GFP_ATOMIC);
249 if (!vmp->last_io_time) {
250 hash_del(&vmp->hnode);
251 vmp->flag = LPFC_VMID_SLOT_FREE;
252 write_unlock(&vport->vmid_lock);
253 return -EIO;
254 }
255
256 write_unlock(&vport->vmid_lock);
257
258 /* complete transaction with switch */
259 if (vport->phba->pport->vmid_flag & LPFC_VMID_TYPE_PRIO)
260 rc = lpfc_vmid_uvem(vport, vmp, true);
261 else if (vport->phba->cfg_vmid_app_header)
262 rc = lpfc_vmid_cmd(vport, SLI_CTAS_RAPP_IDENT, vmp);
263 if (!rc) {
264 write_lock(&vport->vmid_lock);
265 vport->cur_vmid_cnt++;
266 vmp->flag |= LPFC_VMID_REQ_REGISTER;
267 write_unlock(&vport->vmid_lock);
268 } else {
269 write_lock(&vport->vmid_lock);
270 hash_del(&vmp->hnode);
271 vmp->flag = LPFC_VMID_SLOT_FREE;
272 free_percpu(vmp->last_io_time);
273 write_unlock(&vport->vmid_lock);
274 return -EIO;
275 }
276
277 /* finally, enable the idle timer once */
278 if (!(vport->phba->pport->vmid_flag & LPFC_VMID_TIMER_ENBLD)) {
279 mod_timer(&vport->phba->inactive_vmid_poll,
280 jiffies +
281 msecs_to_jiffies(1000 * LPFC_VMID_TIMER));
282 vport->phba->pport->vmid_flag |= LPFC_VMID_TIMER_ENBLD;
283 }
284 }
285 return rc;
286 }
287
288 /*
289 * lpfc_reinit_vmid - reinitializes the vmid data structure
290 * @vport: pointer to vport data structure
291 *
292 * This routine reinitializes the vmid post flogi completion
293 *
294 * Return codes
295 * None
296 */
297 void
lpfc_reinit_vmid(struct lpfc_vport * vport)298 lpfc_reinit_vmid(struct lpfc_vport *vport)
299 {
300 u32 bucket, i, cpu;
301 struct lpfc_vmid *cur;
302 struct lpfc_vmid *vmp = NULL;
303 struct hlist_node *tmp;
304
305 write_lock(&vport->vmid_lock);
306 vport->cur_vmid_cnt = 0;
307
308 for (i = 0; i < vport->max_vmid; i++) {
309 vmp = &vport->vmid[i];
310 vmp->flag = LPFC_VMID_SLOT_FREE;
311 memset(vmp->host_vmid, 0, sizeof(vmp->host_vmid));
312 vmp->io_rd_cnt = 0;
313 vmp->io_wr_cnt = 0;
314
315 if (vmp->last_io_time)
316 for_each_possible_cpu(cpu)
317 *per_cpu_ptr(vmp->last_io_time, cpu) = 0;
318 }
319
320 /* for all elements in the hash table */
321 if (!hash_empty(vport->hash_table))
322 hash_for_each_safe(vport->hash_table, bucket, tmp, cur, hnode)
323 hash_del(&cur->hnode);
324 vport->vmid_flag = 0;
325 write_unlock(&vport->vmid_lock);
326 }
327