scsi: lpfc: vmid: Introduce VMID in I/O path

Introduce the VMID in the I/O path. Check if the VMID is enabled and if
the I/O belongs to a VM or not.

Link: https://lore.kernel.org/r/20210608043556.274139-14-muneendra.kumar@broadcom.com
Reviewed-by: Hannes Reinecke <hare@suse.de>
Signed-off-by: Gaurav Srivastava <gaurav.srivastava@broadcom.com>
Signed-off-by: James Smart <jsmart2021@gmail.com>
Signed-off-by: Muneendra Kumar <muneendra.kumar@broadcom.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>

diff --git a/drivers/scsi/lpfc/lpfc_scsi.c b/drivers/scsi/lpfc/lpfc_scsi.c
index 4ef7ff8..46bfe25 100644 (file)
--- a/drivers/scsi/lpfc/lpfc_scsi.c
+++ b/drivers/scsi/lpfc/lpfc_scsi.c
@@ -5278,6 +5278,160 @@ static void lpfc_vmid_assign_cs_ctl(struct lpfc_vport *vport,
        }
 }
 
+/*
+ * lpfc_vmid_get_appid - get the VMID associated with the UUID
+ * @vport: The virtual port for which this call is being executed.
+ * @uuid: UUID associated with the VE
+ * @cmd: address of scsi_cmd descriptor
+ * @tag: VMID tag
+ * Returns status of the function
+ */
+static int lpfc_vmid_get_appid(struct lpfc_vport *vport, char *uuid, struct
+                              scsi_cmnd * cmd, union lpfc_vmid_io_tag *tag)
+{
+       struct lpfc_vmid *vmp = NULL;
+       int hash, len, rc, i;
+
+       /* check if QFPA is complete */
+       if (lpfc_vmid_is_type_priority_tag(vport) && !(vport->vmid_flag &
+             LPFC_VMID_QFPA_CMPL)) {
+               vport->work_port_events |= WORKER_CHECK_VMID_ISSUE_QFPA;
+               return -EAGAIN;
+       }
+
+       /* search if the UUID has already been mapped to the VMID */
+       len = strlen(uuid);
+       hash = lpfc_vmid_hash_fn(uuid, len);
+
+       /* search for the VMID in the table */
+       read_lock(&vport->vmid_lock);
+       vmp = lpfc_get_vmid_from_hashtable(vport, hash, uuid);
+
+       /* if found, check if its already registered  */
+       if (vmp  && vmp->flag & LPFC_VMID_REGISTERED) {
+               read_unlock(&vport->vmid_lock);
+               lpfc_vmid_update_entry(vport, cmd, vmp, tag);
+               rc = 0;
+       } else if (vmp && (vmp->flag & LPFC_VMID_REQ_REGISTER ||
+                          vmp->flag & LPFC_VMID_DE_REGISTER)) {
+               /* else if register or dereg request has already been sent */
+               /* Hence VMID tag will not be added for this I/O */
+               read_unlock(&vport->vmid_lock);
+               rc = -EBUSY;
+       } else {
+               /* The VMID was not found in the hashtable. At this point, */
+               /* drop the read lock first before proceeding further */
+               read_unlock(&vport->vmid_lock);
+               /* start the process to obtain one as per the */
+               /* type of the VMID indicated */
+               write_lock(&vport->vmid_lock);
+               vmp = lpfc_get_vmid_from_hashtable(vport, hash, uuid);
+
+               /* while the read lock was released, in case the entry was */
+               /* added by other context or is in process of being added */
+               if (vmp && vmp->flag & LPFC_VMID_REGISTERED) {
+                       lpfc_vmid_update_entry(vport, cmd, vmp, tag);
+                       write_unlock(&vport->vmid_lock);
+                       return 0;
+               } else if (vmp && vmp->flag & LPFC_VMID_REQ_REGISTER) {
+                       write_unlock(&vport->vmid_lock);
+                       return -EBUSY;
+               }
+
+               /* else search and allocate a free slot in the hash table */
+               if (vport->cur_vmid_cnt < vport->max_vmid) {
+                       for (i = 0; i < vport->max_vmid; i++) {
+                               vmp = vport->vmid + i;
+                               if (vmp->flag == LPFC_VMID_SLOT_FREE)
+                                       break;
+                       }
+                       if (i == vport->max_vmid)
+                               vmp = NULL;
+               } else {
+                       vmp = NULL;
+               }
+
+               if (!vmp) {
+                       write_unlock(&vport->vmid_lock);
+                       return -ENOMEM;
+               }
+
+               /* Add the vmid and register */
+               lpfc_put_vmid_in_hashtable(vport, hash, vmp);
+               vmp->vmid_len = len;
+               memcpy(vmp->host_vmid, uuid, vmp->vmid_len);
+               vmp->io_rd_cnt = 0;
+               vmp->io_wr_cnt = 0;
+               vmp->flag = LPFC_VMID_SLOT_USED;
+
+               vmp->delete_inactive =
+                       vport->vmid_inactivity_timeout ? 1 : 0;
+
+               /* if type priority tag, get next available VMID */
+               if (lpfc_vmid_is_type_priority_tag(vport))
+                       lpfc_vmid_assign_cs_ctl(vport, vmp);
+
+               /* allocate the per cpu variable for holding */
+               /* the last access time stamp only if VMID is enabled */
+               if (!vmp->last_io_time)
+                       vmp->last_io_time = __alloc_percpu(sizeof(u64),
+                                                          __alignof__(struct
+                                                          lpfc_vmid));
+               if (!vmp->last_io_time) {
+                       hash_del(&vmp->hnode);
+                       vmp->flag = LPFC_VMID_SLOT_FREE;
+                       write_unlock(&vport->vmid_lock);
+                       return -EIO;
+               }
+
+               write_unlock(&vport->vmid_lock);
+
+               /* complete transaction with switch */
+               if (lpfc_vmid_is_type_priority_tag(vport))
+                       rc = lpfc_vmid_uvem(vport, vmp, true);
+               else
+                       rc = lpfc_vmid_cmd(vport, SLI_CTAS_RAPP_IDENT, vmp);
+               if (!rc) {
+                       write_lock(&vport->vmid_lock);
+                       vport->cur_vmid_cnt++;
+                       vmp->flag |= LPFC_VMID_REQ_REGISTER;
+                       write_unlock(&vport->vmid_lock);
+               } else {
+                       write_lock(&vport->vmid_lock);
+                       hash_del(&vmp->hnode);
+                       vmp->flag = LPFC_VMID_SLOT_FREE;
+                       free_percpu(vmp->last_io_time);
+                       write_unlock(&vport->vmid_lock);
+                       return -EIO;
+               }
+
+               /* finally, enable the idle timer once */
+               if (!(vport->phba->pport->vmid_flag & LPFC_VMID_TIMER_ENBLD)) {
+                       mod_timer(&vport->phba->inactive_vmid_poll,
+                                 jiffies +
+                                 msecs_to_jiffies(1000 * LPFC_VMID_TIMER));
+                       vport->phba->pport->vmid_flag |= LPFC_VMID_TIMER_ENBLD;
+               }
+       }
+       return rc;
+}
+
+/*
+ * lpfc_is_command_vm_io - get the UUID from blk cgroup
+ * @cmd: Pointer to scsi_cmnd data structure
+ * Returns UUID if present, otherwise NULL
+ */
+static char *lpfc_is_command_vm_io(struct scsi_cmnd *cmd)
+{
+       char *uuid = NULL;
+
+       if (cmd->request) {
+               if (cmd->request->bio)
+                       uuid = blkcg_get_fc_appid(cmd->request->bio);
+       }
+       return uuid;
+}
+
 /**
  * lpfc_queuecommand - scsi_host_template queuecommand entry point
  * @shost: kernel scsi host pointer.
@@ -5303,6 +5457,7 @@ lpfc_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *cmnd)
        int err, idx;
 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
        uint64_t start = 0L;
+       u8 *uuid = NULL;
 
        if (phba->ktime_on)
                start = ktime_get_ns();
@@ -5430,6 +5585,25 @@ lpfc_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *cmnd)
        }
 
 
+       /* check the necessary and sufficient condition to support VMID */
+       if (lpfc_is_vmid_enabled(phba) &&
+           (ndlp->vmid_support ||
+            phba->pport->vmid_priority_tagging ==
+            LPFC_VMID_PRIO_TAG_ALL_TARGETS)) {
+               /* is the I/O generated by a VM, get the associated virtual */
+               /* entity id */
+               uuid = lpfc_is_command_vm_io(cmnd);
+
+               if (uuid) {
+                       err = lpfc_vmid_get_appid(vport, uuid, cmnd,
+                               (union lpfc_vmid_io_tag *)
+                                       &lpfc_cmd->cur_iocbq.vmid_tag);
+                       if (!err)
+                               lpfc_cmd->cur_iocbq.iocb_flag |= LPFC_IO_VMID;
+               }
+       }
+
+       atomic_inc(&ndlp->cmd_pending);
 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
        if (unlikely(phba->hdwqstat_on & LPFC_CHECK_SCSI_IO))
                this_cpu_inc(phba->sli4_hba.c_stat->xmt_io);