cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

lpfc_vmid.c (9170B)


      1/*******************************************************************
      2 * This file is part of the Emulex Linux Device Driver for         *
      3 * Fibre Channel Host Bus Adapters.                                *
      4 * Copyright (C) 2017-2022 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 */
     47struct 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 */
     68static void
     69lpfc_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 */
     81int 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 */
    107static 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
    129static 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 */
    158int 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(sizeof(u64),
    249							   __alignof__(struct
    250							   lpfc_vmid));
    251		if (!vmp->last_io_time) {
    252			hash_del(&vmp->hnode);
    253			vmp->flag = LPFC_VMID_SLOT_FREE;
    254			write_unlock(&vport->vmid_lock);
    255			return -EIO;
    256		}
    257
    258		write_unlock(&vport->vmid_lock);
    259
    260		/* complete transaction with switch */
    261		if (vport->phba->pport->vmid_flag & LPFC_VMID_TYPE_PRIO)
    262			rc = lpfc_vmid_uvem(vport, vmp, true);
    263		else if (vport->phba->cfg_vmid_app_header)
    264			rc = lpfc_vmid_cmd(vport, SLI_CTAS_RAPP_IDENT, vmp);
    265		if (!rc) {
    266			write_lock(&vport->vmid_lock);
    267			vport->cur_vmid_cnt++;
    268			vmp->flag |= LPFC_VMID_REQ_REGISTER;
    269			write_unlock(&vport->vmid_lock);
    270		} else {
    271			write_lock(&vport->vmid_lock);
    272			hash_del(&vmp->hnode);
    273			vmp->flag = LPFC_VMID_SLOT_FREE;
    274			free_percpu(vmp->last_io_time);
    275			write_unlock(&vport->vmid_lock);
    276			return -EIO;
    277		}
    278
    279		/* finally, enable the idle timer once */
    280		if (!(vport->phba->pport->vmid_flag & LPFC_VMID_TIMER_ENBLD)) {
    281			mod_timer(&vport->phba->inactive_vmid_poll,
    282				  jiffies +
    283				  msecs_to_jiffies(1000 * LPFC_VMID_TIMER));
    284			vport->phba->pport->vmid_flag |= LPFC_VMID_TIMER_ENBLD;
    285		}
    286	}
    287	return rc;
    288}