mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-06 02:24:14 +08:00
bfc0bab172
Introduce multiple hardware queues to improve legacy I/O path performance. Each hardware queue is comprised of a master context and associated I/O resources. The hardware queues are initially implemented as a static array embedded in the AFU. This will be transitioned to a dynamic allocation in a later series to improve the memory footprint of the driver. Signed-off-by: Uma Krishnan <ukrishn@linux.vnet.ibm.com> Acked-by: Matthew R. Ochs <mrochs@linux.vnet.ibm.com> Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2177 lines
60 KiB
C
2177 lines
60 KiB
C
/*
|
|
* CXL Flash Device Driver
|
|
*
|
|
* Written by: Manoj N. Kumar <manoj@linux.vnet.ibm.com>, IBM Corporation
|
|
* Matthew R. Ochs <mrochs@linux.vnet.ibm.com>, IBM Corporation
|
|
*
|
|
* Copyright (C) 2015 IBM Corporation
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version
|
|
* 2 of the License, or (at your option) any later version.
|
|
*/
|
|
|
|
#include <linux/delay.h>
|
|
#include <linux/file.h>
|
|
#include <linux/syscalls.h>
|
|
#include <misc/cxl.h>
|
|
#include <asm/unaligned.h>
|
|
|
|
#include <scsi/scsi.h>
|
|
#include <scsi/scsi_host.h>
|
|
#include <scsi/scsi_cmnd.h>
|
|
#include <scsi/scsi_eh.h>
|
|
#include <uapi/scsi/cxlflash_ioctl.h>
|
|
|
|
#include "sislite.h"
|
|
#include "common.h"
|
|
#include "vlun.h"
|
|
#include "superpipe.h"
|
|
|
|
struct cxlflash_global global;
|
|
|
|
/**
|
|
* marshal_rele_to_resize() - translate release to resize structure
|
|
* @rele: Source structure from which to translate/copy.
|
|
* @resize: Destination structure for the translate/copy.
|
|
*/
|
|
static void marshal_rele_to_resize(struct dk_cxlflash_release *release,
|
|
struct dk_cxlflash_resize *resize)
|
|
{
|
|
resize->hdr = release->hdr;
|
|
resize->context_id = release->context_id;
|
|
resize->rsrc_handle = release->rsrc_handle;
|
|
}
|
|
|
|
/**
|
|
* marshal_det_to_rele() - translate detach to release structure
|
|
* @detach: Destination structure for the translate/copy.
|
|
* @rele: Source structure from which to translate/copy.
|
|
*/
|
|
static void marshal_det_to_rele(struct dk_cxlflash_detach *detach,
|
|
struct dk_cxlflash_release *release)
|
|
{
|
|
release->hdr = detach->hdr;
|
|
release->context_id = detach->context_id;
|
|
}
|
|
|
|
/**
|
|
* cxlflash_free_errpage() - frees resources associated with global error page
|
|
*/
|
|
void cxlflash_free_errpage(void)
|
|
{
|
|
|
|
mutex_lock(&global.mutex);
|
|
if (global.err_page) {
|
|
__free_page(global.err_page);
|
|
global.err_page = NULL;
|
|
}
|
|
mutex_unlock(&global.mutex);
|
|
}
|
|
|
|
/**
|
|
* cxlflash_stop_term_user_contexts() - stops/terminates known user contexts
|
|
* @cfg: Internal structure associated with the host.
|
|
*
|
|
* When the host needs to go down, all users must be quiesced and their
|
|
* memory freed. This is accomplished by putting the contexts in error
|
|
* state which will notify the user and let them 'drive' the tear down.
|
|
* Meanwhile, this routine camps until all user contexts have been removed.
|
|
*
|
|
* Note that the main loop in this routine will always execute at least once
|
|
* to flush the reset_waitq.
|
|
*/
|
|
void cxlflash_stop_term_user_contexts(struct cxlflash_cfg *cfg)
|
|
{
|
|
struct device *dev = &cfg->dev->dev;
|
|
int i, found = true;
|
|
|
|
cxlflash_mark_contexts_error(cfg);
|
|
|
|
while (true) {
|
|
for (i = 0; i < MAX_CONTEXT; i++)
|
|
if (cfg->ctx_tbl[i]) {
|
|
found = true;
|
|
break;
|
|
}
|
|
|
|
if (!found && list_empty(&cfg->ctx_err_recovery))
|
|
return;
|
|
|
|
dev_dbg(dev, "%s: Wait for user contexts to quiesce...\n",
|
|
__func__);
|
|
wake_up_all(&cfg->reset_waitq);
|
|
ssleep(1);
|
|
found = false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* find_error_context() - locates a context by cookie on the error recovery list
|
|
* @cfg: Internal structure associated with the host.
|
|
* @rctxid: Desired context by id.
|
|
* @file: Desired context by file.
|
|
*
|
|
* Return: Found context on success, NULL on failure
|
|
*/
|
|
static struct ctx_info *find_error_context(struct cxlflash_cfg *cfg, u64 rctxid,
|
|
struct file *file)
|
|
{
|
|
struct ctx_info *ctxi;
|
|
|
|
list_for_each_entry(ctxi, &cfg->ctx_err_recovery, list)
|
|
if ((ctxi->ctxid == rctxid) || (ctxi->file == file))
|
|
return ctxi;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* get_context() - obtains a validated and locked context reference
|
|
* @cfg: Internal structure associated with the host.
|
|
* @rctxid: Desired context (raw, un-decoded format).
|
|
* @arg: LUN information or file associated with request.
|
|
* @ctx_ctrl: Control information to 'steer' desired lookup.
|
|
*
|
|
* NOTE: despite the name pid, in linux, current->pid actually refers
|
|
* to the lightweight process id (tid) and can change if the process is
|
|
* multi threaded. The tgid remains constant for the process and only changes
|
|
* when the process of fork. For all intents and purposes, think of tgid
|
|
* as a pid in the traditional sense.
|
|
*
|
|
* Return: Validated context on success, NULL on failure
|
|
*/
|
|
struct ctx_info *get_context(struct cxlflash_cfg *cfg, u64 rctxid,
|
|
void *arg, enum ctx_ctrl ctx_ctrl)
|
|
{
|
|
struct device *dev = &cfg->dev->dev;
|
|
struct ctx_info *ctxi = NULL;
|
|
struct lun_access *lun_access = NULL;
|
|
struct file *file = NULL;
|
|
struct llun_info *lli = arg;
|
|
u64 ctxid = DECODE_CTXID(rctxid);
|
|
int rc;
|
|
pid_t pid = current->tgid, ctxpid = 0;
|
|
|
|
if (ctx_ctrl & CTX_CTRL_FILE) {
|
|
lli = NULL;
|
|
file = (struct file *)arg;
|
|
}
|
|
|
|
if (ctx_ctrl & CTX_CTRL_CLONE)
|
|
pid = current->parent->tgid;
|
|
|
|
if (likely(ctxid < MAX_CONTEXT)) {
|
|
while (true) {
|
|
mutex_lock(&cfg->ctx_tbl_list_mutex);
|
|
ctxi = cfg->ctx_tbl[ctxid];
|
|
if (ctxi)
|
|
if ((file && (ctxi->file != file)) ||
|
|
(!file && (ctxi->ctxid != rctxid)))
|
|
ctxi = NULL;
|
|
|
|
if ((ctx_ctrl & CTX_CTRL_ERR) ||
|
|
(!ctxi && (ctx_ctrl & CTX_CTRL_ERR_FALLBACK)))
|
|
ctxi = find_error_context(cfg, rctxid, file);
|
|
if (!ctxi) {
|
|
mutex_unlock(&cfg->ctx_tbl_list_mutex);
|
|
goto out;
|
|
}
|
|
|
|
/*
|
|
* Need to acquire ownership of the context while still
|
|
* under the table/list lock to serialize with a remove
|
|
* thread. Use the 'try' to avoid stalling the
|
|
* table/list lock for a single context.
|
|
*
|
|
* Note that the lock order is:
|
|
*
|
|
* cfg->ctx_tbl_list_mutex -> ctxi->mutex
|
|
*
|
|
* Therefore release ctx_tbl_list_mutex before retrying.
|
|
*/
|
|
rc = mutex_trylock(&ctxi->mutex);
|
|
mutex_unlock(&cfg->ctx_tbl_list_mutex);
|
|
if (rc)
|
|
break; /* got the context's lock! */
|
|
}
|
|
|
|
if (ctxi->unavail)
|
|
goto denied;
|
|
|
|
ctxpid = ctxi->pid;
|
|
if (likely(!(ctx_ctrl & CTX_CTRL_NOPID)))
|
|
if (pid != ctxpid)
|
|
goto denied;
|
|
|
|
if (lli) {
|
|
list_for_each_entry(lun_access, &ctxi->luns, list)
|
|
if (lun_access->lli == lli)
|
|
goto out;
|
|
goto denied;
|
|
}
|
|
}
|
|
|
|
out:
|
|
dev_dbg(dev, "%s: rctxid=%016llx ctxinfo=%p ctxpid=%u pid=%u "
|
|
"ctx_ctrl=%u\n", __func__, rctxid, ctxi, ctxpid, pid,
|
|
ctx_ctrl);
|
|
|
|
return ctxi;
|
|
|
|
denied:
|
|
mutex_unlock(&ctxi->mutex);
|
|
ctxi = NULL;
|
|
goto out;
|
|
}
|
|
|
|
/**
|
|
* put_context() - release a context that was retrieved from get_context()
|
|
* @ctxi: Context to release.
|
|
*
|
|
* For now, releasing the context equates to unlocking it's mutex.
|
|
*/
|
|
void put_context(struct ctx_info *ctxi)
|
|
{
|
|
mutex_unlock(&ctxi->mutex);
|
|
}
|
|
|
|
/**
|
|
* afu_attach() - attach a context to the AFU
|
|
* @cfg: Internal structure associated with the host.
|
|
* @ctxi: Context to attach.
|
|
*
|
|
* Upon setting the context capabilities, they must be confirmed with
|
|
* a read back operation as the context might have been closed since
|
|
* the mailbox was unlocked. When this occurs, registration is failed.
|
|
*
|
|
* Return: 0 on success, -errno on failure
|
|
*/
|
|
static int afu_attach(struct cxlflash_cfg *cfg, struct ctx_info *ctxi)
|
|
{
|
|
struct device *dev = &cfg->dev->dev;
|
|
struct afu *afu = cfg->afu;
|
|
struct sisl_ctrl_map __iomem *ctrl_map = ctxi->ctrl_map;
|
|
int rc = 0;
|
|
struct hwq *hwq = get_hwq(afu, PRIMARY_HWQ);
|
|
u64 val;
|
|
|
|
/* Unlock cap and restrict user to read/write cmds in translated mode */
|
|
readq_be(&ctrl_map->mbox_r);
|
|
val = (SISL_CTX_CAP_READ_CMD | SISL_CTX_CAP_WRITE_CMD);
|
|
writeq_be(val, &ctrl_map->ctx_cap);
|
|
val = readq_be(&ctrl_map->ctx_cap);
|
|
if (val != (SISL_CTX_CAP_READ_CMD | SISL_CTX_CAP_WRITE_CMD)) {
|
|
dev_err(dev, "%s: ctx may be closed val=%016llx\n",
|
|
__func__, val);
|
|
rc = -EAGAIN;
|
|
goto out;
|
|
}
|
|
|
|
/* Set up MMIO registers pointing to the RHT */
|
|
writeq_be((u64)ctxi->rht_start, &ctrl_map->rht_start);
|
|
val = SISL_RHT_CNT_ID((u64)MAX_RHT_PER_CONTEXT, (u64)(hwq->ctx_hndl));
|
|
writeq_be(val, &ctrl_map->rht_cnt_id);
|
|
out:
|
|
dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* read_cap16() - issues a SCSI READ_CAP16 command
|
|
* @sdev: SCSI device associated with LUN.
|
|
* @lli: LUN destined for capacity request.
|
|
*
|
|
* The READ_CAP16 can take quite a while to complete. Should an EEH occur while
|
|
* in scsi_execute(), the EEH handler will attempt to recover. As part of the
|
|
* recovery, the handler drains all currently running ioctls, waiting until they
|
|
* have completed before proceeding with a reset. As this routine is used on the
|
|
* ioctl path, this can create a condition where the EEH handler becomes stuck,
|
|
* infinitely waiting for this ioctl thread. To avoid this behavior, temporarily
|
|
* unmark this thread as an ioctl thread by releasing the ioctl read semaphore.
|
|
* This will allow the EEH handler to proceed with a recovery while this thread
|
|
* is still running. Once the scsi_execute() returns, reacquire the ioctl read
|
|
* semaphore and check the adapter state in case it changed while inside of
|
|
* scsi_execute(). The state check will wait if the adapter is still being
|
|
* recovered or return a failure if the recovery failed. In the event that the
|
|
* adapter reset failed, simply return the failure as the ioctl would be unable
|
|
* to continue.
|
|
*
|
|
* Note that the above puts a requirement on this routine to only be called on
|
|
* an ioctl thread.
|
|
*
|
|
* Return: 0 on success, -errno on failure
|
|
*/
|
|
static int read_cap16(struct scsi_device *sdev, struct llun_info *lli)
|
|
{
|
|
struct cxlflash_cfg *cfg = shost_priv(sdev->host);
|
|
struct device *dev = &cfg->dev->dev;
|
|
struct glun_info *gli = lli->parent;
|
|
struct scsi_sense_hdr sshdr;
|
|
u8 *cmd_buf = NULL;
|
|
u8 *scsi_cmd = NULL;
|
|
u8 *sense_buf = NULL;
|
|
int rc = 0;
|
|
int result = 0;
|
|
int retry_cnt = 0;
|
|
u32 to = CMD_TIMEOUT * HZ;
|
|
|
|
retry:
|
|
cmd_buf = kzalloc(CMD_BUFSIZE, GFP_KERNEL);
|
|
scsi_cmd = kzalloc(MAX_COMMAND_SIZE, GFP_KERNEL);
|
|
sense_buf = kzalloc(SCSI_SENSE_BUFFERSIZE, GFP_KERNEL);
|
|
if (unlikely(!cmd_buf || !scsi_cmd || !sense_buf)) {
|
|
rc = -ENOMEM;
|
|
goto out;
|
|
}
|
|
|
|
scsi_cmd[0] = SERVICE_ACTION_IN_16; /* read cap(16) */
|
|
scsi_cmd[1] = SAI_READ_CAPACITY_16; /* service action */
|
|
put_unaligned_be32(CMD_BUFSIZE, &scsi_cmd[10]);
|
|
|
|
dev_dbg(dev, "%s: %ssending cmd(%02x)\n", __func__,
|
|
retry_cnt ? "re" : "", scsi_cmd[0]);
|
|
|
|
/* Drop the ioctl read semahpore across lengthy call */
|
|
up_read(&cfg->ioctl_rwsem);
|
|
result = scsi_execute(sdev, scsi_cmd, DMA_FROM_DEVICE, cmd_buf,
|
|
CMD_BUFSIZE, sense_buf, &sshdr, to, CMD_RETRIES,
|
|
0, 0, NULL);
|
|
down_read(&cfg->ioctl_rwsem);
|
|
rc = check_state(cfg);
|
|
if (rc) {
|
|
dev_err(dev, "%s: Failed state result=%08x\n",
|
|
__func__, result);
|
|
rc = -ENODEV;
|
|
goto out;
|
|
}
|
|
|
|
if (driver_byte(result) == DRIVER_SENSE) {
|
|
result &= ~(0xFF<<24); /* DRIVER_SENSE is not an error */
|
|
if (result & SAM_STAT_CHECK_CONDITION) {
|
|
switch (sshdr.sense_key) {
|
|
case NO_SENSE:
|
|
case RECOVERED_ERROR:
|
|
/* fall through */
|
|
case NOT_READY:
|
|
result &= ~SAM_STAT_CHECK_CONDITION;
|
|
break;
|
|
case UNIT_ATTENTION:
|
|
switch (sshdr.asc) {
|
|
case 0x29: /* Power on Reset or Device Reset */
|
|
/* fall through */
|
|
case 0x2A: /* Device capacity changed */
|
|
case 0x3F: /* Report LUNs changed */
|
|
/* Retry the command once more */
|
|
if (retry_cnt++ < 1) {
|
|
kfree(cmd_buf);
|
|
kfree(scsi_cmd);
|
|
kfree(sense_buf);
|
|
goto retry;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (result) {
|
|
dev_err(dev, "%s: command failed, result=%08x\n",
|
|
__func__, result);
|
|
rc = -EIO;
|
|
goto out;
|
|
}
|
|
|
|
/*
|
|
* Read cap was successful, grab values from the buffer;
|
|
* note that we don't need to worry about unaligned access
|
|
* as the buffer is allocated on an aligned boundary.
|
|
*/
|
|
mutex_lock(&gli->mutex);
|
|
gli->max_lba = be64_to_cpu(*((__be64 *)&cmd_buf[0]));
|
|
gli->blk_len = be32_to_cpu(*((__be32 *)&cmd_buf[8]));
|
|
mutex_unlock(&gli->mutex);
|
|
|
|
out:
|
|
kfree(cmd_buf);
|
|
kfree(scsi_cmd);
|
|
kfree(sense_buf);
|
|
|
|
dev_dbg(dev, "%s: maxlba=%lld blklen=%d rc=%d\n",
|
|
__func__, gli->max_lba, gli->blk_len, rc);
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* get_rhte() - obtains validated resource handle table entry reference
|
|
* @ctxi: Context owning the resource handle.
|
|
* @rhndl: Resource handle associated with entry.
|
|
* @lli: LUN associated with request.
|
|
*
|
|
* Return: Validated RHTE on success, NULL on failure
|
|
*/
|
|
struct sisl_rht_entry *get_rhte(struct ctx_info *ctxi, res_hndl_t rhndl,
|
|
struct llun_info *lli)
|
|
{
|
|
struct cxlflash_cfg *cfg = ctxi->cfg;
|
|
struct device *dev = &cfg->dev->dev;
|
|
struct sisl_rht_entry *rhte = NULL;
|
|
|
|
if (unlikely(!ctxi->rht_start)) {
|
|
dev_dbg(dev, "%s: Context does not have allocated RHT\n",
|
|
__func__);
|
|
goto out;
|
|
}
|
|
|
|
if (unlikely(rhndl >= MAX_RHT_PER_CONTEXT)) {
|
|
dev_dbg(dev, "%s: Bad resource handle rhndl=%d\n",
|
|
__func__, rhndl);
|
|
goto out;
|
|
}
|
|
|
|
if (unlikely(ctxi->rht_lun[rhndl] != lli)) {
|
|
dev_dbg(dev, "%s: Bad resource handle LUN rhndl=%d\n",
|
|
__func__, rhndl);
|
|
goto out;
|
|
}
|
|
|
|
rhte = &ctxi->rht_start[rhndl];
|
|
if (unlikely(rhte->nmask == 0)) {
|
|
dev_dbg(dev, "%s: Unopened resource handle rhndl=%d\n",
|
|
__func__, rhndl);
|
|
rhte = NULL;
|
|
goto out;
|
|
}
|
|
|
|
out:
|
|
return rhte;
|
|
}
|
|
|
|
/**
|
|
* rhte_checkout() - obtains free/empty resource handle table entry
|
|
* @ctxi: Context owning the resource handle.
|
|
* @lli: LUN associated with request.
|
|
*
|
|
* Return: Free RHTE on success, NULL on failure
|
|
*/
|
|
struct sisl_rht_entry *rhte_checkout(struct ctx_info *ctxi,
|
|
struct llun_info *lli)
|
|
{
|
|
struct cxlflash_cfg *cfg = ctxi->cfg;
|
|
struct device *dev = &cfg->dev->dev;
|
|
struct sisl_rht_entry *rhte = NULL;
|
|
int i;
|
|
|
|
/* Find a free RHT entry */
|
|
for (i = 0; i < MAX_RHT_PER_CONTEXT; i++)
|
|
if (ctxi->rht_start[i].nmask == 0) {
|
|
rhte = &ctxi->rht_start[i];
|
|
ctxi->rht_out++;
|
|
break;
|
|
}
|
|
|
|
if (likely(rhte))
|
|
ctxi->rht_lun[i] = lli;
|
|
|
|
dev_dbg(dev, "%s: returning rhte=%p index=%d\n", __func__, rhte, i);
|
|
return rhte;
|
|
}
|
|
|
|
/**
|
|
* rhte_checkin() - releases a resource handle table entry
|
|
* @ctxi: Context owning the resource handle.
|
|
* @rhte: RHTE to release.
|
|
*/
|
|
void rhte_checkin(struct ctx_info *ctxi,
|
|
struct sisl_rht_entry *rhte)
|
|
{
|
|
u32 rsrc_handle = rhte - ctxi->rht_start;
|
|
|
|
rhte->nmask = 0;
|
|
rhte->fp = 0;
|
|
ctxi->rht_out--;
|
|
ctxi->rht_lun[rsrc_handle] = NULL;
|
|
ctxi->rht_needs_ws[rsrc_handle] = false;
|
|
}
|
|
|
|
/**
|
|
* rhte_format1() - populates a RHTE for format 1
|
|
* @rhte: RHTE to populate.
|
|
* @lun_id: LUN ID of LUN associated with RHTE.
|
|
* @perm: Desired permissions for RHTE.
|
|
* @port_sel: Port selection mask
|
|
*/
|
|
static void rht_format1(struct sisl_rht_entry *rhte, u64 lun_id, u32 perm,
|
|
u32 port_sel)
|
|
{
|
|
/*
|
|
* Populate the Format 1 RHT entry for direct access (physical
|
|
* LUN) using the synchronization sequence defined in the
|
|
* SISLite specification.
|
|
*/
|
|
struct sisl_rht_entry_f1 dummy = { 0 };
|
|
struct sisl_rht_entry_f1 *rhte_f1 = (struct sisl_rht_entry_f1 *)rhte;
|
|
|
|
memset(rhte_f1, 0, sizeof(*rhte_f1));
|
|
rhte_f1->fp = SISL_RHT_FP(1U, 0);
|
|
dma_wmb(); /* Make setting of format bit visible */
|
|
|
|
rhte_f1->lun_id = lun_id;
|
|
dma_wmb(); /* Make setting of LUN id visible */
|
|
|
|
/*
|
|
* Use a dummy RHT Format 1 entry to build the second dword
|
|
* of the entry that must be populated in a single write when
|
|
* enabled (valid bit set to TRUE).
|
|
*/
|
|
dummy.valid = 0x80;
|
|
dummy.fp = SISL_RHT_FP(1U, perm);
|
|
dummy.port_sel = port_sel;
|
|
rhte_f1->dw = dummy.dw;
|
|
|
|
dma_wmb(); /* Make remaining RHT entry fields visible */
|
|
}
|
|
|
|
/**
|
|
* cxlflash_lun_attach() - attaches a user to a LUN and manages the LUN's mode
|
|
* @gli: LUN to attach.
|
|
* @mode: Desired mode of the LUN.
|
|
* @locked: Mutex status on current thread.
|
|
*
|
|
* Return: 0 on success, -errno on failure
|
|
*/
|
|
int cxlflash_lun_attach(struct glun_info *gli, enum lun_mode mode, bool locked)
|
|
{
|
|
int rc = 0;
|
|
|
|
if (!locked)
|
|
mutex_lock(&gli->mutex);
|
|
|
|
if (gli->mode == MODE_NONE)
|
|
gli->mode = mode;
|
|
else if (gli->mode != mode) {
|
|
pr_debug("%s: gli_mode=%d requested_mode=%d\n",
|
|
__func__, gli->mode, mode);
|
|
rc = -EINVAL;
|
|
goto out;
|
|
}
|
|
|
|
gli->users++;
|
|
WARN_ON(gli->users <= 0);
|
|
out:
|
|
pr_debug("%s: Returning rc=%d gli->mode=%u gli->users=%u\n",
|
|
__func__, rc, gli->mode, gli->users);
|
|
if (!locked)
|
|
mutex_unlock(&gli->mutex);
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* cxlflash_lun_detach() - detaches a user from a LUN and resets the LUN's mode
|
|
* @gli: LUN to detach.
|
|
*
|
|
* When resetting the mode, terminate block allocation resources as they
|
|
* are no longer required (service is safe to call even when block allocation
|
|
* resources were not present - such as when transitioning from physical mode).
|
|
* These resources will be reallocated when needed (subsequent transition to
|
|
* virtual mode).
|
|
*/
|
|
void cxlflash_lun_detach(struct glun_info *gli)
|
|
{
|
|
mutex_lock(&gli->mutex);
|
|
WARN_ON(gli->mode == MODE_NONE);
|
|
if (--gli->users == 0) {
|
|
gli->mode = MODE_NONE;
|
|
cxlflash_ba_terminate(&gli->blka.ba_lun);
|
|
}
|
|
pr_debug("%s: gli->users=%u\n", __func__, gli->users);
|
|
WARN_ON(gli->users < 0);
|
|
mutex_unlock(&gli->mutex);
|
|
}
|
|
|
|
/**
|
|
* _cxlflash_disk_release() - releases the specified resource entry
|
|
* @sdev: SCSI device associated with LUN.
|
|
* @ctxi: Context owning resources.
|
|
* @release: Release ioctl data structure.
|
|
*
|
|
* For LUNs in virtual mode, the virtual LUN associated with the specified
|
|
* resource handle is resized to 0 prior to releasing the RHTE. Note that the
|
|
* AFU sync should _not_ be performed when the context is sitting on the error
|
|
* recovery list. A context on the error recovery list is not known to the AFU
|
|
* due to reset. When the context is recovered, it will be reattached and made
|
|
* known again to the AFU.
|
|
*
|
|
* Return: 0 on success, -errno on failure
|
|
*/
|
|
int _cxlflash_disk_release(struct scsi_device *sdev,
|
|
struct ctx_info *ctxi,
|
|
struct dk_cxlflash_release *release)
|
|
{
|
|
struct cxlflash_cfg *cfg = shost_priv(sdev->host);
|
|
struct device *dev = &cfg->dev->dev;
|
|
struct llun_info *lli = sdev->hostdata;
|
|
struct glun_info *gli = lli->parent;
|
|
struct afu *afu = cfg->afu;
|
|
bool put_ctx = false;
|
|
|
|
struct dk_cxlflash_resize size;
|
|
res_hndl_t rhndl = release->rsrc_handle;
|
|
|
|
int rc = 0;
|
|
u64 ctxid = DECODE_CTXID(release->context_id),
|
|
rctxid = release->context_id;
|
|
|
|
struct sisl_rht_entry *rhte;
|
|
struct sisl_rht_entry_f1 *rhte_f1;
|
|
|
|
dev_dbg(dev, "%s: ctxid=%llu rhndl=%llu gli->mode=%u gli->users=%u\n",
|
|
__func__, ctxid, release->rsrc_handle, gli->mode, gli->users);
|
|
|
|
if (!ctxi) {
|
|
ctxi = get_context(cfg, rctxid, lli, CTX_CTRL_ERR_FALLBACK);
|
|
if (unlikely(!ctxi)) {
|
|
dev_dbg(dev, "%s: Bad context ctxid=%llu\n",
|
|
__func__, ctxid);
|
|
rc = -EINVAL;
|
|
goto out;
|
|
}
|
|
|
|
put_ctx = true;
|
|
}
|
|
|
|
rhte = get_rhte(ctxi, rhndl, lli);
|
|
if (unlikely(!rhte)) {
|
|
dev_dbg(dev, "%s: Bad resource handle rhndl=%d\n",
|
|
__func__, rhndl);
|
|
rc = -EINVAL;
|
|
goto out;
|
|
}
|
|
|
|
/*
|
|
* Resize to 0 for virtual LUNS by setting the size
|
|
* to 0. This will clear LXT_START and LXT_CNT fields
|
|
* in the RHT entry and properly sync with the AFU.
|
|
*
|
|
* Afterwards we clear the remaining fields.
|
|
*/
|
|
switch (gli->mode) {
|
|
case MODE_VIRTUAL:
|
|
marshal_rele_to_resize(release, &size);
|
|
size.req_size = 0;
|
|
rc = _cxlflash_vlun_resize(sdev, ctxi, &size);
|
|
if (rc) {
|
|
dev_dbg(dev, "%s: resize failed rc %d\n", __func__, rc);
|
|
goto out;
|
|
}
|
|
|
|
break;
|
|
case MODE_PHYSICAL:
|
|
/*
|
|
* Clear the Format 1 RHT entry for direct access
|
|
* (physical LUN) using the synchronization sequence
|
|
* defined in the SISLite specification.
|
|
*/
|
|
rhte_f1 = (struct sisl_rht_entry_f1 *)rhte;
|
|
|
|
rhte_f1->valid = 0;
|
|
dma_wmb(); /* Make revocation of RHT entry visible */
|
|
|
|
rhte_f1->lun_id = 0;
|
|
dma_wmb(); /* Make clearing of LUN id visible */
|
|
|
|
rhte_f1->dw = 0;
|
|
dma_wmb(); /* Make RHT entry bottom-half clearing visible */
|
|
|
|
if (!ctxi->err_recovery_active)
|
|
cxlflash_afu_sync(afu, ctxid, rhndl, AFU_HW_SYNC);
|
|
break;
|
|
default:
|
|
WARN(1, "Unsupported LUN mode!");
|
|
goto out;
|
|
}
|
|
|
|
rhte_checkin(ctxi, rhte);
|
|
cxlflash_lun_detach(gli);
|
|
|
|
out:
|
|
if (put_ctx)
|
|
put_context(ctxi);
|
|
dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
|
|
return rc;
|
|
}
|
|
|
|
int cxlflash_disk_release(struct scsi_device *sdev,
|
|
struct dk_cxlflash_release *release)
|
|
{
|
|
return _cxlflash_disk_release(sdev, NULL, release);
|
|
}
|
|
|
|
/**
|
|
* destroy_context() - releases a context
|
|
* @cfg: Internal structure associated with the host.
|
|
* @ctxi: Context to release.
|
|
*
|
|
* This routine is safe to be called with a a non-initialized context.
|
|
* Also note that the routine conditionally checks for the existence
|
|
* of the context control map before clearing the RHT registers and
|
|
* context capabilities because it is possible to destroy a context
|
|
* while the context is in the error state (previous mapping was
|
|
* removed [so there is no need to worry about clearing] and context
|
|
* is waiting for a new mapping).
|
|
*/
|
|
static void destroy_context(struct cxlflash_cfg *cfg,
|
|
struct ctx_info *ctxi)
|
|
{
|
|
struct afu *afu = cfg->afu;
|
|
|
|
if (ctxi->initialized) {
|
|
WARN_ON(!list_empty(&ctxi->luns));
|
|
|
|
/* Clear RHT registers and drop all capabilities for context */
|
|
if (afu->afu_map && ctxi->ctrl_map) {
|
|
writeq_be(0, &ctxi->ctrl_map->rht_start);
|
|
writeq_be(0, &ctxi->ctrl_map->rht_cnt_id);
|
|
writeq_be(0, &ctxi->ctrl_map->ctx_cap);
|
|
}
|
|
}
|
|
|
|
/* Free memory associated with context */
|
|
free_page((ulong)ctxi->rht_start);
|
|
kfree(ctxi->rht_needs_ws);
|
|
kfree(ctxi->rht_lun);
|
|
kfree(ctxi);
|
|
}
|
|
|
|
/**
|
|
* create_context() - allocates and initializes a context
|
|
* @cfg: Internal structure associated with the host.
|
|
*
|
|
* Return: Allocated context on success, NULL on failure
|
|
*/
|
|
static struct ctx_info *create_context(struct cxlflash_cfg *cfg)
|
|
{
|
|
struct device *dev = &cfg->dev->dev;
|
|
struct ctx_info *ctxi = NULL;
|
|
struct llun_info **lli = NULL;
|
|
u8 *ws = NULL;
|
|
struct sisl_rht_entry *rhte;
|
|
|
|
ctxi = kzalloc(sizeof(*ctxi), GFP_KERNEL);
|
|
lli = kzalloc((MAX_RHT_PER_CONTEXT * sizeof(*lli)), GFP_KERNEL);
|
|
ws = kzalloc((MAX_RHT_PER_CONTEXT * sizeof(*ws)), GFP_KERNEL);
|
|
if (unlikely(!ctxi || !lli || !ws)) {
|
|
dev_err(dev, "%s: Unable to allocate context\n", __func__);
|
|
goto err;
|
|
}
|
|
|
|
rhte = (struct sisl_rht_entry *)get_zeroed_page(GFP_KERNEL);
|
|
if (unlikely(!rhte)) {
|
|
dev_err(dev, "%s: Unable to allocate RHT\n", __func__);
|
|
goto err;
|
|
}
|
|
|
|
ctxi->rht_lun = lli;
|
|
ctxi->rht_needs_ws = ws;
|
|
ctxi->rht_start = rhte;
|
|
out:
|
|
return ctxi;
|
|
|
|
err:
|
|
kfree(ws);
|
|
kfree(lli);
|
|
kfree(ctxi);
|
|
ctxi = NULL;
|
|
goto out;
|
|
}
|
|
|
|
/**
|
|
* init_context() - initializes a previously allocated context
|
|
* @ctxi: Previously allocated context
|
|
* @cfg: Internal structure associated with the host.
|
|
* @ctx: Previously obtained CXL context reference.
|
|
* @ctxid: Previously obtained process element associated with CXL context.
|
|
* @file: Previously obtained file associated with CXL context.
|
|
* @perms: User-specified permissions.
|
|
*/
|
|
static void init_context(struct ctx_info *ctxi, struct cxlflash_cfg *cfg,
|
|
struct cxl_context *ctx, int ctxid, struct file *file,
|
|
u32 perms)
|
|
{
|
|
struct afu *afu = cfg->afu;
|
|
|
|
ctxi->rht_perms = perms;
|
|
ctxi->ctrl_map = &afu->afu_map->ctrls[ctxid].ctrl;
|
|
ctxi->ctxid = ENCODE_CTXID(ctxi, ctxid);
|
|
ctxi->pid = current->tgid; /* tgid = pid */
|
|
ctxi->ctx = ctx;
|
|
ctxi->cfg = cfg;
|
|
ctxi->file = file;
|
|
ctxi->initialized = true;
|
|
mutex_init(&ctxi->mutex);
|
|
kref_init(&ctxi->kref);
|
|
INIT_LIST_HEAD(&ctxi->luns);
|
|
INIT_LIST_HEAD(&ctxi->list); /* initialize for list_empty() */
|
|
}
|
|
|
|
/**
|
|
* remove_context() - context kref release handler
|
|
* @kref: Kernel reference associated with context to be removed.
|
|
*
|
|
* When a context no longer has any references it can safely be removed
|
|
* from global access and destroyed. Note that it is assumed the thread
|
|
* relinquishing access to the context holds its mutex.
|
|
*/
|
|
static void remove_context(struct kref *kref)
|
|
{
|
|
struct ctx_info *ctxi = container_of(kref, struct ctx_info, kref);
|
|
struct cxlflash_cfg *cfg = ctxi->cfg;
|
|
u64 ctxid = DECODE_CTXID(ctxi->ctxid);
|
|
|
|
/* Remove context from table/error list */
|
|
WARN_ON(!mutex_is_locked(&ctxi->mutex));
|
|
ctxi->unavail = true;
|
|
mutex_unlock(&ctxi->mutex);
|
|
mutex_lock(&cfg->ctx_tbl_list_mutex);
|
|
mutex_lock(&ctxi->mutex);
|
|
|
|
if (!list_empty(&ctxi->list))
|
|
list_del(&ctxi->list);
|
|
cfg->ctx_tbl[ctxid] = NULL;
|
|
mutex_unlock(&cfg->ctx_tbl_list_mutex);
|
|
mutex_unlock(&ctxi->mutex);
|
|
|
|
/* Context now completely uncoupled/unreachable */
|
|
destroy_context(cfg, ctxi);
|
|
}
|
|
|
|
/**
|
|
* _cxlflash_disk_detach() - detaches a LUN from a context
|
|
* @sdev: SCSI device associated with LUN.
|
|
* @ctxi: Context owning resources.
|
|
* @detach: Detach ioctl data structure.
|
|
*
|
|
* As part of the detach, all per-context resources associated with the LUN
|
|
* are cleaned up. When detaching the last LUN for a context, the context
|
|
* itself is cleaned up and released.
|
|
*
|
|
* Return: 0 on success, -errno on failure
|
|
*/
|
|
static int _cxlflash_disk_detach(struct scsi_device *sdev,
|
|
struct ctx_info *ctxi,
|
|
struct dk_cxlflash_detach *detach)
|
|
{
|
|
struct cxlflash_cfg *cfg = shost_priv(sdev->host);
|
|
struct device *dev = &cfg->dev->dev;
|
|
struct llun_info *lli = sdev->hostdata;
|
|
struct lun_access *lun_access, *t;
|
|
struct dk_cxlflash_release rel;
|
|
bool put_ctx = false;
|
|
|
|
int i;
|
|
int rc = 0;
|
|
u64 ctxid = DECODE_CTXID(detach->context_id),
|
|
rctxid = detach->context_id;
|
|
|
|
dev_dbg(dev, "%s: ctxid=%llu\n", __func__, ctxid);
|
|
|
|
if (!ctxi) {
|
|
ctxi = get_context(cfg, rctxid, lli, CTX_CTRL_ERR_FALLBACK);
|
|
if (unlikely(!ctxi)) {
|
|
dev_dbg(dev, "%s: Bad context ctxid=%llu\n",
|
|
__func__, ctxid);
|
|
rc = -EINVAL;
|
|
goto out;
|
|
}
|
|
|
|
put_ctx = true;
|
|
}
|
|
|
|
/* Cleanup outstanding resources tied to this LUN */
|
|
if (ctxi->rht_out) {
|
|
marshal_det_to_rele(detach, &rel);
|
|
for (i = 0; i < MAX_RHT_PER_CONTEXT; i++) {
|
|
if (ctxi->rht_lun[i] == lli) {
|
|
rel.rsrc_handle = i;
|
|
_cxlflash_disk_release(sdev, ctxi, &rel);
|
|
}
|
|
|
|
/* No need to loop further if we're done */
|
|
if (ctxi->rht_out == 0)
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Take our LUN out of context, free the node */
|
|
list_for_each_entry_safe(lun_access, t, &ctxi->luns, list)
|
|
if (lun_access->lli == lli) {
|
|
list_del(&lun_access->list);
|
|
kfree(lun_access);
|
|
lun_access = NULL;
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* Release the context reference and the sdev reference that
|
|
* bound this LUN to the context.
|
|
*/
|
|
if (kref_put(&ctxi->kref, remove_context))
|
|
put_ctx = false;
|
|
scsi_device_put(sdev);
|
|
out:
|
|
if (put_ctx)
|
|
put_context(ctxi);
|
|
dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
|
|
return rc;
|
|
}
|
|
|
|
static int cxlflash_disk_detach(struct scsi_device *sdev,
|
|
struct dk_cxlflash_detach *detach)
|
|
{
|
|
return _cxlflash_disk_detach(sdev, NULL, detach);
|
|
}
|
|
|
|
/**
|
|
* cxlflash_cxl_release() - release handler for adapter file descriptor
|
|
* @inode: File-system inode associated with fd.
|
|
* @file: File installed with adapter file descriptor.
|
|
*
|
|
* This routine is the release handler for the fops registered with
|
|
* the CXL services on an initial attach for a context. It is called
|
|
* when a close (explicity by the user or as part of a process tear
|
|
* down) is performed on the adapter file descriptor returned to the
|
|
* user. The user should be aware that explicitly performing a close
|
|
* considered catastrophic and subsequent usage of the superpipe API
|
|
* with previously saved off tokens will fail.
|
|
*
|
|
* This routine derives the context reference and calls detach for
|
|
* each LUN associated with the context.The final detach operation
|
|
* causes the context itself to be freed. With exception to when the
|
|
* CXL process element (context id) lookup fails (a case that should
|
|
* theoretically never occur), every call into this routine results
|
|
* in a complete freeing of a context.
|
|
*
|
|
* Return: 0 on success
|
|
*/
|
|
static int cxlflash_cxl_release(struct inode *inode, struct file *file)
|
|
{
|
|
struct cxl_context *ctx = cxl_fops_get_context(file);
|
|
struct cxlflash_cfg *cfg = container_of(file->f_op, struct cxlflash_cfg,
|
|
cxl_fops);
|
|
struct device *dev = &cfg->dev->dev;
|
|
struct ctx_info *ctxi = NULL;
|
|
struct dk_cxlflash_detach detach = { { 0 }, 0 };
|
|
struct lun_access *lun_access, *t;
|
|
enum ctx_ctrl ctrl = CTX_CTRL_ERR_FALLBACK | CTX_CTRL_FILE;
|
|
int ctxid;
|
|
|
|
ctxid = cxl_process_element(ctx);
|
|
if (unlikely(ctxid < 0)) {
|
|
dev_err(dev, "%s: Context %p was closed ctxid=%d\n",
|
|
__func__, ctx, ctxid);
|
|
goto out;
|
|
}
|
|
|
|
ctxi = get_context(cfg, ctxid, file, ctrl);
|
|
if (unlikely(!ctxi)) {
|
|
ctxi = get_context(cfg, ctxid, file, ctrl | CTX_CTRL_CLONE);
|
|
if (!ctxi) {
|
|
dev_dbg(dev, "%s: ctxid=%d already free\n",
|
|
__func__, ctxid);
|
|
goto out_release;
|
|
}
|
|
|
|
dev_dbg(dev, "%s: Another process owns ctxid=%d\n",
|
|
__func__, ctxid);
|
|
put_context(ctxi);
|
|
goto out;
|
|
}
|
|
|
|
dev_dbg(dev, "%s: close for ctxid=%d\n", __func__, ctxid);
|
|
|
|
detach.context_id = ctxi->ctxid;
|
|
list_for_each_entry_safe(lun_access, t, &ctxi->luns, list)
|
|
_cxlflash_disk_detach(lun_access->sdev, ctxi, &detach);
|
|
out_release:
|
|
cxl_fd_release(inode, file);
|
|
out:
|
|
dev_dbg(dev, "%s: returning\n", __func__);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* unmap_context() - clears a previously established mapping
|
|
* @ctxi: Context owning the mapping.
|
|
*
|
|
* This routine is used to switch between the error notification page
|
|
* (dummy page of all 1's) and the real mapping (established by the CXL
|
|
* fault handler).
|
|
*/
|
|
static void unmap_context(struct ctx_info *ctxi)
|
|
{
|
|
unmap_mapping_range(ctxi->file->f_mapping, 0, 0, 1);
|
|
}
|
|
|
|
/**
|
|
* get_err_page() - obtains and allocates the error notification page
|
|
* @cfg: Internal structure associated with the host.
|
|
*
|
|
* Return: error notification page on success, NULL on failure
|
|
*/
|
|
static struct page *get_err_page(struct cxlflash_cfg *cfg)
|
|
{
|
|
struct page *err_page = global.err_page;
|
|
struct device *dev = &cfg->dev->dev;
|
|
|
|
if (unlikely(!err_page)) {
|
|
err_page = alloc_page(GFP_KERNEL);
|
|
if (unlikely(!err_page)) {
|
|
dev_err(dev, "%s: Unable to allocate err_page\n",
|
|
__func__);
|
|
goto out;
|
|
}
|
|
|
|
memset(page_address(err_page), -1, PAGE_SIZE);
|
|
|
|
/* Serialize update w/ other threads to avoid a leak */
|
|
mutex_lock(&global.mutex);
|
|
if (likely(!global.err_page))
|
|
global.err_page = err_page;
|
|
else {
|
|
__free_page(err_page);
|
|
err_page = global.err_page;
|
|
}
|
|
mutex_unlock(&global.mutex);
|
|
}
|
|
|
|
out:
|
|
dev_dbg(dev, "%s: returning err_page=%p\n", __func__, err_page);
|
|
return err_page;
|
|
}
|
|
|
|
/**
|
|
* cxlflash_mmap_fault() - mmap fault handler for adapter file descriptor
|
|
* @vmf: VM fault associated with current fault.
|
|
*
|
|
* To support error notification via MMIO, faults are 'caught' by this routine
|
|
* that was inserted before passing back the adapter file descriptor on attach.
|
|
* When a fault occurs, this routine evaluates if error recovery is active and
|
|
* if so, installs the error page to 'notify' the user about the error state.
|
|
* During normal operation, the fault is simply handled by the original fault
|
|
* handler that was installed by CXL services as part of initializing the
|
|
* adapter file descriptor. The VMA's page protection bits are toggled to
|
|
* indicate cached/not-cached depending on the memory backing the fault.
|
|
*
|
|
* Return: 0 on success, VM_FAULT_SIGBUS on failure
|
|
*/
|
|
static int cxlflash_mmap_fault(struct vm_fault *vmf)
|
|
{
|
|
struct vm_area_struct *vma = vmf->vma;
|
|
struct file *file = vma->vm_file;
|
|
struct cxl_context *ctx = cxl_fops_get_context(file);
|
|
struct cxlflash_cfg *cfg = container_of(file->f_op, struct cxlflash_cfg,
|
|
cxl_fops);
|
|
struct device *dev = &cfg->dev->dev;
|
|
struct ctx_info *ctxi = NULL;
|
|
struct page *err_page = NULL;
|
|
enum ctx_ctrl ctrl = CTX_CTRL_ERR_FALLBACK | CTX_CTRL_FILE;
|
|
int rc = 0;
|
|
int ctxid;
|
|
|
|
ctxid = cxl_process_element(ctx);
|
|
if (unlikely(ctxid < 0)) {
|
|
dev_err(dev, "%s: Context %p was closed ctxid=%d\n",
|
|
__func__, ctx, ctxid);
|
|
goto err;
|
|
}
|
|
|
|
ctxi = get_context(cfg, ctxid, file, ctrl);
|
|
if (unlikely(!ctxi)) {
|
|
dev_dbg(dev, "%s: Bad context ctxid=%d\n", __func__, ctxid);
|
|
goto err;
|
|
}
|
|
|
|
dev_dbg(dev, "%s: fault for context %d\n", __func__, ctxid);
|
|
|
|
if (likely(!ctxi->err_recovery_active)) {
|
|
vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
|
|
rc = ctxi->cxl_mmap_vmops->fault(vmf);
|
|
} else {
|
|
dev_dbg(dev, "%s: err recovery active, use err_page\n",
|
|
__func__);
|
|
|
|
err_page = get_err_page(cfg);
|
|
if (unlikely(!err_page)) {
|
|
dev_err(dev, "%s: Could not get err_page\n", __func__);
|
|
rc = VM_FAULT_RETRY;
|
|
goto out;
|
|
}
|
|
|
|
get_page(err_page);
|
|
vmf->page = err_page;
|
|
vma->vm_page_prot = pgprot_cached(vma->vm_page_prot);
|
|
}
|
|
|
|
out:
|
|
if (likely(ctxi))
|
|
put_context(ctxi);
|
|
dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
|
|
return rc;
|
|
|
|
err:
|
|
rc = VM_FAULT_SIGBUS;
|
|
goto out;
|
|
}
|
|
|
|
/*
|
|
* Local MMAP vmops to 'catch' faults
|
|
*/
|
|
static const struct vm_operations_struct cxlflash_mmap_vmops = {
|
|
.fault = cxlflash_mmap_fault,
|
|
};
|
|
|
|
/**
|
|
* cxlflash_cxl_mmap() - mmap handler for adapter file descriptor
|
|
* @file: File installed with adapter file descriptor.
|
|
* @vma: VM area associated with mapping.
|
|
*
|
|
* Installs local mmap vmops to 'catch' faults for error notification support.
|
|
*
|
|
* Return: 0 on success, -errno on failure
|
|
*/
|
|
static int cxlflash_cxl_mmap(struct file *file, struct vm_area_struct *vma)
|
|
{
|
|
struct cxl_context *ctx = cxl_fops_get_context(file);
|
|
struct cxlflash_cfg *cfg = container_of(file->f_op, struct cxlflash_cfg,
|
|
cxl_fops);
|
|
struct device *dev = &cfg->dev->dev;
|
|
struct ctx_info *ctxi = NULL;
|
|
enum ctx_ctrl ctrl = CTX_CTRL_ERR_FALLBACK | CTX_CTRL_FILE;
|
|
int ctxid;
|
|
int rc = 0;
|
|
|
|
ctxid = cxl_process_element(ctx);
|
|
if (unlikely(ctxid < 0)) {
|
|
dev_err(dev, "%s: Context %p was closed ctxid=%d\n",
|
|
__func__, ctx, ctxid);
|
|
rc = -EIO;
|
|
goto out;
|
|
}
|
|
|
|
ctxi = get_context(cfg, ctxid, file, ctrl);
|
|
if (unlikely(!ctxi)) {
|
|
dev_dbg(dev, "%s: Bad context ctxid=%d\n", __func__, ctxid);
|
|
rc = -EIO;
|
|
goto out;
|
|
}
|
|
|
|
dev_dbg(dev, "%s: mmap for context %d\n", __func__, ctxid);
|
|
|
|
rc = cxl_fd_mmap(file, vma);
|
|
if (likely(!rc)) {
|
|
/* Insert ourself in the mmap fault handler path */
|
|
ctxi->cxl_mmap_vmops = vma->vm_ops;
|
|
vma->vm_ops = &cxlflash_mmap_vmops;
|
|
}
|
|
|
|
out:
|
|
if (likely(ctxi))
|
|
put_context(ctxi);
|
|
return rc;
|
|
}
|
|
|
|
const struct file_operations cxlflash_cxl_fops = {
|
|
.owner = THIS_MODULE,
|
|
.mmap = cxlflash_cxl_mmap,
|
|
.release = cxlflash_cxl_release,
|
|
};
|
|
|
|
/**
|
|
* cxlflash_mark_contexts_error() - move contexts to error state and list
|
|
* @cfg: Internal structure associated with the host.
|
|
*
|
|
* A context is only moved over to the error list when there are no outstanding
|
|
* references to it. This ensures that a running operation has completed.
|
|
*
|
|
* Return: 0 on success, -errno on failure
|
|
*/
|
|
int cxlflash_mark_contexts_error(struct cxlflash_cfg *cfg)
|
|
{
|
|
int i, rc = 0;
|
|
struct ctx_info *ctxi = NULL;
|
|
|
|
mutex_lock(&cfg->ctx_tbl_list_mutex);
|
|
|
|
for (i = 0; i < MAX_CONTEXT; i++) {
|
|
ctxi = cfg->ctx_tbl[i];
|
|
if (ctxi) {
|
|
mutex_lock(&ctxi->mutex);
|
|
cfg->ctx_tbl[i] = NULL;
|
|
list_add(&ctxi->list, &cfg->ctx_err_recovery);
|
|
ctxi->err_recovery_active = true;
|
|
ctxi->ctrl_map = NULL;
|
|
unmap_context(ctxi);
|
|
mutex_unlock(&ctxi->mutex);
|
|
}
|
|
}
|
|
|
|
mutex_unlock(&cfg->ctx_tbl_list_mutex);
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
* Dummy NULL fops
|
|
*/
|
|
static const struct file_operations null_fops = {
|
|
.owner = THIS_MODULE,
|
|
};
|
|
|
|
/**
|
|
* check_state() - checks and responds to the current adapter state
|
|
* @cfg: Internal structure associated with the host.
|
|
*
|
|
* This routine can block and should only be used on process context.
|
|
* It assumes that the caller is an ioctl thread and holding the ioctl
|
|
* read semaphore. This is temporarily let up across the wait to allow
|
|
* for draining actively running ioctls. Also note that when waking up
|
|
* from waiting in reset, the state is unknown and must be checked again
|
|
* before proceeding.
|
|
*
|
|
* Return: 0 on success, -errno on failure
|
|
*/
|
|
int check_state(struct cxlflash_cfg *cfg)
|
|
{
|
|
struct device *dev = &cfg->dev->dev;
|
|
int rc = 0;
|
|
|
|
retry:
|
|
switch (cfg->state) {
|
|
case STATE_RESET:
|
|
dev_dbg(dev, "%s: Reset state, going to wait...\n", __func__);
|
|
up_read(&cfg->ioctl_rwsem);
|
|
rc = wait_event_interruptible(cfg->reset_waitq,
|
|
cfg->state != STATE_RESET);
|
|
down_read(&cfg->ioctl_rwsem);
|
|
if (unlikely(rc))
|
|
break;
|
|
goto retry;
|
|
case STATE_FAILTERM:
|
|
dev_dbg(dev, "%s: Failed/Terminating\n", __func__);
|
|
rc = -ENODEV;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* cxlflash_disk_attach() - attach a LUN to a context
|
|
* @sdev: SCSI device associated with LUN.
|
|
* @attach: Attach ioctl data structure.
|
|
*
|
|
* Creates a context and attaches LUN to it. A LUN can only be attached
|
|
* one time to a context (subsequent attaches for the same context/LUN pair
|
|
* are not supported). Additional LUNs can be attached to a context by
|
|
* specifying the 'reuse' flag defined in the cxlflash_ioctl.h header.
|
|
*
|
|
* Return: 0 on success, -errno on failure
|
|
*/
|
|
static int cxlflash_disk_attach(struct scsi_device *sdev,
|
|
struct dk_cxlflash_attach *attach)
|
|
{
|
|
struct cxlflash_cfg *cfg = shost_priv(sdev->host);
|
|
struct device *dev = &cfg->dev->dev;
|
|
struct afu *afu = cfg->afu;
|
|
struct llun_info *lli = sdev->hostdata;
|
|
struct glun_info *gli = lli->parent;
|
|
struct cxl_ioctl_start_work *work;
|
|
struct ctx_info *ctxi = NULL;
|
|
struct lun_access *lun_access = NULL;
|
|
int rc = 0;
|
|
u32 perms;
|
|
int ctxid = -1;
|
|
u64 flags = 0UL;
|
|
u64 rctxid = 0UL;
|
|
struct file *file = NULL;
|
|
|
|
struct cxl_context *ctx = NULL;
|
|
|
|
int fd = -1;
|
|
|
|
if (attach->num_interrupts > 4) {
|
|
dev_dbg(dev, "%s: Cannot support this many interrupts %llu\n",
|
|
__func__, attach->num_interrupts);
|
|
rc = -EINVAL;
|
|
goto out;
|
|
}
|
|
|
|
if (gli->max_lba == 0) {
|
|
dev_dbg(dev, "%s: No capacity info for LUN=%016llx\n",
|
|
__func__, lli->lun_id[sdev->channel]);
|
|
rc = read_cap16(sdev, lli);
|
|
if (rc) {
|
|
dev_err(dev, "%s: Invalid device rc=%d\n",
|
|
__func__, rc);
|
|
rc = -ENODEV;
|
|
goto out;
|
|
}
|
|
dev_dbg(dev, "%s: LBA = %016llx\n", __func__, gli->max_lba);
|
|
dev_dbg(dev, "%s: BLK_LEN = %08x\n", __func__, gli->blk_len);
|
|
}
|
|
|
|
if (attach->hdr.flags & DK_CXLFLASH_ATTACH_REUSE_CONTEXT) {
|
|
rctxid = attach->context_id;
|
|
ctxi = get_context(cfg, rctxid, NULL, 0);
|
|
if (!ctxi) {
|
|
dev_dbg(dev, "%s: Bad context rctxid=%016llx\n",
|
|
__func__, rctxid);
|
|
rc = -EINVAL;
|
|
goto out;
|
|
}
|
|
|
|
list_for_each_entry(lun_access, &ctxi->luns, list)
|
|
if (lun_access->lli == lli) {
|
|
dev_dbg(dev, "%s: Already attached\n",
|
|
__func__);
|
|
rc = -EINVAL;
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
rc = scsi_device_get(sdev);
|
|
if (unlikely(rc)) {
|
|
dev_err(dev, "%s: Unable to get sdev reference\n", __func__);
|
|
goto out;
|
|
}
|
|
|
|
lun_access = kzalloc(sizeof(*lun_access), GFP_KERNEL);
|
|
if (unlikely(!lun_access)) {
|
|
dev_err(dev, "%s: Unable to allocate lun_access\n", __func__);
|
|
rc = -ENOMEM;
|
|
goto err;
|
|
}
|
|
|
|
lun_access->lli = lli;
|
|
lun_access->sdev = sdev;
|
|
|
|
/* Non-NULL context indicates reuse (another context reference) */
|
|
if (ctxi) {
|
|
dev_dbg(dev, "%s: Reusing context for LUN rctxid=%016llx\n",
|
|
__func__, rctxid);
|
|
kref_get(&ctxi->kref);
|
|
list_add(&lun_access->list, &ctxi->luns);
|
|
goto out_attach;
|
|
}
|
|
|
|
ctxi = create_context(cfg);
|
|
if (unlikely(!ctxi)) {
|
|
dev_err(dev, "%s: Failed to create context ctxid=%d\n",
|
|
__func__, ctxid);
|
|
goto err;
|
|
}
|
|
|
|
ctx = cxl_dev_context_init(cfg->dev);
|
|
if (IS_ERR_OR_NULL(ctx)) {
|
|
dev_err(dev, "%s: Could not initialize context %p\n",
|
|
__func__, ctx);
|
|
rc = -ENODEV;
|
|
goto err;
|
|
}
|
|
|
|
work = &ctxi->work;
|
|
work->num_interrupts = attach->num_interrupts;
|
|
work->flags = CXL_START_WORK_NUM_IRQS;
|
|
|
|
rc = cxl_start_work(ctx, work);
|
|
if (unlikely(rc)) {
|
|
dev_dbg(dev, "%s: Could not start context rc=%d\n",
|
|
__func__, rc);
|
|
goto err;
|
|
}
|
|
|
|
ctxid = cxl_process_element(ctx);
|
|
if (unlikely((ctxid >= MAX_CONTEXT) || (ctxid < 0))) {
|
|
dev_err(dev, "%s: ctxid=%d invalid\n", __func__, ctxid);
|
|
rc = -EPERM;
|
|
goto err;
|
|
}
|
|
|
|
file = cxl_get_fd(ctx, &cfg->cxl_fops, &fd);
|
|
if (unlikely(fd < 0)) {
|
|
rc = -ENODEV;
|
|
dev_err(dev, "%s: Could not get file descriptor\n", __func__);
|
|
goto err;
|
|
}
|
|
|
|
/* Translate read/write O_* flags from fcntl.h to AFU permission bits */
|
|
perms = SISL_RHT_PERM(attach->hdr.flags + 1);
|
|
|
|
/* Context mutex is locked upon return */
|
|
init_context(ctxi, cfg, ctx, ctxid, file, perms);
|
|
|
|
rc = afu_attach(cfg, ctxi);
|
|
if (unlikely(rc)) {
|
|
dev_err(dev, "%s: Could not attach AFU rc %d\n", __func__, rc);
|
|
goto err;
|
|
}
|
|
|
|
/*
|
|
* No error paths after this point. Once the fd is installed it's
|
|
* visible to user space and can't be undone safely on this thread.
|
|
* There is no need to worry about a deadlock here because no one
|
|
* knows about us yet; we can be the only one holding our mutex.
|
|
*/
|
|
list_add(&lun_access->list, &ctxi->luns);
|
|
mutex_lock(&cfg->ctx_tbl_list_mutex);
|
|
mutex_lock(&ctxi->mutex);
|
|
cfg->ctx_tbl[ctxid] = ctxi;
|
|
mutex_unlock(&cfg->ctx_tbl_list_mutex);
|
|
fd_install(fd, file);
|
|
|
|
out_attach:
|
|
if (fd != -1)
|
|
flags |= DK_CXLFLASH_APP_CLOSE_ADAP_FD;
|
|
if (afu_is_sq_cmd_mode(afu))
|
|
flags |= DK_CXLFLASH_CONTEXT_SQ_CMD_MODE;
|
|
|
|
attach->hdr.return_flags = flags;
|
|
attach->context_id = ctxi->ctxid;
|
|
attach->block_size = gli->blk_len;
|
|
attach->mmio_size = sizeof(afu->afu_map->hosts[0].harea);
|
|
attach->last_lba = gli->max_lba;
|
|
attach->max_xfer = sdev->host->max_sectors * MAX_SECTOR_UNIT;
|
|
attach->max_xfer /= gli->blk_len;
|
|
|
|
out:
|
|
attach->adap_fd = fd;
|
|
|
|
if (ctxi)
|
|
put_context(ctxi);
|
|
|
|
dev_dbg(dev, "%s: returning ctxid=%d fd=%d bs=%lld rc=%d llba=%lld\n",
|
|
__func__, ctxid, fd, attach->block_size, rc, attach->last_lba);
|
|
return rc;
|
|
|
|
err:
|
|
/* Cleanup CXL context; okay to 'stop' even if it was not started */
|
|
if (!IS_ERR_OR_NULL(ctx)) {
|
|
cxl_stop_context(ctx);
|
|
cxl_release_context(ctx);
|
|
ctx = NULL;
|
|
}
|
|
|
|
/*
|
|
* Here, we're overriding the fops with a dummy all-NULL fops because
|
|
* fput() calls the release fop, which will cause us to mistakenly
|
|
* call into the CXL code. Rather than try to add yet more complexity
|
|
* to that routine (cxlflash_cxl_release) we should try to fix the
|
|
* issue here.
|
|
*/
|
|
if (fd > 0) {
|
|
file->f_op = &null_fops;
|
|
fput(file);
|
|
put_unused_fd(fd);
|
|
fd = -1;
|
|
file = NULL;
|
|
}
|
|
|
|
/* Cleanup our context */
|
|
if (ctxi) {
|
|
destroy_context(cfg, ctxi);
|
|
ctxi = NULL;
|
|
}
|
|
|
|
kfree(lun_access);
|
|
scsi_device_put(sdev);
|
|
goto out;
|
|
}
|
|
|
|
/**
|
|
* recover_context() - recovers a context in error
|
|
* @cfg: Internal structure associated with the host.
|
|
* @ctxi: Context to release.
|
|
* @adap_fd: Adapter file descriptor associated with new/recovered context.
|
|
*
|
|
* Restablishes the state for a context-in-error.
|
|
*
|
|
* Return: 0 on success, -errno on failure
|
|
*/
|
|
static int recover_context(struct cxlflash_cfg *cfg,
|
|
struct ctx_info *ctxi,
|
|
int *adap_fd)
|
|
{
|
|
struct device *dev = &cfg->dev->dev;
|
|
int rc = 0;
|
|
int fd = -1;
|
|
int ctxid = -1;
|
|
struct file *file;
|
|
struct cxl_context *ctx;
|
|
struct afu *afu = cfg->afu;
|
|
|
|
ctx = cxl_dev_context_init(cfg->dev);
|
|
if (IS_ERR_OR_NULL(ctx)) {
|
|
dev_err(dev, "%s: Could not initialize context %p\n",
|
|
__func__, ctx);
|
|
rc = -ENODEV;
|
|
goto out;
|
|
}
|
|
|
|
rc = cxl_start_work(ctx, &ctxi->work);
|
|
if (unlikely(rc)) {
|
|
dev_dbg(dev, "%s: Could not start context rc=%d\n",
|
|
__func__, rc);
|
|
goto err1;
|
|
}
|
|
|
|
ctxid = cxl_process_element(ctx);
|
|
if (unlikely((ctxid >= MAX_CONTEXT) || (ctxid < 0))) {
|
|
dev_err(dev, "%s: ctxid=%d invalid\n", __func__, ctxid);
|
|
rc = -EPERM;
|
|
goto err2;
|
|
}
|
|
|
|
file = cxl_get_fd(ctx, &cfg->cxl_fops, &fd);
|
|
if (unlikely(fd < 0)) {
|
|
rc = -ENODEV;
|
|
dev_err(dev, "%s: Could not get file descriptor\n", __func__);
|
|
goto err2;
|
|
}
|
|
|
|
/* Update with new MMIO area based on updated context id */
|
|
ctxi->ctrl_map = &afu->afu_map->ctrls[ctxid].ctrl;
|
|
|
|
rc = afu_attach(cfg, ctxi);
|
|
if (rc) {
|
|
dev_err(dev, "%s: Could not attach AFU rc %d\n", __func__, rc);
|
|
goto err3;
|
|
}
|
|
|
|
/*
|
|
* No error paths after this point. Once the fd is installed it's
|
|
* visible to user space and can't be undone safely on this thread.
|
|
*/
|
|
ctxi->ctxid = ENCODE_CTXID(ctxi, ctxid);
|
|
ctxi->ctx = ctx;
|
|
ctxi->file = file;
|
|
|
|
/*
|
|
* Put context back in table (note the reinit of the context list);
|
|
* we must first drop the context's mutex and then acquire it in
|
|
* order with the table/list mutex to avoid a deadlock - safe to do
|
|
* here because no one can find us at this moment in time.
|
|
*/
|
|
mutex_unlock(&ctxi->mutex);
|
|
mutex_lock(&cfg->ctx_tbl_list_mutex);
|
|
mutex_lock(&ctxi->mutex);
|
|
list_del_init(&ctxi->list);
|
|
cfg->ctx_tbl[ctxid] = ctxi;
|
|
mutex_unlock(&cfg->ctx_tbl_list_mutex);
|
|
fd_install(fd, file);
|
|
*adap_fd = fd;
|
|
out:
|
|
dev_dbg(dev, "%s: returning ctxid=%d fd=%d rc=%d\n",
|
|
__func__, ctxid, fd, rc);
|
|
return rc;
|
|
|
|
err3:
|
|
fput(file);
|
|
put_unused_fd(fd);
|
|
err2:
|
|
cxl_stop_context(ctx);
|
|
err1:
|
|
cxl_release_context(ctx);
|
|
goto out;
|
|
}
|
|
|
|
/**
|
|
* cxlflash_afu_recover() - initiates AFU recovery
|
|
* @sdev: SCSI device associated with LUN.
|
|
* @recover: Recover ioctl data structure.
|
|
*
|
|
* Only a single recovery is allowed at a time to avoid exhausting CXL
|
|
* resources (leading to recovery failure) in the event that we're up
|
|
* against the maximum number of contexts limit. For similar reasons,
|
|
* a context recovery is retried if there are multiple recoveries taking
|
|
* place at the same time and the failure was due to CXL services being
|
|
* unable to keep up.
|
|
*
|
|
* As this routine is called on ioctl context, it holds the ioctl r/w
|
|
* semaphore that is used to drain ioctls in recovery scenarios. The
|
|
* implementation to achieve the pacing described above (a local mutex)
|
|
* requires that the ioctl r/w semaphore be dropped and reacquired to
|
|
* avoid a 3-way deadlock when multiple process recoveries operate in
|
|
* parallel.
|
|
*
|
|
* Because a user can detect an error condition before the kernel, it is
|
|
* quite possible for this routine to act as the kernel's EEH detection
|
|
* source (MMIO read of mbox_r). Because of this, there is a window of
|
|
* time where an EEH might have been detected but not yet 'serviced'
|
|
* (callback invoked, causing the device to enter reset state). To avoid
|
|
* looping in this routine during that window, a 1 second sleep is in place
|
|
* between the time the MMIO failure is detected and the time a wait on the
|
|
* reset wait queue is attempted via check_state().
|
|
*
|
|
* Return: 0 on success, -errno on failure
|
|
*/
|
|
static int cxlflash_afu_recover(struct scsi_device *sdev,
|
|
struct dk_cxlflash_recover_afu *recover)
|
|
{
|
|
struct cxlflash_cfg *cfg = shost_priv(sdev->host);
|
|
struct device *dev = &cfg->dev->dev;
|
|
struct llun_info *lli = sdev->hostdata;
|
|
struct afu *afu = cfg->afu;
|
|
struct ctx_info *ctxi = NULL;
|
|
struct mutex *mutex = &cfg->ctx_recovery_mutex;
|
|
struct hwq *hwq = get_hwq(afu, PRIMARY_HWQ);
|
|
u64 flags;
|
|
u64 ctxid = DECODE_CTXID(recover->context_id),
|
|
rctxid = recover->context_id;
|
|
long reg;
|
|
int lretry = 20; /* up to 2 seconds */
|
|
int new_adap_fd = -1;
|
|
int rc = 0;
|
|
|
|
atomic_inc(&cfg->recovery_threads);
|
|
up_read(&cfg->ioctl_rwsem);
|
|
rc = mutex_lock_interruptible(mutex);
|
|
down_read(&cfg->ioctl_rwsem);
|
|
if (rc)
|
|
goto out;
|
|
rc = check_state(cfg);
|
|
if (rc) {
|
|
dev_err(dev, "%s: Failed state rc=%d\n", __func__, rc);
|
|
rc = -ENODEV;
|
|
goto out;
|
|
}
|
|
|
|
dev_dbg(dev, "%s: reason=%016llx rctxid=%016llx\n",
|
|
__func__, recover->reason, rctxid);
|
|
|
|
retry:
|
|
/* Ensure that this process is attached to the context */
|
|
ctxi = get_context(cfg, rctxid, lli, CTX_CTRL_ERR_FALLBACK);
|
|
if (unlikely(!ctxi)) {
|
|
dev_dbg(dev, "%s: Bad context ctxid=%llu\n", __func__, ctxid);
|
|
rc = -EINVAL;
|
|
goto out;
|
|
}
|
|
|
|
if (ctxi->err_recovery_active) {
|
|
retry_recover:
|
|
rc = recover_context(cfg, ctxi, &new_adap_fd);
|
|
if (unlikely(rc)) {
|
|
dev_err(dev, "%s: Recovery failed ctxid=%llu rc=%d\n",
|
|
__func__, ctxid, rc);
|
|
if ((rc == -ENODEV) &&
|
|
((atomic_read(&cfg->recovery_threads) > 1) ||
|
|
(lretry--))) {
|
|
dev_dbg(dev, "%s: Going to try again\n",
|
|
__func__);
|
|
mutex_unlock(mutex);
|
|
msleep(100);
|
|
rc = mutex_lock_interruptible(mutex);
|
|
if (rc)
|
|
goto out;
|
|
goto retry_recover;
|
|
}
|
|
|
|
goto out;
|
|
}
|
|
|
|
ctxi->err_recovery_active = false;
|
|
|
|
flags = DK_CXLFLASH_APP_CLOSE_ADAP_FD |
|
|
DK_CXLFLASH_RECOVER_AFU_CONTEXT_RESET;
|
|
if (afu_is_sq_cmd_mode(afu))
|
|
flags |= DK_CXLFLASH_CONTEXT_SQ_CMD_MODE;
|
|
|
|
recover->hdr.return_flags = flags;
|
|
recover->context_id = ctxi->ctxid;
|
|
recover->adap_fd = new_adap_fd;
|
|
recover->mmio_size = sizeof(afu->afu_map->hosts[0].harea);
|
|
goto out;
|
|
}
|
|
|
|
/* Test if in error state */
|
|
reg = readq_be(&hwq->ctrl_map->mbox_r);
|
|
if (reg == -1) {
|
|
dev_dbg(dev, "%s: MMIO fail, wait for recovery.\n", __func__);
|
|
|
|
/*
|
|
* Before checking the state, put back the context obtained with
|
|
* get_context() as it is no longer needed and sleep for a short
|
|
* period of time (see prolog notes).
|
|
*/
|
|
put_context(ctxi);
|
|
ctxi = NULL;
|
|
ssleep(1);
|
|
rc = check_state(cfg);
|
|
if (unlikely(rc))
|
|
goto out;
|
|
goto retry;
|
|
}
|
|
|
|
dev_dbg(dev, "%s: MMIO working, no recovery required\n", __func__);
|
|
out:
|
|
if (likely(ctxi))
|
|
put_context(ctxi);
|
|
mutex_unlock(mutex);
|
|
atomic_dec_if_positive(&cfg->recovery_threads);
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* process_sense() - evaluates and processes sense data
|
|
* @sdev: SCSI device associated with LUN.
|
|
* @verify: Verify ioctl data structure.
|
|
*
|
|
* Return: 0 on success, -errno on failure
|
|
*/
|
|
static int process_sense(struct scsi_device *sdev,
|
|
struct dk_cxlflash_verify *verify)
|
|
{
|
|
struct cxlflash_cfg *cfg = shost_priv(sdev->host);
|
|
struct device *dev = &cfg->dev->dev;
|
|
struct llun_info *lli = sdev->hostdata;
|
|
struct glun_info *gli = lli->parent;
|
|
u64 prev_lba = gli->max_lba;
|
|
struct scsi_sense_hdr sshdr = { 0 };
|
|
int rc = 0;
|
|
|
|
rc = scsi_normalize_sense((const u8 *)&verify->sense_data,
|
|
DK_CXLFLASH_VERIFY_SENSE_LEN, &sshdr);
|
|
if (!rc) {
|
|
dev_err(dev, "%s: Failed to normalize sense data\n", __func__);
|
|
rc = -EINVAL;
|
|
goto out;
|
|
}
|
|
|
|
switch (sshdr.sense_key) {
|
|
case NO_SENSE:
|
|
case RECOVERED_ERROR:
|
|
/* fall through */
|
|
case NOT_READY:
|
|
break;
|
|
case UNIT_ATTENTION:
|
|
switch (sshdr.asc) {
|
|
case 0x29: /* Power on Reset or Device Reset */
|
|
/* fall through */
|
|
case 0x2A: /* Device settings/capacity changed */
|
|
rc = read_cap16(sdev, lli);
|
|
if (rc) {
|
|
rc = -ENODEV;
|
|
break;
|
|
}
|
|
if (prev_lba != gli->max_lba)
|
|
dev_dbg(dev, "%s: Capacity changed old=%lld "
|
|
"new=%lld\n", __func__, prev_lba,
|
|
gli->max_lba);
|
|
break;
|
|
case 0x3F: /* Report LUNs changed, Rescan. */
|
|
scsi_scan_host(cfg->host);
|
|
break;
|
|
default:
|
|
rc = -EIO;
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
rc = -EIO;
|
|
break;
|
|
}
|
|
out:
|
|
dev_dbg(dev, "%s: sense_key %x asc %x ascq %x rc %d\n", __func__,
|
|
sshdr.sense_key, sshdr.asc, sshdr.ascq, rc);
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* cxlflash_disk_verify() - verifies a LUN is the same and handle size changes
|
|
* @sdev: SCSI device associated with LUN.
|
|
* @verify: Verify ioctl data structure.
|
|
*
|
|
* Return: 0 on success, -errno on failure
|
|
*/
|
|
static int cxlflash_disk_verify(struct scsi_device *sdev,
|
|
struct dk_cxlflash_verify *verify)
|
|
{
|
|
int rc = 0;
|
|
struct ctx_info *ctxi = NULL;
|
|
struct cxlflash_cfg *cfg = shost_priv(sdev->host);
|
|
struct device *dev = &cfg->dev->dev;
|
|
struct llun_info *lli = sdev->hostdata;
|
|
struct glun_info *gli = lli->parent;
|
|
struct sisl_rht_entry *rhte = NULL;
|
|
res_hndl_t rhndl = verify->rsrc_handle;
|
|
u64 ctxid = DECODE_CTXID(verify->context_id),
|
|
rctxid = verify->context_id;
|
|
u64 last_lba = 0;
|
|
|
|
dev_dbg(dev, "%s: ctxid=%llu rhndl=%016llx, hint=%016llx, "
|
|
"flags=%016llx\n", __func__, ctxid, verify->rsrc_handle,
|
|
verify->hint, verify->hdr.flags);
|
|
|
|
ctxi = get_context(cfg, rctxid, lli, 0);
|
|
if (unlikely(!ctxi)) {
|
|
dev_dbg(dev, "%s: Bad context ctxid=%llu\n", __func__, ctxid);
|
|
rc = -EINVAL;
|
|
goto out;
|
|
}
|
|
|
|
rhte = get_rhte(ctxi, rhndl, lli);
|
|
if (unlikely(!rhte)) {
|
|
dev_dbg(dev, "%s: Bad resource handle rhndl=%d\n",
|
|
__func__, rhndl);
|
|
rc = -EINVAL;
|
|
goto out;
|
|
}
|
|
|
|
/*
|
|
* Look at the hint/sense to see if it requires us to redrive
|
|
* inquiry (i.e. the Unit attention is due to the WWN changing).
|
|
*/
|
|
if (verify->hint & DK_CXLFLASH_VERIFY_HINT_SENSE) {
|
|
/* Can't hold mutex across process_sense/read_cap16,
|
|
* since we could have an intervening EEH event.
|
|
*/
|
|
ctxi->unavail = true;
|
|
mutex_unlock(&ctxi->mutex);
|
|
rc = process_sense(sdev, verify);
|
|
if (unlikely(rc)) {
|
|
dev_err(dev, "%s: Failed to validate sense data (%d)\n",
|
|
__func__, rc);
|
|
mutex_lock(&ctxi->mutex);
|
|
ctxi->unavail = false;
|
|
goto out;
|
|
}
|
|
mutex_lock(&ctxi->mutex);
|
|
ctxi->unavail = false;
|
|
}
|
|
|
|
switch (gli->mode) {
|
|
case MODE_PHYSICAL:
|
|
last_lba = gli->max_lba;
|
|
break;
|
|
case MODE_VIRTUAL:
|
|
/* Cast lxt_cnt to u64 for multiply to be treated as 64bit op */
|
|
last_lba = ((u64)rhte->lxt_cnt * MC_CHUNK_SIZE * gli->blk_len);
|
|
last_lba /= CXLFLASH_BLOCK_SIZE;
|
|
last_lba--;
|
|
break;
|
|
default:
|
|
WARN(1, "Unsupported LUN mode!");
|
|
}
|
|
|
|
verify->last_lba = last_lba;
|
|
|
|
out:
|
|
if (likely(ctxi))
|
|
put_context(ctxi);
|
|
dev_dbg(dev, "%s: returning rc=%d llba=%llx\n",
|
|
__func__, rc, verify->last_lba);
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* decode_ioctl() - translates an encoded ioctl to an easily identifiable string
|
|
* @cmd: The ioctl command to decode.
|
|
*
|
|
* Return: A string identifying the decoded ioctl.
|
|
*/
|
|
static char *decode_ioctl(int cmd)
|
|
{
|
|
switch (cmd) {
|
|
case DK_CXLFLASH_ATTACH:
|
|
return __stringify_1(DK_CXLFLASH_ATTACH);
|
|
case DK_CXLFLASH_USER_DIRECT:
|
|
return __stringify_1(DK_CXLFLASH_USER_DIRECT);
|
|
case DK_CXLFLASH_USER_VIRTUAL:
|
|
return __stringify_1(DK_CXLFLASH_USER_VIRTUAL);
|
|
case DK_CXLFLASH_VLUN_RESIZE:
|
|
return __stringify_1(DK_CXLFLASH_VLUN_RESIZE);
|
|
case DK_CXLFLASH_RELEASE:
|
|
return __stringify_1(DK_CXLFLASH_RELEASE);
|
|
case DK_CXLFLASH_DETACH:
|
|
return __stringify_1(DK_CXLFLASH_DETACH);
|
|
case DK_CXLFLASH_VERIFY:
|
|
return __stringify_1(DK_CXLFLASH_VERIFY);
|
|
case DK_CXLFLASH_VLUN_CLONE:
|
|
return __stringify_1(DK_CXLFLASH_VLUN_CLONE);
|
|
case DK_CXLFLASH_RECOVER_AFU:
|
|
return __stringify_1(DK_CXLFLASH_RECOVER_AFU);
|
|
case DK_CXLFLASH_MANAGE_LUN:
|
|
return __stringify_1(DK_CXLFLASH_MANAGE_LUN);
|
|
}
|
|
|
|
return "UNKNOWN";
|
|
}
|
|
|
|
/**
|
|
* cxlflash_disk_direct_open() - opens a direct (physical) disk
|
|
* @sdev: SCSI device associated with LUN.
|
|
* @arg: UDirect ioctl data structure.
|
|
*
|
|
* On successful return, the user is informed of the resource handle
|
|
* to be used to identify the direct lun and the size (in blocks) of
|
|
* the direct lun in last LBA format.
|
|
*
|
|
* Return: 0 on success, -errno on failure
|
|
*/
|
|
static int cxlflash_disk_direct_open(struct scsi_device *sdev, void *arg)
|
|
{
|
|
struct cxlflash_cfg *cfg = shost_priv(sdev->host);
|
|
struct device *dev = &cfg->dev->dev;
|
|
struct afu *afu = cfg->afu;
|
|
struct llun_info *lli = sdev->hostdata;
|
|
struct glun_info *gli = lli->parent;
|
|
|
|
struct dk_cxlflash_udirect *pphys = (struct dk_cxlflash_udirect *)arg;
|
|
|
|
u64 ctxid = DECODE_CTXID(pphys->context_id),
|
|
rctxid = pphys->context_id;
|
|
u64 lun_size = 0;
|
|
u64 last_lba = 0;
|
|
u64 rsrc_handle = -1;
|
|
u32 port = CHAN2PORTMASK(sdev->channel);
|
|
|
|
int rc = 0;
|
|
|
|
struct ctx_info *ctxi = NULL;
|
|
struct sisl_rht_entry *rhte = NULL;
|
|
|
|
dev_dbg(dev, "%s: ctxid=%llu ls=%llu\n", __func__, ctxid, lun_size);
|
|
|
|
rc = cxlflash_lun_attach(gli, MODE_PHYSICAL, false);
|
|
if (unlikely(rc)) {
|
|
dev_dbg(dev, "%s: Failed attach to LUN (PHYSICAL)\n", __func__);
|
|
goto out;
|
|
}
|
|
|
|
ctxi = get_context(cfg, rctxid, lli, 0);
|
|
if (unlikely(!ctxi)) {
|
|
dev_dbg(dev, "%s: Bad context ctxid=%llu\n", __func__, ctxid);
|
|
rc = -EINVAL;
|
|
goto err1;
|
|
}
|
|
|
|
rhte = rhte_checkout(ctxi, lli);
|
|
if (unlikely(!rhte)) {
|
|
dev_dbg(dev, "%s: Too many opens ctxid=%lld\n",
|
|
__func__, ctxid);
|
|
rc = -EMFILE; /* too many opens */
|
|
goto err1;
|
|
}
|
|
|
|
rsrc_handle = (rhte - ctxi->rht_start);
|
|
|
|
rht_format1(rhte, lli->lun_id[sdev->channel], ctxi->rht_perms, port);
|
|
cxlflash_afu_sync(afu, ctxid, rsrc_handle, AFU_LW_SYNC);
|
|
|
|
last_lba = gli->max_lba;
|
|
pphys->hdr.return_flags = 0;
|
|
pphys->last_lba = last_lba;
|
|
pphys->rsrc_handle = rsrc_handle;
|
|
|
|
out:
|
|
if (likely(ctxi))
|
|
put_context(ctxi);
|
|
dev_dbg(dev, "%s: returning handle=%llu rc=%d llba=%llu\n",
|
|
__func__, rsrc_handle, rc, last_lba);
|
|
return rc;
|
|
|
|
err1:
|
|
cxlflash_lun_detach(gli);
|
|
goto out;
|
|
}
|
|
|
|
/**
|
|
* ioctl_common() - common IOCTL handler for driver
|
|
* @sdev: SCSI device associated with LUN.
|
|
* @cmd: IOCTL command.
|
|
*
|
|
* Handles common fencing operations that are valid for multiple ioctls. Always
|
|
* allow through ioctls that are cleanup oriented in nature, even when operating
|
|
* in a failed/terminating state.
|
|
*
|
|
* Return: 0 on success, -errno on failure
|
|
*/
|
|
static int ioctl_common(struct scsi_device *sdev, int cmd)
|
|
{
|
|
struct cxlflash_cfg *cfg = shost_priv(sdev->host);
|
|
struct device *dev = &cfg->dev->dev;
|
|
struct llun_info *lli = sdev->hostdata;
|
|
int rc = 0;
|
|
|
|
if (unlikely(!lli)) {
|
|
dev_dbg(dev, "%s: Unknown LUN\n", __func__);
|
|
rc = -EINVAL;
|
|
goto out;
|
|
}
|
|
|
|
rc = check_state(cfg);
|
|
if (unlikely(rc) && (cfg->state == STATE_FAILTERM)) {
|
|
switch (cmd) {
|
|
case DK_CXLFLASH_VLUN_RESIZE:
|
|
case DK_CXLFLASH_RELEASE:
|
|
case DK_CXLFLASH_DETACH:
|
|
dev_dbg(dev, "%s: Command override rc=%d\n",
|
|
__func__, rc);
|
|
rc = 0;
|
|
break;
|
|
}
|
|
}
|
|
out:
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* cxlflash_ioctl() - IOCTL handler for driver
|
|
* @sdev: SCSI device associated with LUN.
|
|
* @cmd: IOCTL command.
|
|
* @arg: Userspace ioctl data structure.
|
|
*
|
|
* A read/write semaphore is used to implement a 'drain' of currently
|
|
* running ioctls. The read semaphore is taken at the beginning of each
|
|
* ioctl thread and released upon concluding execution. Additionally the
|
|
* semaphore should be released and then reacquired in any ioctl execution
|
|
* path which will wait for an event to occur that is outside the scope of
|
|
* the ioctl (i.e. an adapter reset). To drain the ioctls currently running,
|
|
* a thread simply needs to acquire the write semaphore.
|
|
*
|
|
* Return: 0 on success, -errno on failure
|
|
*/
|
|
int cxlflash_ioctl(struct scsi_device *sdev, int cmd, void __user *arg)
|
|
{
|
|
typedef int (*sioctl) (struct scsi_device *, void *);
|
|
|
|
struct cxlflash_cfg *cfg = shost_priv(sdev->host);
|
|
struct device *dev = &cfg->dev->dev;
|
|
struct afu *afu = cfg->afu;
|
|
struct dk_cxlflash_hdr *hdr;
|
|
char buf[sizeof(union cxlflash_ioctls)];
|
|
size_t size = 0;
|
|
bool known_ioctl = false;
|
|
int idx;
|
|
int rc = 0;
|
|
struct Scsi_Host *shost = sdev->host;
|
|
sioctl do_ioctl = NULL;
|
|
|
|
static const struct {
|
|
size_t size;
|
|
sioctl ioctl;
|
|
} ioctl_tbl[] = { /* NOTE: order matters here */
|
|
{sizeof(struct dk_cxlflash_attach), (sioctl)cxlflash_disk_attach},
|
|
{sizeof(struct dk_cxlflash_udirect), cxlflash_disk_direct_open},
|
|
{sizeof(struct dk_cxlflash_release), (sioctl)cxlflash_disk_release},
|
|
{sizeof(struct dk_cxlflash_detach), (sioctl)cxlflash_disk_detach},
|
|
{sizeof(struct dk_cxlflash_verify), (sioctl)cxlflash_disk_verify},
|
|
{sizeof(struct dk_cxlflash_recover_afu), (sioctl)cxlflash_afu_recover},
|
|
{sizeof(struct dk_cxlflash_manage_lun), (sioctl)cxlflash_manage_lun},
|
|
{sizeof(struct dk_cxlflash_uvirtual), cxlflash_disk_virtual_open},
|
|
{sizeof(struct dk_cxlflash_resize), (sioctl)cxlflash_vlun_resize},
|
|
{sizeof(struct dk_cxlflash_clone), (sioctl)cxlflash_disk_clone},
|
|
};
|
|
|
|
/* Hold read semaphore so we can drain if needed */
|
|
down_read(&cfg->ioctl_rwsem);
|
|
|
|
/* Restrict command set to physical support only for internal LUN */
|
|
if (afu->internal_lun)
|
|
switch (cmd) {
|
|
case DK_CXLFLASH_RELEASE:
|
|
case DK_CXLFLASH_USER_VIRTUAL:
|
|
case DK_CXLFLASH_VLUN_RESIZE:
|
|
case DK_CXLFLASH_VLUN_CLONE:
|
|
dev_dbg(dev, "%s: %s not supported for lun_mode=%d\n",
|
|
__func__, decode_ioctl(cmd), afu->internal_lun);
|
|
rc = -EINVAL;
|
|
goto cxlflash_ioctl_exit;
|
|
}
|
|
|
|
switch (cmd) {
|
|
case DK_CXLFLASH_ATTACH:
|
|
case DK_CXLFLASH_USER_DIRECT:
|
|
case DK_CXLFLASH_RELEASE:
|
|
case DK_CXLFLASH_DETACH:
|
|
case DK_CXLFLASH_VERIFY:
|
|
case DK_CXLFLASH_RECOVER_AFU:
|
|
case DK_CXLFLASH_USER_VIRTUAL:
|
|
case DK_CXLFLASH_VLUN_RESIZE:
|
|
case DK_CXLFLASH_VLUN_CLONE:
|
|
dev_dbg(dev, "%s: %s (%08X) on dev(%d/%d/%d/%llu)\n",
|
|
__func__, decode_ioctl(cmd), cmd, shost->host_no,
|
|
sdev->channel, sdev->id, sdev->lun);
|
|
rc = ioctl_common(sdev, cmd);
|
|
if (unlikely(rc))
|
|
goto cxlflash_ioctl_exit;
|
|
|
|
/* fall through */
|
|
|
|
case DK_CXLFLASH_MANAGE_LUN:
|
|
known_ioctl = true;
|
|
idx = _IOC_NR(cmd) - _IOC_NR(DK_CXLFLASH_ATTACH);
|
|
size = ioctl_tbl[idx].size;
|
|
do_ioctl = ioctl_tbl[idx].ioctl;
|
|
|
|
if (likely(do_ioctl))
|
|
break;
|
|
|
|
/* fall through */
|
|
default:
|
|
rc = -EINVAL;
|
|
goto cxlflash_ioctl_exit;
|
|
}
|
|
|
|
if (unlikely(copy_from_user(&buf, arg, size))) {
|
|
dev_err(dev, "%s: copy_from_user() fail "
|
|
"size=%lu cmd=%d (%s) arg=%p\n",
|
|
__func__, size, cmd, decode_ioctl(cmd), arg);
|
|
rc = -EFAULT;
|
|
goto cxlflash_ioctl_exit;
|
|
}
|
|
|
|
hdr = (struct dk_cxlflash_hdr *)&buf;
|
|
if (hdr->version != DK_CXLFLASH_VERSION_0) {
|
|
dev_dbg(dev, "%s: Version %u not supported for %s\n",
|
|
__func__, hdr->version, decode_ioctl(cmd));
|
|
rc = -EINVAL;
|
|
goto cxlflash_ioctl_exit;
|
|
}
|
|
|
|
if (hdr->rsvd[0] || hdr->rsvd[1] || hdr->rsvd[2] || hdr->return_flags) {
|
|
dev_dbg(dev, "%s: Reserved/rflags populated\n", __func__);
|
|
rc = -EINVAL;
|
|
goto cxlflash_ioctl_exit;
|
|
}
|
|
|
|
rc = do_ioctl(sdev, (void *)&buf);
|
|
if (likely(!rc))
|
|
if (unlikely(copy_to_user(arg, &buf, size))) {
|
|
dev_err(dev, "%s: copy_to_user() fail "
|
|
"size=%lu cmd=%d (%s) arg=%p\n",
|
|
__func__, size, cmd, decode_ioctl(cmd), arg);
|
|
rc = -EFAULT;
|
|
}
|
|
|
|
/* fall through to exit */
|
|
|
|
cxlflash_ioctl_exit:
|
|
up_read(&cfg->ioctl_rwsem);
|
|
if (unlikely(rc && known_ioctl))
|
|
dev_err(dev, "%s: ioctl %s (%08X) on dev(%d/%d/%d/%llu) "
|
|
"returned rc %d\n", __func__,
|
|
decode_ioctl(cmd), cmd, shost->host_no,
|
|
sdev->channel, sdev->id, sdev->lun, rc);
|
|
else
|
|
dev_dbg(dev, "%s: ioctl %s (%08X) on dev(%d/%d/%d/%llu) "
|
|
"returned rc %d\n", __func__, decode_ioctl(cmd),
|
|
cmd, shost->host_no, sdev->channel, sdev->id,
|
|
sdev->lun, rc);
|
|
return rc;
|
|
}
|