mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-06 02:24:14 +08:00
0aa14887c6
As staging to support FC-related updates to the SISlite specification, introduce helper routines to obtain references to FC resources that exist within the global map. This will allow changes to the underlying global map structure without impacting existing code paths. Signed-off-by: Matthew R. Ochs <mrochs@linux.vnet.ibm.com> Signed-off-by: Uma Krishnan <ukrishn@linux.vnet.ibm.com> Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
1305 lines
36 KiB
C
1305 lines
36 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/syscalls.h>
|
|
#include <misc/cxl.h>
|
|
#include <asm/unaligned.h>
|
|
#include <asm/bitsperlong.h>
|
|
|
|
#include <scsi/scsi_cmnd.h>
|
|
#include <scsi/scsi_host.h>
|
|
#include <uapi/scsi/cxlflash_ioctl.h>
|
|
|
|
#include "sislite.h"
|
|
#include "common.h"
|
|
#include "vlun.h"
|
|
#include "superpipe.h"
|
|
|
|
/**
|
|
* marshal_virt_to_resize() - translate uvirtual to resize structure
|
|
* @virt: Source structure from which to translate/copy.
|
|
* @resize: Destination structure for the translate/copy.
|
|
*/
|
|
static void marshal_virt_to_resize(struct dk_cxlflash_uvirtual *virt,
|
|
struct dk_cxlflash_resize *resize)
|
|
{
|
|
resize->hdr = virt->hdr;
|
|
resize->context_id = virt->context_id;
|
|
resize->rsrc_handle = virt->rsrc_handle;
|
|
resize->req_size = virt->lun_size;
|
|
resize->last_lba = virt->last_lba;
|
|
}
|
|
|
|
/**
|
|
* marshal_clone_to_rele() - translate clone to release structure
|
|
* @clone: Source structure from which to translate/copy.
|
|
* @rele: Destination structure for the translate/copy.
|
|
*/
|
|
static void marshal_clone_to_rele(struct dk_cxlflash_clone *clone,
|
|
struct dk_cxlflash_release *release)
|
|
{
|
|
release->hdr = clone->hdr;
|
|
release->context_id = clone->context_id_dst;
|
|
}
|
|
|
|
/**
|
|
* ba_init() - initializes a block allocator
|
|
* @ba_lun: Block allocator to initialize.
|
|
*
|
|
* Return: 0 on success, -errno on failure
|
|
*/
|
|
static int ba_init(struct ba_lun *ba_lun)
|
|
{
|
|
struct ba_lun_info *bali = NULL;
|
|
int lun_size_au = 0, i = 0;
|
|
int last_word_underflow = 0;
|
|
u64 *lam;
|
|
|
|
pr_debug("%s: Initializing LUN: lun_id=%016llx "
|
|
"ba_lun->lsize=%lx ba_lun->au_size=%lX\n",
|
|
__func__, ba_lun->lun_id, ba_lun->lsize, ba_lun->au_size);
|
|
|
|
/* Calculate bit map size */
|
|
lun_size_au = ba_lun->lsize / ba_lun->au_size;
|
|
if (lun_size_au == 0) {
|
|
pr_debug("%s: Requested LUN size of 0!\n", __func__);
|
|
return -EINVAL;
|
|
}
|
|
|
|
/* Allocate lun information container */
|
|
bali = kzalloc(sizeof(struct ba_lun_info), GFP_KERNEL);
|
|
if (unlikely(!bali)) {
|
|
pr_err("%s: Failed to allocate lun_info lun_id=%016llx\n",
|
|
__func__, ba_lun->lun_id);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
bali->total_aus = lun_size_au;
|
|
bali->lun_bmap_size = lun_size_au / BITS_PER_LONG;
|
|
|
|
if (lun_size_au % BITS_PER_LONG)
|
|
bali->lun_bmap_size++;
|
|
|
|
/* Allocate bitmap space */
|
|
bali->lun_alloc_map = kzalloc((bali->lun_bmap_size * sizeof(u64)),
|
|
GFP_KERNEL);
|
|
if (unlikely(!bali->lun_alloc_map)) {
|
|
pr_err("%s: Failed to allocate lun allocation map: "
|
|
"lun_id=%016llx\n", __func__, ba_lun->lun_id);
|
|
kfree(bali);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
/* Initialize the bit map size and set all bits to '1' */
|
|
bali->free_aun_cnt = lun_size_au;
|
|
|
|
for (i = 0; i < bali->lun_bmap_size; i++)
|
|
bali->lun_alloc_map[i] = 0xFFFFFFFFFFFFFFFFULL;
|
|
|
|
/* If the last word not fully utilized, mark extra bits as allocated */
|
|
last_word_underflow = (bali->lun_bmap_size * BITS_PER_LONG);
|
|
last_word_underflow -= bali->free_aun_cnt;
|
|
if (last_word_underflow > 0) {
|
|
lam = &bali->lun_alloc_map[bali->lun_bmap_size - 1];
|
|
for (i = (HIBIT - last_word_underflow + 1);
|
|
i < BITS_PER_LONG;
|
|
i++)
|
|
clear_bit(i, (ulong *)lam);
|
|
}
|
|
|
|
/* Initialize high elevator index, low/curr already at 0 from kzalloc */
|
|
bali->free_high_idx = bali->lun_bmap_size;
|
|
|
|
/* Allocate clone map */
|
|
bali->aun_clone_map = kzalloc((bali->total_aus * sizeof(u8)),
|
|
GFP_KERNEL);
|
|
if (unlikely(!bali->aun_clone_map)) {
|
|
pr_err("%s: Failed to allocate clone map: lun_id=%016llx\n",
|
|
__func__, ba_lun->lun_id);
|
|
kfree(bali->lun_alloc_map);
|
|
kfree(bali);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
/* Pass the allocated LUN info as a handle to the user */
|
|
ba_lun->ba_lun_handle = bali;
|
|
|
|
pr_debug("%s: Successfully initialized the LUN: "
|
|
"lun_id=%016llx bitmap size=%x, free_aun_cnt=%llx\n",
|
|
__func__, ba_lun->lun_id, bali->lun_bmap_size,
|
|
bali->free_aun_cnt);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* find_free_range() - locates a free bit within the block allocator
|
|
* @low: First word in block allocator to start search.
|
|
* @high: Last word in block allocator to search.
|
|
* @bali: LUN information structure owning the block allocator to search.
|
|
* @bit_word: Passes back the word in the block allocator owning the free bit.
|
|
*
|
|
* Return: The bit position within the passed back word, -1 on failure
|
|
*/
|
|
static int find_free_range(u32 low,
|
|
u32 high,
|
|
struct ba_lun_info *bali, int *bit_word)
|
|
{
|
|
int i;
|
|
u64 bit_pos = -1;
|
|
ulong *lam, num_bits;
|
|
|
|
for (i = low; i < high; i++)
|
|
if (bali->lun_alloc_map[i] != 0) {
|
|
lam = (ulong *)&bali->lun_alloc_map[i];
|
|
num_bits = (sizeof(*lam) * BITS_PER_BYTE);
|
|
bit_pos = find_first_bit(lam, num_bits);
|
|
|
|
pr_devel("%s: Found free bit %llu in LUN "
|
|
"map entry %016llx at bitmap index = %d\n",
|
|
__func__, bit_pos, bali->lun_alloc_map[i], i);
|
|
|
|
*bit_word = i;
|
|
bali->free_aun_cnt--;
|
|
clear_bit(bit_pos, lam);
|
|
break;
|
|
}
|
|
|
|
return bit_pos;
|
|
}
|
|
|
|
/**
|
|
* ba_alloc() - allocates a block from the block allocator
|
|
* @ba_lun: Block allocator from which to allocate a block.
|
|
*
|
|
* Return: The allocated block, -1 on failure
|
|
*/
|
|
static u64 ba_alloc(struct ba_lun *ba_lun)
|
|
{
|
|
u64 bit_pos = -1;
|
|
int bit_word = 0;
|
|
struct ba_lun_info *bali = NULL;
|
|
|
|
bali = ba_lun->ba_lun_handle;
|
|
|
|
pr_debug("%s: Received block allocation request: "
|
|
"lun_id=%016llx free_aun_cnt=%llx\n",
|
|
__func__, ba_lun->lun_id, bali->free_aun_cnt);
|
|
|
|
if (bali->free_aun_cnt == 0) {
|
|
pr_debug("%s: No space left on LUN: lun_id=%016llx\n",
|
|
__func__, ba_lun->lun_id);
|
|
return -1ULL;
|
|
}
|
|
|
|
/* Search to find a free entry, curr->high then low->curr */
|
|
bit_pos = find_free_range(bali->free_curr_idx,
|
|
bali->free_high_idx, bali, &bit_word);
|
|
if (bit_pos == -1) {
|
|
bit_pos = find_free_range(bali->free_low_idx,
|
|
bali->free_curr_idx,
|
|
bali, &bit_word);
|
|
if (bit_pos == -1) {
|
|
pr_debug("%s: Could not find an allocation unit on LUN:"
|
|
" lun_id=%016llx\n", __func__, ba_lun->lun_id);
|
|
return -1ULL;
|
|
}
|
|
}
|
|
|
|
/* Update the free_curr_idx */
|
|
if (bit_pos == HIBIT)
|
|
bali->free_curr_idx = bit_word + 1;
|
|
else
|
|
bali->free_curr_idx = bit_word;
|
|
|
|
pr_debug("%s: Allocating AU number=%llx lun_id=%016llx "
|
|
"free_aun_cnt=%llx\n", __func__,
|
|
((bit_word * BITS_PER_LONG) + bit_pos), ba_lun->lun_id,
|
|
bali->free_aun_cnt);
|
|
|
|
return (u64) ((bit_word * BITS_PER_LONG) + bit_pos);
|
|
}
|
|
|
|
/**
|
|
* validate_alloc() - validates the specified block has been allocated
|
|
* @ba_lun_info: LUN info owning the block allocator.
|
|
* @aun: Block to validate.
|
|
*
|
|
* Return: 0 on success, -1 on failure
|
|
*/
|
|
static int validate_alloc(struct ba_lun_info *bali, u64 aun)
|
|
{
|
|
int idx = 0, bit_pos = 0;
|
|
|
|
idx = aun / BITS_PER_LONG;
|
|
bit_pos = aun % BITS_PER_LONG;
|
|
|
|
if (test_bit(bit_pos, (ulong *)&bali->lun_alloc_map[idx]))
|
|
return -1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ba_free() - frees a block from the block allocator
|
|
* @ba_lun: Block allocator from which to allocate a block.
|
|
* @to_free: Block to free.
|
|
*
|
|
* Return: 0 on success, -1 on failure
|
|
*/
|
|
static int ba_free(struct ba_lun *ba_lun, u64 to_free)
|
|
{
|
|
int idx = 0, bit_pos = 0;
|
|
struct ba_lun_info *bali = NULL;
|
|
|
|
bali = ba_lun->ba_lun_handle;
|
|
|
|
if (validate_alloc(bali, to_free)) {
|
|
pr_debug("%s: AUN %llx is not allocated on lun_id=%016llx\n",
|
|
__func__, to_free, ba_lun->lun_id);
|
|
return -1;
|
|
}
|
|
|
|
pr_debug("%s: Received a request to free AU=%llx lun_id=%016llx "
|
|
"free_aun_cnt=%llx\n", __func__, to_free, ba_lun->lun_id,
|
|
bali->free_aun_cnt);
|
|
|
|
if (bali->aun_clone_map[to_free] > 0) {
|
|
pr_debug("%s: AUN %llx lun_id=%016llx cloned. Clone count=%x\n",
|
|
__func__, to_free, ba_lun->lun_id,
|
|
bali->aun_clone_map[to_free]);
|
|
bali->aun_clone_map[to_free]--;
|
|
return 0;
|
|
}
|
|
|
|
idx = to_free / BITS_PER_LONG;
|
|
bit_pos = to_free % BITS_PER_LONG;
|
|
|
|
set_bit(bit_pos, (ulong *)&bali->lun_alloc_map[idx]);
|
|
bali->free_aun_cnt++;
|
|
|
|
if (idx < bali->free_low_idx)
|
|
bali->free_low_idx = idx;
|
|
else if (idx > bali->free_high_idx)
|
|
bali->free_high_idx = idx;
|
|
|
|
pr_debug("%s: Successfully freed AU bit_pos=%x bit map index=%x "
|
|
"lun_id=%016llx free_aun_cnt=%llx\n", __func__, bit_pos, idx,
|
|
ba_lun->lun_id, bali->free_aun_cnt);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ba_clone() - Clone a chunk of the block allocation table
|
|
* @ba_lun: Block allocator from which to allocate a block.
|
|
* @to_free: Block to free.
|
|
*
|
|
* Return: 0 on success, -1 on failure
|
|
*/
|
|
static int ba_clone(struct ba_lun *ba_lun, u64 to_clone)
|
|
{
|
|
struct ba_lun_info *bali = ba_lun->ba_lun_handle;
|
|
|
|
if (validate_alloc(bali, to_clone)) {
|
|
pr_debug("%s: AUN=%llx not allocated on lun_id=%016llx\n",
|
|
__func__, to_clone, ba_lun->lun_id);
|
|
return -1;
|
|
}
|
|
|
|
pr_debug("%s: Received a request to clone AUN %llx on lun_id=%016llx\n",
|
|
__func__, to_clone, ba_lun->lun_id);
|
|
|
|
if (bali->aun_clone_map[to_clone] == MAX_AUN_CLONE_CNT) {
|
|
pr_debug("%s: AUN %llx on lun_id=%016llx hit max clones already\n",
|
|
__func__, to_clone, ba_lun->lun_id);
|
|
return -1;
|
|
}
|
|
|
|
bali->aun_clone_map[to_clone]++;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ba_space() - returns the amount of free space left in the block allocator
|
|
* @ba_lun: Block allocator.
|
|
*
|
|
* Return: Amount of free space in block allocator
|
|
*/
|
|
static u64 ba_space(struct ba_lun *ba_lun)
|
|
{
|
|
struct ba_lun_info *bali = ba_lun->ba_lun_handle;
|
|
|
|
return bali->free_aun_cnt;
|
|
}
|
|
|
|
/**
|
|
* cxlflash_ba_terminate() - frees resources associated with the block allocator
|
|
* @ba_lun: Block allocator.
|
|
*
|
|
* Safe to call in a partially allocated state.
|
|
*/
|
|
void cxlflash_ba_terminate(struct ba_lun *ba_lun)
|
|
{
|
|
struct ba_lun_info *bali = ba_lun->ba_lun_handle;
|
|
|
|
if (bali) {
|
|
kfree(bali->aun_clone_map);
|
|
kfree(bali->lun_alloc_map);
|
|
kfree(bali);
|
|
ba_lun->ba_lun_handle = NULL;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* init_vlun() - initializes a LUN for virtual use
|
|
* @lun_info: LUN information structure that owns the block allocator.
|
|
*
|
|
* Return: 0 on success, -errno on failure
|
|
*/
|
|
static int init_vlun(struct llun_info *lli)
|
|
{
|
|
int rc = 0;
|
|
struct glun_info *gli = lli->parent;
|
|
struct blka *blka = &gli->blka;
|
|
|
|
memset(blka, 0, sizeof(*blka));
|
|
mutex_init(&blka->mutex);
|
|
|
|
/* LUN IDs are unique per port, save the index instead */
|
|
blka->ba_lun.lun_id = lli->lun_index;
|
|
blka->ba_lun.lsize = gli->max_lba + 1;
|
|
blka->ba_lun.lba_size = gli->blk_len;
|
|
|
|
blka->ba_lun.au_size = MC_CHUNK_SIZE;
|
|
blka->nchunk = blka->ba_lun.lsize / MC_CHUNK_SIZE;
|
|
|
|
rc = ba_init(&blka->ba_lun);
|
|
if (unlikely(rc))
|
|
pr_debug("%s: cannot init block_alloc, rc=%d\n", __func__, rc);
|
|
|
|
pr_debug("%s: returning rc=%d lli=%p\n", __func__, rc, lli);
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* write_same16() - sends a SCSI WRITE_SAME16 (0) command to specified LUN
|
|
* @sdev: SCSI device associated with LUN.
|
|
* @lba: Logical block address to start write same.
|
|
* @nblks: Number of logical blocks to write same.
|
|
*
|
|
* The SCSI WRITE_SAME16 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 write_same16(struct scsi_device *sdev,
|
|
u64 lba,
|
|
u32 nblks)
|
|
{
|
|
u8 *cmd_buf = NULL;
|
|
u8 *scsi_cmd = NULL;
|
|
u8 *sense_buf = NULL;
|
|
int rc = 0;
|
|
int result = 0;
|
|
int ws_limit = SISLITE_MAX_WS_BLOCKS;
|
|
u64 offset = lba;
|
|
int left = nblks;
|
|
u32 to = sdev->request_queue->rq_timeout;
|
|
struct cxlflash_cfg *cfg = shost_priv(sdev->host);
|
|
struct device *dev = &cfg->dev->dev;
|
|
|
|
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;
|
|
}
|
|
|
|
while (left > 0) {
|
|
|
|
scsi_cmd[0] = WRITE_SAME_16;
|
|
put_unaligned_be64(offset, &scsi_cmd[2]);
|
|
put_unaligned_be32(ws_limit < left ? ws_limit : left,
|
|
&scsi_cmd[10]);
|
|
|
|
/* Drop the ioctl read semahpore across lengthy call */
|
|
up_read(&cfg->ioctl_rwsem);
|
|
result = scsi_execute(sdev, scsi_cmd, DMA_TO_DEVICE, cmd_buf,
|
|
CMD_BUFSIZE, sense_buf, NULL, 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 (result) {
|
|
dev_err_ratelimited(dev, "%s: command failed for "
|
|
"offset=%lld result=%08x\n",
|
|
__func__, offset, result);
|
|
rc = -EIO;
|
|
goto out;
|
|
}
|
|
left -= ws_limit;
|
|
offset += ws_limit;
|
|
}
|
|
|
|
out:
|
|
kfree(cmd_buf);
|
|
kfree(scsi_cmd);
|
|
kfree(sense_buf);
|
|
dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* grow_lxt() - expands the translation table associated with the specified RHTE
|
|
* @afu: AFU associated with the host.
|
|
* @sdev: SCSI device associated with LUN.
|
|
* @ctxid: Context ID of context owning the RHTE.
|
|
* @rhndl: Resource handle associated with the RHTE.
|
|
* @rhte: Resource handle entry (RHTE).
|
|
* @new_size: Number of translation entries associated with RHTE.
|
|
*
|
|
* By design, this routine employs a 'best attempt' allocation and will
|
|
* truncate the requested size down if there is not sufficient space in
|
|
* the block allocator to satisfy the request but there does exist some
|
|
* amount of space. The user is made aware of this by returning the size
|
|
* allocated.
|
|
*
|
|
* Return: 0 on success, -errno on failure
|
|
*/
|
|
static int grow_lxt(struct afu *afu,
|
|
struct scsi_device *sdev,
|
|
ctx_hndl_t ctxid,
|
|
res_hndl_t rhndl,
|
|
struct sisl_rht_entry *rhte,
|
|
u64 *new_size)
|
|
{
|
|
struct cxlflash_cfg *cfg = shost_priv(sdev->host);
|
|
struct device *dev = &cfg->dev->dev;
|
|
struct sisl_lxt_entry *lxt = NULL, *lxt_old = NULL;
|
|
struct llun_info *lli = sdev->hostdata;
|
|
struct glun_info *gli = lli->parent;
|
|
struct blka *blka = &gli->blka;
|
|
u32 av_size;
|
|
u32 ngrps, ngrps_old;
|
|
u64 aun; /* chunk# allocated by block allocator */
|
|
u64 delta = *new_size - rhte->lxt_cnt;
|
|
u64 my_new_size;
|
|
int i, rc = 0;
|
|
|
|
/*
|
|
* Check what is available in the block allocator before re-allocating
|
|
* LXT array. This is done up front under the mutex which must not be
|
|
* released until after allocation is complete.
|
|
*/
|
|
mutex_lock(&blka->mutex);
|
|
av_size = ba_space(&blka->ba_lun);
|
|
if (unlikely(av_size <= 0)) {
|
|
dev_dbg(dev, "%s: ba_space error av_size=%d\n",
|
|
__func__, av_size);
|
|
mutex_unlock(&blka->mutex);
|
|
rc = -ENOSPC;
|
|
goto out;
|
|
}
|
|
|
|
if (av_size < delta)
|
|
delta = av_size;
|
|
|
|
lxt_old = rhte->lxt_start;
|
|
ngrps_old = LXT_NUM_GROUPS(rhte->lxt_cnt);
|
|
ngrps = LXT_NUM_GROUPS(rhte->lxt_cnt + delta);
|
|
|
|
if (ngrps != ngrps_old) {
|
|
/* reallocate to fit new size */
|
|
lxt = kzalloc((sizeof(*lxt) * LXT_GROUP_SIZE * ngrps),
|
|
GFP_KERNEL);
|
|
if (unlikely(!lxt)) {
|
|
mutex_unlock(&blka->mutex);
|
|
rc = -ENOMEM;
|
|
goto out;
|
|
}
|
|
|
|
/* copy over all old entries */
|
|
memcpy(lxt, lxt_old, (sizeof(*lxt) * rhte->lxt_cnt));
|
|
} else
|
|
lxt = lxt_old;
|
|
|
|
/* nothing can fail from now on */
|
|
my_new_size = rhte->lxt_cnt + delta;
|
|
|
|
/* add new entries to the end */
|
|
for (i = rhte->lxt_cnt; i < my_new_size; i++) {
|
|
/*
|
|
* Due to the earlier check of available space, ba_alloc
|
|
* cannot fail here. If it did due to internal error,
|
|
* leave a rlba_base of -1u which will likely be a
|
|
* invalid LUN (too large).
|
|
*/
|
|
aun = ba_alloc(&blka->ba_lun);
|
|
if ((aun == -1ULL) || (aun >= blka->nchunk))
|
|
dev_dbg(dev, "%s: ba_alloc error allocated chunk=%llu "
|
|
"max=%llu\n", __func__, aun, blka->nchunk - 1);
|
|
|
|
/* select both ports, use r/w perms from RHT */
|
|
lxt[i].rlba_base = ((aun << MC_CHUNK_SHIFT) |
|
|
(lli->lun_index << LXT_LUNIDX_SHIFT) |
|
|
(RHT_PERM_RW << LXT_PERM_SHIFT |
|
|
lli->port_sel));
|
|
}
|
|
|
|
mutex_unlock(&blka->mutex);
|
|
|
|
/*
|
|
* The following sequence is prescribed in the SISlite spec
|
|
* for syncing up with the AFU when adding LXT entries.
|
|
*/
|
|
dma_wmb(); /* Make LXT updates are visible */
|
|
|
|
rhte->lxt_start = lxt;
|
|
dma_wmb(); /* Make RHT entry's LXT table update visible */
|
|
|
|
rhte->lxt_cnt = my_new_size;
|
|
dma_wmb(); /* Make RHT entry's LXT table size update visible */
|
|
|
|
cxlflash_afu_sync(afu, ctxid, rhndl, AFU_LW_SYNC);
|
|
|
|
/* free old lxt if reallocated */
|
|
if (lxt != lxt_old)
|
|
kfree(lxt_old);
|
|
*new_size = my_new_size;
|
|
out:
|
|
dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* shrink_lxt() - reduces translation table associated with the specified RHTE
|
|
* @afu: AFU associated with the host.
|
|
* @sdev: SCSI device associated with LUN.
|
|
* @rhndl: Resource handle associated with the RHTE.
|
|
* @rhte: Resource handle entry (RHTE).
|
|
* @ctxi: Context owning resources.
|
|
* @new_size: Number of translation entries associated with RHTE.
|
|
*
|
|
* Return: 0 on success, -errno on failure
|
|
*/
|
|
static int shrink_lxt(struct afu *afu,
|
|
struct scsi_device *sdev,
|
|
res_hndl_t rhndl,
|
|
struct sisl_rht_entry *rhte,
|
|
struct ctx_info *ctxi,
|
|
u64 *new_size)
|
|
{
|
|
struct cxlflash_cfg *cfg = shost_priv(sdev->host);
|
|
struct device *dev = &cfg->dev->dev;
|
|
struct sisl_lxt_entry *lxt, *lxt_old;
|
|
struct llun_info *lli = sdev->hostdata;
|
|
struct glun_info *gli = lli->parent;
|
|
struct blka *blka = &gli->blka;
|
|
ctx_hndl_t ctxid = DECODE_CTXID(ctxi->ctxid);
|
|
bool needs_ws = ctxi->rht_needs_ws[rhndl];
|
|
bool needs_sync = !ctxi->err_recovery_active;
|
|
u32 ngrps, ngrps_old;
|
|
u64 aun; /* chunk# allocated by block allocator */
|
|
u64 delta = rhte->lxt_cnt - *new_size;
|
|
u64 my_new_size;
|
|
int i, rc = 0;
|
|
|
|
lxt_old = rhte->lxt_start;
|
|
ngrps_old = LXT_NUM_GROUPS(rhte->lxt_cnt);
|
|
ngrps = LXT_NUM_GROUPS(rhte->lxt_cnt - delta);
|
|
|
|
if (ngrps != ngrps_old) {
|
|
/* Reallocate to fit new size unless new size is 0 */
|
|
if (ngrps) {
|
|
lxt = kzalloc((sizeof(*lxt) * LXT_GROUP_SIZE * ngrps),
|
|
GFP_KERNEL);
|
|
if (unlikely(!lxt)) {
|
|
rc = -ENOMEM;
|
|
goto out;
|
|
}
|
|
|
|
/* Copy over old entries that will remain */
|
|
memcpy(lxt, lxt_old,
|
|
(sizeof(*lxt) * (rhte->lxt_cnt - delta)));
|
|
} else
|
|
lxt = NULL;
|
|
} else
|
|
lxt = lxt_old;
|
|
|
|
/* Nothing can fail from now on */
|
|
my_new_size = rhte->lxt_cnt - delta;
|
|
|
|
/*
|
|
* The following sequence is prescribed in the SISlite spec
|
|
* for syncing up with the AFU when removing LXT entries.
|
|
*/
|
|
rhte->lxt_cnt = my_new_size;
|
|
dma_wmb(); /* Make RHT entry's LXT table size update visible */
|
|
|
|
rhte->lxt_start = lxt;
|
|
dma_wmb(); /* Make RHT entry's LXT table update visible */
|
|
|
|
if (needs_sync)
|
|
cxlflash_afu_sync(afu, ctxid, rhndl, AFU_HW_SYNC);
|
|
|
|
if (needs_ws) {
|
|
/*
|
|
* Mark the context as unavailable, so that we can release
|
|
* the mutex safely.
|
|
*/
|
|
ctxi->unavail = true;
|
|
mutex_unlock(&ctxi->mutex);
|
|
}
|
|
|
|
/* Free LBAs allocated to freed chunks */
|
|
mutex_lock(&blka->mutex);
|
|
for (i = delta - 1; i >= 0; i--) {
|
|
/* Mask the higher 48 bits before shifting, even though
|
|
* it is a noop
|
|
*/
|
|
aun = (lxt_old[my_new_size + i].rlba_base & SISL_ASTATUS_MASK);
|
|
aun = (aun >> MC_CHUNK_SHIFT);
|
|
if (needs_ws)
|
|
write_same16(sdev, aun, MC_CHUNK_SIZE);
|
|
ba_free(&blka->ba_lun, aun);
|
|
}
|
|
mutex_unlock(&blka->mutex);
|
|
|
|
if (needs_ws) {
|
|
/* Make the context visible again */
|
|
mutex_lock(&ctxi->mutex);
|
|
ctxi->unavail = false;
|
|
}
|
|
|
|
/* Free old lxt if reallocated */
|
|
if (lxt != lxt_old)
|
|
kfree(lxt_old);
|
|
*new_size = my_new_size;
|
|
out:
|
|
dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* _cxlflash_vlun_resize() - changes the size of a virtual LUN
|
|
* @sdev: SCSI device associated with LUN owning virtual LUN.
|
|
* @ctxi: Context owning resources.
|
|
* @resize: Resize ioctl data structure.
|
|
*
|
|
* On successful return, the user is informed of the new size (in blocks)
|
|
* of the virtual LUN in last LBA format. When the size of the virtual
|
|
* LUN is zero, the last LBA is reflected as -1. See comment in the
|
|
* prologue for _cxlflash_disk_release() regarding AFU syncs and contexts
|
|
* on the error recovery list.
|
|
*
|
|
* Return: 0 on success, -errno on failure
|
|
*/
|
|
int _cxlflash_vlun_resize(struct scsi_device *sdev,
|
|
struct ctx_info *ctxi,
|
|
struct dk_cxlflash_resize *resize)
|
|
{
|
|
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;
|
|
|
|
res_hndl_t rhndl = resize->rsrc_handle;
|
|
u64 new_size;
|
|
u64 nsectors;
|
|
u64 ctxid = DECODE_CTXID(resize->context_id),
|
|
rctxid = resize->context_id;
|
|
|
|
struct sisl_rht_entry *rhte;
|
|
|
|
int rc = 0;
|
|
|
|
/*
|
|
* The requested size (req_size) is always assumed to be in 4k blocks,
|
|
* so we have to convert it here from 4k to chunk size.
|
|
*/
|
|
nsectors = (resize->req_size * CXLFLASH_BLOCK_SIZE) / gli->blk_len;
|
|
new_size = DIV_ROUND_UP(nsectors, MC_CHUNK_SIZE);
|
|
|
|
dev_dbg(dev, "%s: ctxid=%llu rhndl=%llu req_size=%llu new_size=%llu\n",
|
|
__func__, ctxid, resize->rsrc_handle, resize->req_size,
|
|
new_size);
|
|
|
|
if (unlikely(gli->mode != MODE_VIRTUAL)) {
|
|
dev_dbg(dev, "%s: LUN mode does not support resize mode=%d\n",
|
|
__func__, gli->mode);
|
|
rc = -EINVAL;
|
|
goto out;
|
|
|
|
}
|
|
|
|
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=%u\n",
|
|
__func__, rhndl);
|
|
rc = -EINVAL;
|
|
goto out;
|
|
}
|
|
|
|
if (new_size > rhte->lxt_cnt)
|
|
rc = grow_lxt(afu, sdev, ctxid, rhndl, rhte, &new_size);
|
|
else if (new_size < rhte->lxt_cnt)
|
|
rc = shrink_lxt(afu, sdev, rhndl, rhte, ctxi, &new_size);
|
|
|
|
resize->hdr.return_flags = 0;
|
|
resize->last_lba = (new_size * MC_CHUNK_SIZE * gli->blk_len);
|
|
resize->last_lba /= CXLFLASH_BLOCK_SIZE;
|
|
resize->last_lba--;
|
|
|
|
out:
|
|
if (put_ctx)
|
|
put_context(ctxi);
|
|
dev_dbg(dev, "%s: resized to %llu returning rc=%d\n",
|
|
__func__, resize->last_lba, rc);
|
|
return rc;
|
|
}
|
|
|
|
int cxlflash_vlun_resize(struct scsi_device *sdev,
|
|
struct dk_cxlflash_resize *resize)
|
|
{
|
|
return _cxlflash_vlun_resize(sdev, NULL, resize);
|
|
}
|
|
|
|
/**
|
|
* cxlflash_restore_luntable() - Restore LUN table to prior state
|
|
* @cfg: Internal structure associated with the host.
|
|
*/
|
|
void cxlflash_restore_luntable(struct cxlflash_cfg *cfg)
|
|
{
|
|
struct llun_info *lli, *temp;
|
|
u32 lind;
|
|
int k;
|
|
struct device *dev = &cfg->dev->dev;
|
|
__be64 __iomem *fc_port_luns;
|
|
|
|
mutex_lock(&global.mutex);
|
|
|
|
list_for_each_entry_safe(lli, temp, &cfg->lluns, list) {
|
|
if (!lli->in_table)
|
|
continue;
|
|
|
|
lind = lli->lun_index;
|
|
dev_dbg(dev, "%s: Virtual LUNs on slot %d:\n", __func__, lind);
|
|
|
|
for (k = 0; k < cfg->num_fc_ports; k++)
|
|
if (lli->port_sel & (1 << k)) {
|
|
fc_port_luns = get_fc_port_luns(cfg, k);
|
|
writeq_be(lli->lun_id[k], &fc_port_luns[lind]);
|
|
dev_dbg(dev, "\t%d=%llx\n", k, lli->lun_id[k]);
|
|
}
|
|
}
|
|
|
|
mutex_unlock(&global.mutex);
|
|
}
|
|
|
|
/**
|
|
* get_num_ports() - compute number of ports from port selection mask
|
|
* @psm: Port selection mask.
|
|
*
|
|
* Return: Population count of port selection mask
|
|
*/
|
|
static inline u8 get_num_ports(u32 psm)
|
|
{
|
|
static const u8 bits[16] = { 0, 1, 1, 2, 1, 2, 2, 3,
|
|
1, 2, 2, 3, 2, 3, 3, 4 };
|
|
|
|
return bits[psm & 0xf];
|
|
}
|
|
|
|
/**
|
|
* init_luntable() - write an entry in the LUN table
|
|
* @cfg: Internal structure associated with the host.
|
|
* @lli: Per adapter LUN information structure.
|
|
*
|
|
* On successful return, a LUN table entry is created:
|
|
* - at the top for LUNs visible on multiple ports.
|
|
* - at the bottom for LUNs visible only on one port.
|
|
*
|
|
* Return: 0 on success, -errno on failure
|
|
*/
|
|
static int init_luntable(struct cxlflash_cfg *cfg, struct llun_info *lli)
|
|
{
|
|
u32 chan;
|
|
u32 lind;
|
|
u32 nports;
|
|
int rc = 0;
|
|
int k;
|
|
struct device *dev = &cfg->dev->dev;
|
|
__be64 __iomem *fc_port_luns;
|
|
|
|
mutex_lock(&global.mutex);
|
|
|
|
if (lli->in_table)
|
|
goto out;
|
|
|
|
nports = get_num_ports(lli->port_sel);
|
|
if (nports == 0 || nports > cfg->num_fc_ports) {
|
|
WARN(1, "Unsupported port configuration nports=%u", nports);
|
|
rc = -EIO;
|
|
goto out;
|
|
}
|
|
|
|
if (nports > 1) {
|
|
/*
|
|
* When LUN is visible from multiple ports, we will put
|
|
* it in the top half of the LUN table.
|
|
*/
|
|
for (k = 0; k < cfg->num_fc_ports; k++) {
|
|
if (!(lli->port_sel & (1 << k)))
|
|
continue;
|
|
|
|
if (cfg->promote_lun_index == cfg->last_lun_index[k]) {
|
|
rc = -ENOSPC;
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
lind = lli->lun_index = cfg->promote_lun_index;
|
|
dev_dbg(dev, "%s: Virtual LUNs on slot %d:\n", __func__, lind);
|
|
|
|
for (k = 0; k < cfg->num_fc_ports; k++) {
|
|
if (!(lli->port_sel & (1 << k)))
|
|
continue;
|
|
|
|
fc_port_luns = get_fc_port_luns(cfg, k);
|
|
writeq_be(lli->lun_id[k], &fc_port_luns[lind]);
|
|
dev_dbg(dev, "\t%d=%llx\n", k, lli->lun_id[k]);
|
|
}
|
|
|
|
cfg->promote_lun_index++;
|
|
} else {
|
|
/*
|
|
* When LUN is visible only from one port, we will put
|
|
* it in the bottom half of the LUN table.
|
|
*/
|
|
chan = PORTMASK2CHAN(lli->port_sel);
|
|
if (cfg->promote_lun_index == cfg->last_lun_index[chan]) {
|
|
rc = -ENOSPC;
|
|
goto out;
|
|
}
|
|
|
|
lind = lli->lun_index = cfg->last_lun_index[chan];
|
|
fc_port_luns = get_fc_port_luns(cfg, chan);
|
|
writeq_be(lli->lun_id[chan], &fc_port_luns[lind]);
|
|
cfg->last_lun_index[chan]--;
|
|
dev_dbg(dev, "%s: Virtual LUNs on slot %d:\n\t%d=%llx\n",
|
|
__func__, lind, chan, lli->lun_id[chan]);
|
|
}
|
|
|
|
lli->in_table = true;
|
|
out:
|
|
mutex_unlock(&global.mutex);
|
|
dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* cxlflash_disk_virtual_open() - open a virtual disk of specified size
|
|
* @sdev: SCSI device associated with LUN owning virtual LUN.
|
|
* @arg: UVirtual ioctl data structure.
|
|
*
|
|
* On successful return, the user is informed of the resource handle
|
|
* to be used to identify the virtual LUN and the size (in blocks) of
|
|
* the virtual LUN in last LBA format. When the size of the virtual LUN
|
|
* is zero, the last LBA is reflected as -1.
|
|
*
|
|
* Return: 0 on success, -errno on failure
|
|
*/
|
|
int cxlflash_disk_virtual_open(struct scsi_device *sdev, void *arg)
|
|
{
|
|
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 dk_cxlflash_uvirtual *virt = (struct dk_cxlflash_uvirtual *)arg;
|
|
struct dk_cxlflash_resize resize;
|
|
|
|
u64 ctxid = DECODE_CTXID(virt->context_id),
|
|
rctxid = virt->context_id;
|
|
u64 lun_size = virt->lun_size;
|
|
u64 last_lba = 0;
|
|
u64 rsrc_handle = -1;
|
|
|
|
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);
|
|
|
|
/* Setup the LUNs block allocator on first call */
|
|
mutex_lock(&gli->mutex);
|
|
if (gli->mode == MODE_NONE) {
|
|
rc = init_vlun(lli);
|
|
if (rc) {
|
|
dev_err(dev, "%s: init_vlun failed rc=%d\n",
|
|
__func__, rc);
|
|
rc = -ENOMEM;
|
|
goto err0;
|
|
}
|
|
}
|
|
|
|
rc = cxlflash_lun_attach(gli, MODE_VIRTUAL, true);
|
|
if (unlikely(rc)) {
|
|
dev_err(dev, "%s: Failed attach to LUN (VIRTUAL)\n", __func__);
|
|
goto err0;
|
|
}
|
|
mutex_unlock(&gli->mutex);
|
|
|
|
rc = init_luntable(cfg, lli);
|
|
if (rc) {
|
|
dev_err(dev, "%s: init_luntable failed rc=%d\n", __func__, rc);
|
|
goto err1;
|
|
}
|
|
|
|
ctxi = get_context(cfg, rctxid, lli, 0);
|
|
if (unlikely(!ctxi)) {
|
|
dev_err(dev, "%s: Bad context ctxid=%llu\n", __func__, ctxid);
|
|
rc = -EINVAL;
|
|
goto err1;
|
|
}
|
|
|
|
rhte = rhte_checkout(ctxi, lli);
|
|
if (unlikely(!rhte)) {
|
|
dev_err(dev, "%s: too many opens ctxid=%llu\n",
|
|
__func__, ctxid);
|
|
rc = -EMFILE; /* too many opens */
|
|
goto err1;
|
|
}
|
|
|
|
rsrc_handle = (rhte - ctxi->rht_start);
|
|
|
|
/* Populate RHT format 0 */
|
|
rhte->nmask = MC_RHT_NMASK;
|
|
rhte->fp = SISL_RHT_FP(0U, ctxi->rht_perms);
|
|
|
|
/* Resize even if requested size is 0 */
|
|
marshal_virt_to_resize(virt, &resize);
|
|
resize.rsrc_handle = rsrc_handle;
|
|
rc = _cxlflash_vlun_resize(sdev, ctxi, &resize);
|
|
if (rc) {
|
|
dev_err(dev, "%s: resize failed rc=%d\n", __func__, rc);
|
|
goto err2;
|
|
}
|
|
last_lba = resize.last_lba;
|
|
|
|
if (virt->hdr.flags & DK_CXLFLASH_UVIRTUAL_NEED_WRITE_SAME)
|
|
ctxi->rht_needs_ws[rsrc_handle] = true;
|
|
|
|
virt->hdr.return_flags = 0;
|
|
virt->last_lba = last_lba;
|
|
virt->rsrc_handle = rsrc_handle;
|
|
|
|
if (get_num_ports(lli->port_sel) > 1)
|
|
virt->hdr.return_flags |= DK_CXLFLASH_ALL_PORTS_ACTIVE;
|
|
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;
|
|
|
|
err2:
|
|
rhte_checkin(ctxi, rhte);
|
|
err1:
|
|
cxlflash_lun_detach(gli);
|
|
goto out;
|
|
err0:
|
|
/* Special common cleanup prior to successful LUN attach */
|
|
cxlflash_ba_terminate(&gli->blka.ba_lun);
|
|
mutex_unlock(&gli->mutex);
|
|
goto out;
|
|
}
|
|
|
|
/**
|
|
* clone_lxt() - copies translation tables from source to destination RHTE
|
|
* @afu: AFU associated with the host.
|
|
* @blka: Block allocator associated with LUN.
|
|
* @ctxid: Context ID of context owning the RHTE.
|
|
* @rhndl: Resource handle associated with the RHTE.
|
|
* @rhte: Destination resource handle entry (RHTE).
|
|
* @rhte_src: Source resource handle entry (RHTE).
|
|
*
|
|
* Return: 0 on success, -errno on failure
|
|
*/
|
|
static int clone_lxt(struct afu *afu,
|
|
struct blka *blka,
|
|
ctx_hndl_t ctxid,
|
|
res_hndl_t rhndl,
|
|
struct sisl_rht_entry *rhte,
|
|
struct sisl_rht_entry *rhte_src)
|
|
{
|
|
struct cxlflash_cfg *cfg = afu->parent;
|
|
struct device *dev = &cfg->dev->dev;
|
|
struct sisl_lxt_entry *lxt;
|
|
u32 ngrps;
|
|
u64 aun; /* chunk# allocated by block allocator */
|
|
int i, j;
|
|
|
|
ngrps = LXT_NUM_GROUPS(rhte_src->lxt_cnt);
|
|
|
|
if (ngrps) {
|
|
/* allocate new LXTs for clone */
|
|
lxt = kzalloc((sizeof(*lxt) * LXT_GROUP_SIZE * ngrps),
|
|
GFP_KERNEL);
|
|
if (unlikely(!lxt))
|
|
return -ENOMEM;
|
|
|
|
/* copy over */
|
|
memcpy(lxt, rhte_src->lxt_start,
|
|
(sizeof(*lxt) * rhte_src->lxt_cnt));
|
|
|
|
/* clone the LBAs in block allocator via ref_cnt */
|
|
mutex_lock(&blka->mutex);
|
|
for (i = 0; i < rhte_src->lxt_cnt; i++) {
|
|
aun = (lxt[i].rlba_base >> MC_CHUNK_SHIFT);
|
|
if (ba_clone(&blka->ba_lun, aun) == -1ULL) {
|
|
/* free the clones already made */
|
|
for (j = 0; j < i; j++) {
|
|
aun = (lxt[j].rlba_base >>
|
|
MC_CHUNK_SHIFT);
|
|
ba_free(&blka->ba_lun, aun);
|
|
}
|
|
|
|
mutex_unlock(&blka->mutex);
|
|
kfree(lxt);
|
|
return -EIO;
|
|
}
|
|
}
|
|
mutex_unlock(&blka->mutex);
|
|
} else {
|
|
lxt = NULL;
|
|
}
|
|
|
|
/*
|
|
* The following sequence is prescribed in the SISlite spec
|
|
* for syncing up with the AFU when adding LXT entries.
|
|
*/
|
|
dma_wmb(); /* Make LXT updates are visible */
|
|
|
|
rhte->lxt_start = lxt;
|
|
dma_wmb(); /* Make RHT entry's LXT table update visible */
|
|
|
|
rhte->lxt_cnt = rhte_src->lxt_cnt;
|
|
dma_wmb(); /* Make RHT entry's LXT table size update visible */
|
|
|
|
cxlflash_afu_sync(afu, ctxid, rhndl, AFU_LW_SYNC);
|
|
|
|
dev_dbg(dev, "%s: returning\n", __func__);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* cxlflash_disk_clone() - clone a context by making snapshot of another
|
|
* @sdev: SCSI device associated with LUN owning virtual LUN.
|
|
* @clone: Clone ioctl data structure.
|
|
*
|
|
* This routine effectively performs cxlflash_disk_open operation for each
|
|
* in-use virtual resource in the source context. Note that the destination
|
|
* context must be in pristine state and cannot have any resource handles
|
|
* open at the time of the clone.
|
|
*
|
|
* Return: 0 on success, -errno on failure
|
|
*/
|
|
int cxlflash_disk_clone(struct scsi_device *sdev,
|
|
struct dk_cxlflash_clone *clone)
|
|
{
|
|
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 blka *blka = &gli->blka;
|
|
struct afu *afu = cfg->afu;
|
|
struct dk_cxlflash_release release = { { 0 }, 0 };
|
|
|
|
struct ctx_info *ctxi_src = NULL,
|
|
*ctxi_dst = NULL;
|
|
struct lun_access *lun_access_src, *lun_access_dst;
|
|
u32 perms;
|
|
u64 ctxid_src = DECODE_CTXID(clone->context_id_src),
|
|
ctxid_dst = DECODE_CTXID(clone->context_id_dst),
|
|
rctxid_src = clone->context_id_src,
|
|
rctxid_dst = clone->context_id_dst;
|
|
int i, j;
|
|
int rc = 0;
|
|
bool found;
|
|
LIST_HEAD(sidecar);
|
|
|
|
dev_dbg(dev, "%s: ctxid_src=%llu ctxid_dst=%llu\n",
|
|
__func__, ctxid_src, ctxid_dst);
|
|
|
|
/* Do not clone yourself */
|
|
if (unlikely(rctxid_src == rctxid_dst)) {
|
|
rc = -EINVAL;
|
|
goto out;
|
|
}
|
|
|
|
if (unlikely(gli->mode != MODE_VIRTUAL)) {
|
|
rc = -EINVAL;
|
|
dev_dbg(dev, "%s: Only supported on virtual LUNs mode=%u\n",
|
|
__func__, gli->mode);
|
|
goto out;
|
|
}
|
|
|
|
ctxi_src = get_context(cfg, rctxid_src, lli, CTX_CTRL_CLONE);
|
|
ctxi_dst = get_context(cfg, rctxid_dst, lli, 0);
|
|
if (unlikely(!ctxi_src || !ctxi_dst)) {
|
|
dev_dbg(dev, "%s: Bad context ctxid_src=%llu ctxid_dst=%llu\n",
|
|
__func__, ctxid_src, ctxid_dst);
|
|
rc = -EINVAL;
|
|
goto out;
|
|
}
|
|
|
|
/* Verify there is no open resource handle in the destination context */
|
|
for (i = 0; i < MAX_RHT_PER_CONTEXT; i++)
|
|
if (ctxi_dst->rht_start[i].nmask != 0) {
|
|
rc = -EINVAL;
|
|
goto out;
|
|
}
|
|
|
|
/* Clone LUN access list */
|
|
list_for_each_entry(lun_access_src, &ctxi_src->luns, list) {
|
|
found = false;
|
|
list_for_each_entry(lun_access_dst, &ctxi_dst->luns, list)
|
|
if (lun_access_dst->sdev == lun_access_src->sdev) {
|
|
found = true;
|
|
break;
|
|
}
|
|
|
|
if (!found) {
|
|
lun_access_dst = kzalloc(sizeof(*lun_access_dst),
|
|
GFP_KERNEL);
|
|
if (unlikely(!lun_access_dst)) {
|
|
dev_err(dev, "%s: lun_access allocation fail\n",
|
|
__func__);
|
|
rc = -ENOMEM;
|
|
goto out;
|
|
}
|
|
|
|
*lun_access_dst = *lun_access_src;
|
|
list_add(&lun_access_dst->list, &sidecar);
|
|
}
|
|
}
|
|
|
|
if (unlikely(!ctxi_src->rht_out)) {
|
|
dev_dbg(dev, "%s: Nothing to clone\n", __func__);
|
|
goto out_success;
|
|
}
|
|
|
|
/* User specified permission on attach */
|
|
perms = ctxi_dst->rht_perms;
|
|
|
|
/*
|
|
* Copy over checked-out RHT (and their associated LXT) entries by
|
|
* hand, stopping after we've copied all outstanding entries and
|
|
* cleaning up if the clone fails.
|
|
*
|
|
* Note: This loop is equivalent to performing cxlflash_disk_open and
|
|
* cxlflash_vlun_resize. As such, LUN accounting needs to be taken into
|
|
* account by attaching after each successful RHT entry clone. In the
|
|
* event that a clone failure is experienced, the LUN detach is handled
|
|
* via the cleanup performed by _cxlflash_disk_release.
|
|
*/
|
|
for (i = 0; i < MAX_RHT_PER_CONTEXT; i++) {
|
|
if (ctxi_src->rht_out == ctxi_dst->rht_out)
|
|
break;
|
|
if (ctxi_src->rht_start[i].nmask == 0)
|
|
continue;
|
|
|
|
/* Consume a destination RHT entry */
|
|
ctxi_dst->rht_out++;
|
|
ctxi_dst->rht_start[i].nmask = ctxi_src->rht_start[i].nmask;
|
|
ctxi_dst->rht_start[i].fp =
|
|
SISL_RHT_FP_CLONE(ctxi_src->rht_start[i].fp, perms);
|
|
ctxi_dst->rht_lun[i] = ctxi_src->rht_lun[i];
|
|
|
|
rc = clone_lxt(afu, blka, ctxid_dst, i,
|
|
&ctxi_dst->rht_start[i],
|
|
&ctxi_src->rht_start[i]);
|
|
if (rc) {
|
|
marshal_clone_to_rele(clone, &release);
|
|
for (j = 0; j < i; j++) {
|
|
release.rsrc_handle = j;
|
|
_cxlflash_disk_release(sdev, ctxi_dst,
|
|
&release);
|
|
}
|
|
|
|
/* Put back the one we failed on */
|
|
rhte_checkin(ctxi_dst, &ctxi_dst->rht_start[i]);
|
|
goto err;
|
|
}
|
|
|
|
cxlflash_lun_attach(gli, gli->mode, false);
|
|
}
|
|
|
|
out_success:
|
|
list_splice(&sidecar, &ctxi_dst->luns);
|
|
|
|
/* fall through */
|
|
out:
|
|
if (ctxi_src)
|
|
put_context(ctxi_src);
|
|
if (ctxi_dst)
|
|
put_context(ctxi_dst);
|
|
dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
|
|
return rc;
|
|
|
|
err:
|
|
list_for_each_entry_safe(lun_access_src, lun_access_dst, &sidecar, list)
|
|
kfree(lun_access_src);
|
|
goto out;
|
|
}
|