Allow userspace applications to obtain CXL resources and exploit the
superpipe functionality of the IBM CXL Flash adapter.
Signed-off-by: Matthew R. Ochs <mrochs@xxxxxxxxxxxxxxxxxx>
Signed-off-by: Manoj N. Kumar <manoj@xxxxxxxxxxxxxxxxxx>
---
drivers/scsi/cxlflash/Makefile | 2 +-
drivers/scsi/cxlflash/main.c | 1 +
drivers/scsi/cxlflash/main.h | 1 +
drivers/scsi/cxlflash/superpipe.c | 1673 ++++++++++++++++++++++++++++++++++++
drivers/scsi/cxlflash/superpipe.h | 67 ++
include/uapi/scsi/Kbuild | 1 +
include/uapi/scsi/cxlflash_ioctl.h | 133 +++
7 files changed, 1877 insertions(+), 1 deletion(-)
create mode 100644 drivers/scsi/cxlflash/superpipe.c
create mode 100644 drivers/scsi/cxlflash/superpipe.h
create mode 100644 include/uapi/scsi/cxlflash_ioctl.h
diff --git a/drivers/scsi/cxlflash/Makefile b/drivers/scsi/cxlflash/Makefile
index 90e9382..5ddcae4 100644
--- a/drivers/scsi/cxlflash/Makefile
+++ b/drivers/scsi/cxlflash/Makefile
@@ -1,4 +1,4 @@
obj-$(CONFIG_CXLFLASH) += cxlflash.o
-cxlflash-y += main.o
+cxlflash-y += main.o superpipe.o
ccflags-y += -DCONFIG_PRINTK
diff --git a/drivers/scsi/cxlflash/main.c b/drivers/scsi/cxlflash/main.c
index 2533ecb..4612ccd 100644
--- a/drivers/scsi/cxlflash/main.c
+++ b/drivers/scsi/cxlflash/main.c
@@ -601,6 +601,7 @@ static struct scsi_host_template driver_template = {
.module = THIS_MODULE,
.name = CXLFLASH_ADAPTER_NAME,
.info = cxlflash_driver_info,
+ .ioctl = cxlflash_ioctl,
.proc_name = CXLFLASH_NAME,
.queuecommand = cxlflash_queuecommand,
.eh_device_reset_handler = cxlflash_eh_device_reset_handler,
diff --git a/drivers/scsi/cxlflash/main.h b/drivers/scsi/cxlflash/main.h
index b79d4f3..67332f1 100644
--- a/drivers/scsi/cxlflash/main.h
+++ b/drivers/scsi/cxlflash/main.h
@@ -120,5 +120,6 @@ static inline u64 lun_to_lunid(u64 lun)
/*
* Externs and Prototypes
*/
+int cxlflash_ioctl(struct scsi_device *, int, void __user *);
#endif /* _CXLFLASH_MAIN_H */
diff --git a/drivers/scsi/cxlflash/superpipe.c b/drivers/scsi/cxlflash/superpipe.c
new file mode 100644
index 0000000..9cc7666
--- /dev/null
+++ b/drivers/scsi/cxlflash/superpipe.c
@@ -0,0 +1,1673 @@
+/*
+ * CXL Flash Device Driver
+ *
+ * Written by: Manoj N. Kumar <manoj@xxxxxxxxxxxxxxxxxx>, IBM Corporation
+ * Matthew R. Ochs <mrochs@xxxxxxxxxxxxxxxxxx>, 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/file.h>
+#include <misc/cxl.h>
+#include <asm/unaligned.h>
+
+#include <scsi/scsi_host.h>
+#include <uapi/scsi/cxlflash_ioctl.h>
+
+#include "sislite.h"
+#include "common.h"
+#include "superpipe.h"
+
+static void marshall_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;
+}
+
+static void marshall_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;
+}
+
+static void marshall_det_to_rele(struct dk_cxlflash_detach *detach,
+ struct dk_cxlflash_release *release)
+{
+ release->hdr = detach->hdr;
+ release->context_id = detach->context_id;
+}
+
+static void marshall_clone_to_rele(struct dk_cxlflash_clone *clone,
+ struct dk_cxlflash_release *release)
+{
+ release->hdr = clone->hdr;
+ release->context_id = clone->context_id_dst;
+}
+
+static int ba_init(struct ba_lun *ba_lun)
+{
+ struct ba_lun_info *lun_info = NULL;
+ int lun_size_au = 0, i = 0;
+ int last_word_underflow = 0;
+ u64 *lam;
+
+ cxlflash_info("Initializing LUN: lun_id = %llX, "
+ "ba_lun->lsize = %lX, ba_lun->au_size = %lX",
+ 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) {
+ cxlflash_err("Requested LUN size of 0!");
+ return -EINVAL;
+ }
+
+ /* Allocate lun_fino */
+ lun_info = kzalloc(sizeof(struct ba_lun_info), GFP_KERNEL);
+ if (unlikely(!lun_info)) {
+ cxlflash_err("Failed to allocate lun_info for lun_id %llX",
+ ba_lun->lun_id);
+ return -ENOMEM;
+ }
+
+ lun_info->total_aus = lun_size_au;
+ lun_info->lun_bmap_size = lun_size_au / 64;
+
+ if (lun_size_au % 64)
+ lun_info->lun_bmap_size++;
+
+ /* Allocate bitmap space */
+ lun_info->lun_alloc_map = kzalloc((lun_info->lun_bmap_size *
+ sizeof(u64)), GFP_KERNEL);
+ if (unlikely(!lun_info->lun_alloc_map)) {
+ cxlflash_err("Failed to allocate lun allocation map: "
+ "lun_id = %llX", ba_lun->lun_id);
+ kfree(lun_info);
+ return -ENOMEM;
+ }
+
+ /* Initialize the bit map size and set all bits to '1' */
+ lun_info->free_aun_cnt = lun_size_au;
+
+ for (i = 0; i < lun_info->lun_bmap_size; i++)
+ lun_info->lun_alloc_map[i] = (u64) ~ 0;
+
+ /* If the last word not fully utilized, mark extra bits as allocated */
+ last_word_underflow = (lun_info->lun_bmap_size * 64) -
+ lun_info->free_aun_cnt;
+ if (last_word_underflow > 0) {
+ lam = &lun_info->lun_alloc_map[lun_info->lun_bmap_size - 1];
+ for (i = (63 - last_word_underflow + 1); i < 64; i++)
+ clear_bit(i, (ulong *)lam);
+ }
+
+ /* Initialize high elevator index, low/curr already at 0 from kzalloc */
+ lun_info->free_high_idx = lun_info->lun_bmap_size;
+
+ /* Allocate clone map */
+ lun_info->aun_clone_map = kzalloc((lun_info->total_aus *
+ sizeof(u8)), GFP_KERNEL);
+ if (unlikely(!lun_info->aun_clone_map)) {
+ cxlflash_err("Failed to allocate clone map: lun_id = %llX",
+ ba_lun->lun_id);
+ kfree(lun_info->lun_alloc_map);
+ kfree(lun_info);
+ return -ENOMEM;
+ }
+
+ /* Pass the allocated lun info as a handle to the user */
+ ba_lun->ba_lun_handle = (void *)lun_info;
+
+ cxlflash_info("Successfully initialized the LUN: "
+ "lun_id = %llX, bitmap size = %X, free_aun_cnt = %llX",
+ ba_lun->lun_id, lun_info->lun_bmap_size,
+ lun_info->free_aun_cnt);
+ return 0;
+}
+
+static int find_free_range(u32 low,
+ u32 high,
+ struct ba_lun_info *lun_info, int *bit_word)
+{
+ int i;
+ u64 bit_pos = -1;
+ ulong *lam;
+
+ for (i = low; i < high; i++)
+ if (lun_info->lun_alloc_map[i] != 0) {
+ lam = (ulong *)&lun_info->lun_alloc_map[i];
+ bit_pos = find_first_bit(lam, sizeof(u64));
+
+ cxlflash_dbg("Found free bit %llX in lun "
+ "map entry %llX at bitmap index = %X",
+ bit_pos, lun_info->lun_alloc_map[i], i);
+
+ *bit_word = i;
+ lun_info->free_aun_cnt--;
+ clear_bit(bit_pos, lam);
+ break;
+ }
+
+ return bit_pos;
+}
+
+static u64 ba_alloc(struct ba_lun *ba_lun)
+{
+ u64 bit_pos = -1;
+ int bit_word = 0;
+ struct ba_lun_info *lun_info = NULL;
+
+ lun_info = (struct ba_lun_info *)ba_lun->ba_lun_handle;
+
+ cxlflash_dbg("Received block allocation request: "
+ "lun_id = %llX, free_aun_cnt = %llX",
+ ba_lun->lun_id, lun_info->free_aun_cnt);
+
+ if (lun_info->free_aun_cnt == 0) {
+ cxlflash_err("No space left on LUN: lun_id = %llX",
+ ba_lun->lun_id);
+ return -1ULL;
+ }
+
+ /* Search to find a free entry, curr->high then low->curr */
+ bit_pos = find_free_range(lun_info->free_curr_idx,
+ lun_info->free_high_idx, lun_info, &bit_word);
+ if (bit_pos == -1) {
+ bit_pos = find_free_range(lun_info->free_low_idx,
+ lun_info->free_curr_idx,
+ lun_info, &bit_word);
+ if (bit_pos == -1) {
+ cxlflash_err
+ ("Could not find an allocation unit on LUN: "
+ "lun_id = %llX", ba_lun->lun_id);
+ return -1ULL;
+ }
+ }
+
+ /* Update the free_curr_idx */
+ if (bit_pos == 63)
+ lun_info->free_curr_idx = bit_word + 1;
+ else
+ lun_info->free_curr_idx = bit_word;
+
+ cxlflash_dbg("Allocating AU number %llX, on lun_id %llX, "
+ "free_aun_cnt = %llX", ((bit_word * 64) + bit_pos),
+ ba_lun->lun_id, lun_info->free_aun_cnt);
+
+ return (u64) ((bit_word * 64) + bit_pos);
+}
+
+static int validate_alloc(struct ba_lun_info *lun_info, u64 aun)
+{
+ int idx = 0, bit_pos = 0;
+
+ idx = aun / 64;
+ bit_pos = aun % 64;
+
+ if (test_bit(bit_pos, (ulong *)&lun_info->lun_alloc_map[idx]))
+ return -1;
+
+ return 0;
+}
+
+static int ba_free(struct ba_lun *ba_lun, u64 to_free)
+{
+ int idx = 0, bit_pos = 0;
+ struct ba_lun_info *lun_info = NULL;
+
+ lun_info = (struct ba_lun_info *)ba_lun->ba_lun_handle;
+
+ if (validate_alloc(lun_info, to_free)) {
+ cxlflash_err("The AUN %llX is not allocated on lun_id %llX",
+ to_free, ba_lun->lun_id);
+ return -1;
+ }
+
+ cxlflash_dbg("Received a request to free AU %llX on lun_id %llX, "
+ "free_aun_cnt = %llX", to_free, ba_lun->lun_id,
+ lun_info->free_aun_cnt);
+
+ if (lun_info->aun_clone_map[to_free] > 0) {
+ cxlflash_info("AUN %llX on lun_id %llX has been cloned. Clone "
+ "count = %X",
+ to_free, ba_lun->lun_id,
+ lun_info->aun_clone_map[to_free]);
+ lun_info->aun_clone_map[to_free]--;
+ return 0;
+ }
+
+ idx = to_free / 64;
+ bit_pos = to_free % 64;
+
+ set_bit(bit_pos, (ulong *)&lun_info->lun_alloc_map[idx]);
+ lun_info->free_aun_cnt++;
+
+ if (idx < lun_info->free_low_idx)
+ lun_info->free_low_idx = idx;
+ else if (idx > lun_info->free_high_idx)
+ lun_info->free_high_idx = idx;
+
+ cxlflash_dbg("Successfully freed AU at bit_pos %X, bit map index %X on "
+ "lun_id %llX, free_aun_cnt = %llX", bit_pos, idx,
+ ba_lun->lun_id, lun_info->free_aun_cnt);
+
+ return 0;
+}
+
+static int ba_clone(struct ba_lun *ba_lun, u64 to_clone)
+{
+ struct ba_lun_info *lun_info =
+ (struct ba_lun_info *)ba_lun->ba_lun_handle;
+
+ if (validate_alloc(lun_info, to_clone)) {
+ cxlflash_err("AUN %llX is not allocated on lun_id %llX",
+ to_clone, ba_lun->lun_id);
+ return -1;
+ }
+
+ cxlflash_info("Received a request to clone AUN %llX on lun_id %llX",
+ to_clone, ba_lun->lun_id);
+
+ if (lun_info->aun_clone_map[to_clone] == MAX_AUN_CLONE_CNT) {
+ cxlflash_err
+ ("AUN %llX on lun_id %llX has hit max clones already",
+ to_clone, ba_lun->lun_id);
+ return -1;
+ }
+
+ lun_info->aun_clone_map[to_clone]++;
+
+ return 0;
+}
+
+static u64 ba_space(struct ba_lun *ba_lun)
+{
+ struct ba_lun_info *lun_info =
+ (struct ba_lun_info *)ba_lun->ba_lun_handle;
+
+ return lun_info->free_aun_cnt;
+}
+
+static int cxlflash_afu_attach(struct cxlflash *cxlflash, u64 context_id)
+{
+ struct afu *afu = cxlflash->afu;
+ struct ctx_info *ctx_info = &afu->ctx_info[context_id];
+ int rc = 0;
+ u64 reg;
+
+ /* restrict user to read/write cmds in translated
+ * mode. User has option to choose read and/or write
+ * permissions again in mc_open.
+ */
+ (void)readq_be(&ctx_info->ctrl_map->mbox_r); /* unlock ctx_cap */
+ writeq_be((SISL_CTX_CAP_READ_CMD | SISL_CTX_CAP_WRITE_CMD),
+ &ctx_info->ctrl_map->ctx_cap);
+
+ reg = readq_be(&ctx_info->ctrl_map->ctx_cap);
+
+ /* if the write failed, the ctx must have been
+ * closed since the mbox read and the ctx_cap
+ * register locked up. fail the registration
+ */
+ if (reg != (SISL_CTX_CAP_READ_CMD | SISL_CTX_CAP_WRITE_CMD)) {
+ cxlflash_err("ctx may be closed reg=%llx", reg);
+ rc = -EAGAIN;
+ goto out;
+ }
+
+ /* the context gets a dedicated RHT tbl */
+ ctx_info->rht_info = &afu->rht_info[context_id];
+ ctx_info->rht_info->ref_cnt = 1;
+ memset(ctx_info->rht_info->rht_start, 0,
+ sizeof(struct sisl_rht_entry) * MAX_RHT_PER_CONTEXT);
+ /* make clearing of the RHT visible to AFU before
+ * MMIO
+ */
+ smp_wmb();
+
+ /* set up MMIO registers pointing to the RHT */
+ writeq_be((u64) ctx_info->rht_info->rht_start,
+ &ctx_info->ctrl_map->rht_start);
+ writeq_be(SISL_RHT_CNT_ID((u64) MAX_RHT_PER_CONTEXT,
+ (u64) (afu->ctx_hndl)),
+ &ctx_info->ctrl_map->rht_cnt_id);
+ ctx_info->ref_cnt = 1;
+out:
+ cxlflash_info("returning rc=%d", rc);
+ return rc;
+
+}
+
+static int cxlflash_init_ba(struct lun_info *lun_info)
+{
+ int rc = 0;
+ struct blka *blka = &lun_info->blka;
+
+ memset(blka, 0, sizeof(*blka));
+ mutex_init(&blka->mutex);
+
+ blka->ba_lun.lun_id = lun_info->lun_id;
+ blka->ba_lun.lsize = lun_info->max_lba + 1;
+ blka->ba_lun.lba_size = lun_info->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 (rc) {
+ cxlflash_err("cannot init block_alloc, rc=%d", rc);
+ goto cxlflash_init_ba_exit;
+ }
+
+cxlflash_init_ba_exit:
+ cxlflash_info("returning rc=%d lun_info=%p", rc, lun_info);
+ return rc;
+}
+
+int cxlflash_cxl_release(struct inode *inode, struct file *file)
+{
+ struct cxl_context *ctx = cxl_fops_get_context(file);
+ struct cxlflash *cxlflash = container_of(file->f_op, struct cxlflash,
+ cxl_fops);
+ int context_id = cxl_process_element(ctx);
+
+ if (context_id < 0) {
+ cxlflash_err("context %d closed", context_id);
+ return 0;
+ }
+
+ cxlflash_info("close(%d) for context %d",
+ cxlflash->per_context[context_id].lfd, context_id);
+
+ return cxl_fd_release(inode, file);
+}
+
+const struct file_operations cxlflash_cxl_fops = {
+ .owner = THIS_MODULE,
+ .release = cxlflash_cxl_release,
+};
+
+/*
+ * NAME: cxlflash_disk_attach
+ *
+ * FUNCTION: attach a LUN to context
+ *
+ * INPUTS:
+ * sdev - Pointer to scsi device structure
+ * arg - Pointer to ioctl specific structure
+ *
+ * OUTPUTS:
+ * context_id - Unique context index
+ * adap_fd - New file descriptor for user
+ *
+ * RETURNS:
+ * 0 - Success
+ * errno - Failure
+ *
+ * NOTES:
+ * When successful:
+ * a. initialize AFU for this context
+ *
+ */
+static int cxlflash_disk_attach(struct scsi_device *sdev,
+ struct dk_cxlflash_attach *attach)
+{
+ struct cxlflash *cxlflash = (struct cxlflash *)sdev->host->hostdata;
+ struct afu *afu = cxlflash->afu;
+ struct lun_info *lun_info = sdev->hostdata;
+ struct cxl_ioctl_start_work *work;
+ int rc = 0;
+ u32 perms;
+ int context_id;
+ struct file *file;
+
+ struct cxl_context *ctx;
+
+ int fd = -1;
+
+ /* On first attach set fileops */
+ if (cxlflash->num_user_contexts == 0)
+ cxlflash->cxl_fops = cxlflash_cxl_fops;
+
+ if (lun_info->max_lba == 0) {
+ cxlflash_info("No capacity info yet for this LUN "
+ "(%016llX)", lun_info->lun_id);
+ read_cap16(afu, lun_info, sdev->channel + 1);
+ cxlflash_info("LBA = %016llX", lun_info->max_lba);
+ cxlflash_info("BLK_LEN = %08X", lun_info->blk_len);
+ rc = cxlflash_init_ba(lun_info);
+ if (rc) {
+ cxlflash_err("call to cxlflash_init_ba failed "
+ "rc=%d!", rc);
+ rc = -ENOMEM;
+ goto out;
+ }
+ }
+
+ ctx = cxl_dev_context_init(cxlflash->dev);
+ if (!ctx) {
+ cxlflash_err("Could not initialize context");
+ rc = -ENODEV;
+ goto out;
+ }
+
+ context_id = cxl_process_element(ctx);
+ if ((context_id > MAX_CONTEXT) || (context_id < 0)) {
+ cxlflash_err("context_id (%u) invalid!", context_id);
+ rc = -EPERM;
+ goto out;
+ }
+ //BUG_ON(cxlflash->per_context[context_id].lfd != -1);
+ //BUG_ON(cxlflash->per_context[context_id].pid != 0);
+
+ /*
+ * Create and attach a new file descriptor. This must be the last
+ * statement as once this is run, the file descritor is visible to
+ * userspace and can't be undone. No error paths after this as we
+ * can't free the fd safely.
+ */
+ work = &cxlflash->per_context[context_id].work;
+ memset(work, 0, sizeof(*work));
+ work->num_interrupts = attach->num_interrupts;
+ work->flags = CXL_START_WORK_NUM_IRQS;
+
+ file = cxl_get_fd(ctx, &cxlflash->cxl_fops, &fd);
+ if (fd < 0) {
+ rc = -ENODEV;
+ cxlflash_err("Could not get file descriptor");
+ goto err1;
+ }
+
+ rc = cxl_start_work(ctx, work);
+ if (rc) {
+ cxlflash_err("Could not start context rc=%d", rc);
+ goto err2;
+ }
+
+ rc = cxlflash_afu_attach(cxlflash, context_id);
+ if (rc) {
+ cxlflash_err("Could not attach AFU rc %d", rc);
+ goto err3;
+ }
+
+ /* No error paths after installing the fd */
+ fd_install(fd, file);
+
+ cxlflash->num_user_contexts++;
+ cxlflash->per_context[context_id].lfd = fd;
+ cxlflash->per_context[context_id].pid = current->pid;
+ cxlflash->per_context[context_id].ctx = ctx;
+
+ /* Translate read/write O_* flags from fnctl.h to AFU permission bits */
+ perms = ((attach->hdr.flags + 1) & 0x3);
+ afu->ctx_info[context_id].rht_info->perms = perms;
+
+ attach->hdr.return_flags = 0;
+ attach->context_id = context_id;
+ attach->block_size = lun_info->blk_len;
+ attach->mmio_size = sizeof(afu->afu_map->hosts[0].harea);
+ attach->last_lba = lun_info->max_lba;
+ attach->max_xfer = sdev->host->max_sectors;
+
+out:
+ attach->adap_fd = fd;
+
+ cxlflash_info("returning fd=%d bs=%lld rc=%d llba=%lld",
+ fd, attach->block_size, rc, attach->last_lba);
+ return rc;
+
+err3:
+ cxl_stop_context(ctx);
+err2:
+ fput(file);
+ put_unused_fd(fd);
+ fd = -1;
+err1:
+ cxl_release_context(ctx);
+ goto out;
+}
+
+static struct ctx_info *get_validated_context(struct cxlflash *cxlflash,
+ u64 ctxid, bool clone_path)
+{
+ struct afu *afu = cxlflash->afu;
+ struct ctx_info *ctx_info = NULL;
+ bool mc_override = ctxid == afu->ctx_hndl;
+ pid_t pid = current->pid, ctxpid = 0;
+
+ if (unlikely(clone_path))
+ pid = current->parent->pid;
+
+ if (likely(ctxid < MAX_CONTEXT)) {
+ ctx_info = &afu->ctx_info[ctxid];
+
+ if (checkpid) {
+ ctxpid = cxlflash->per_context[ctxid].pid;
+
+ if ((pid != ctxpid) && (!mc_override))
+ ctx_info = NULL;
+ }
+ }
+
+ cxlflash_dbg("ctxid=%llu ctx_info=%p ctxpid=%u pid=%u clone_path=%d",
+ ctxid, ctx_info, ctxpid, pid, clone_path);
+
+ return ctx_info;
+}
+
+/* Checkout a free/empty RHT entry */
+static struct sisl_rht_entry *rhte_checkout(struct cxlflash *cxlflash,
+ u64 context_id)
+{
+ struct ctx_info *ctx_info;
+ struct rht_info *rht_info = NULL;
+ struct sisl_rht_entry *rht_entry = NULL;
+ int i;
+
+ ctx_info = get_validated_context(cxlflash, context_id, false);
+ if (unlikely(!ctx_info)) {
+ cxlflash_err("Invalid context! (%llu)", context_id);
+ goto out;
+ }
+
+ rht_info = ctx_info->rht_info;
+
+ cxlflash_info("ctx 0x%llx ctxinfo %p rhtinfo %p",
+ context_id, ctx_info, rht_info);
+
+ /* find a free RHT entry */
+ for (i = 0; i < MAX_RHT_PER_CONTEXT; i++)
+ if (rht_info->rht_start[i].nmask == 0) {
+ rht_entry = &rht_info->rht_start[i];
+ break;
+ }
+
+ cxlflash_dbg("i %d rhti %p rhte %p", i, rht_info, rht_entry);
+
+ /* No free entries means we've reached max opens allowed per context */
+ if (unlikely(!rht_entry)) {
+ cxlflash_err("No free entries found for context id %llu",
+ context_id);
+ goto out;
+ }
+
+out:
+ cxlflash_info("returning rht_entry=%p", rht_entry);
+ return rht_entry;
+}
+
+static void rhte_checkin(struct sisl_rht_entry *rht_entry)
+{
+ rht_entry->nmask = 0;
+ rht_entry->fp = 0;
+}
+
+void cxlflash_rht_format1(struct sisl_rht_entry *rht_entry,
+ u64 lun_id, u32 perm)
+{
+ /*
+ * 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 *rht_entry_f1 =
+ (struct sisl_rht_entry_f1 *)rht_entry;
+ memset(rht_entry_f1, 0, sizeof(struct sisl_rht_entry_f1));
+ rht_entry_f1->fp = SISL_RHT_FP(1U, 0);
+ smp_wmb();
+
+ rht_entry_f1->lun_id = lun_id;
+ smp_wmb();
+
+ /*
+ * 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);
+#if 0 /* XXX - check with Andy/Todd b/c this doesn't work */
+ if (internal_lun)
+ dummy.port_sel = 0x1;
+ else
+#endif
+ dummy.port_sel = 0x3;
+ rht_entry_f1->dw = dummy.dw;
+
+ smp_wmb();
+
+ return;
+}
+
+static int grow_lxt(struct afu *afu,
+ struct lun_info *lun_info,
+ ctx_hndl_t ctx_hndl_u,
+ res_hndl_t res_hndl_u,
+ struct sisl_rht_entry *rht_entry,
+ u64 delta, u64 * act_new_size)
+{
+ struct sisl_lxt_entry *lxt = NULL, *lxt_old = NULL;
+ unsigned int av_size;
+ unsigned int ngrps, ngrps_old;
+ u64 aun; /* chunk# allocated by block allocator */
+ int i;
+ struct blka *blka = &lun_info->blka;
+
+ /*
+ * 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 (av_size < delta)
+ delta = av_size;
+
+ lxt_old = rht_entry->lxt_start;
+ ngrps_old = LXT_NUM_GROUPS(rht_entry->lxt_cnt);
+ ngrps = LXT_NUM_GROUPS(rht_entry->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);
+ return -ENOMEM;
+ }
+
+ /* copy over all old entries */
+ memcpy(lxt, lxt_old, (sizeof(*lxt) *
+ rht_entry->lxt_cnt));
+ } else
+ lxt = lxt_old;
+
+ /* nothing can fail from now on */
+ *act_new_size = rht_entry->lxt_cnt + delta;
+
+ /* add new entries to the end */
+ for (i = rht_entry->lxt_cnt; i < *act_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))
+ cxlflash_err("ba_alloc error: allocated chunk# %llX, "
+ "max %llX", aun, blka->nchunk - 1);
+
+ /* select both ports, use r/w perms from RHT */
+ lxt[i].rlba_base = ((aun << MC_CHUNK_SHIFT) |
+ (lun_info->lun_index <<
+ LXT_LUNIDX_SHIFT) | 0x33);
+ }
+
+ mutex_unlock(&blka->mutex);
+
+ smp_wmb(); /* make lxt updates visible */
+
+ /* Now sync up AFU - this can take a while */
+ rht_entry->lxt_start = lxt; /* even if lxt didn't change */
+ smp_wmb();
+
+ rht_entry->lxt_cnt = *act_new_size;
+ smp_wmb();
+
+ cxlflash_afu_sync(afu, ctx_hndl_u, res_hndl_u, AFU_LW_SYNC);
+
+ /* free old lxt if reallocated */
+ if (lxt != lxt_old)
+ kfree(lxt_old);
+ cxlflash_info("returning");
+ return 0;
+}
+
+static int shrink_lxt(struct afu *afu,
+ struct lun_info *lun_info,
+ ctx_hndl_t ctx_hndl_u,
+ res_hndl_t res_hndl_u,
+ struct sisl_rht_entry *rht_entry,
+ u64 delta, u64 * act_new_size)
+{
+ struct sisl_lxt_entry *lxt, *lxt_old;
+ unsigned int ngrps, ngrps_old;
+ u64 aun; /* chunk# allocated by block allocator */
+ int i;
+ struct blka *blka = &lun_info->blka;
+
+ lxt_old = rht_entry->lxt_start;
+ ngrps_old = LXT_NUM_GROUPS(rht_entry->lxt_cnt);
+ ngrps = LXT_NUM_GROUPS(rht_entry->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))
+ return -ENOMEM;
+
+ /* copy over old entries that will remain */
+ memcpy(lxt, lxt_old, (sizeof(*lxt) *
+ (rht_entry->lxt_cnt -
+ delta)));
+ } else
+ lxt = NULL;
+ } else
+ lxt = lxt_old;
+
+ /* nothing can fail from now on */
+ *act_new_size = rht_entry->lxt_cnt - delta;
+
+ /* Now sync up AFU - this can take a while */
+ rht_entry->lxt_cnt = *act_new_size;
+ smp_wmb(); /* also makes lxt updates visible */
+
+ rht_entry->lxt_start = lxt; /* even if lxt didn't change */
+ smp_wmb();
+
+ cxlflash_afu_sync(afu, ctx_hndl_u, res_hndl_u, AFU_HW_SYNC);
+
+ /* free LBAs allocated to freed chunks */
+ mutex_lock(&blka->mutex);
+ for (i = delta - 1; i >= 0; i--) {
+ aun = (lxt_old[*act_new_size + i].rlba_base >>
+ MC_CHUNK_SHIFT);
+ ba_free(&blka->ba_lun, aun);
+ }
+ mutex_unlock(&blka->mutex);
+
+ /* free old lxt if reallocated */
+ if (lxt != lxt_old)
+ kfree(lxt_old);
+ cxlflash_info("returning");
+ return 0;
+}
+
+/*
+ * NAME: cxlflash_vlun_resize()
+ *
+ * FUNCTION: Resize a resource handle by changing the RHT entry and LXT
+ * Tbl it points to. Synchronize all contexts that refer to
+ * the RHT.
+ *
+ * INPUTS:
+ * sdev - Pointer to scsi device structure
+ * arg - Pointer to ioctl specific structure
+ *
+ * OUTPUTS:
+ * act_new_size - pointer to actual new size in chunks
+ *
+ * RETURNS:
+ * 0 - Success
+ * errno - Failure
+ *
+ * NOTES:
+ * Setting new_size=0 will clear LXT_START and LXT_CNT fields
+ * in the RHT entry.
+ */
+static int cxlflash_vlun_resize(struct scsi_device *sdev,
+ struct dk_cxlflash_resize *resize)
+{
+ struct cxlflash *cxlflash = (struct cxlflash *)sdev->host->hostdata;
+ struct lun_info *lun_info = sdev->hostdata;
+ struct afu *afu = cxlflash->afu;
+
+ u64 act_new_size = 0;
+ res_hndl_t res_hndl = resize->rsrc_handle;
+ u64 new_size;
+ u64 nsectors;
+
+ struct ctx_info *ctx_info;
+ struct rht_info *rht_info;
+ struct sisl_rht_entry *rht_entry;
+
+ int rc = 0;
+
+ /* req_size is always assumed to be in 4k blocks. So we have to convert
+ * it from 4k to chunk size
+ */
+ nsectors = (resize->req_size * CXLFLASH_BLOCK_SIZE) /
+ (lun_info->blk_len);
+ new_size = (nsectors + MC_CHUNK_SIZE - 1) / MC_CHUNK_SIZE;
+
+ cxlflash_info("context=0x%llx res_hndl=0x%llx, req_size=0x%llx,"
+ "new_size=%llx", resize->context_id,
+ resize->rsrc_handle, resize->req_size, new_size);
+
+ if (lun_info->mode != MODE_VIRTUAL) {
+ cxlflash_err("cannot resize lun that is not virtual %d",
+ lun_info->mode);
+ rc = -EINVAL;
+ goto out;
+
+ }
+
+ ctx_info = get_validated_context(cxlflash, resize->context_id, false);
+ if (unlikely(!ctx_info)) {
+ cxlflash_err("Invalid context! (%llu)", resize->context_id);
+ rc = -EINVAL;
+ goto out;
+ }
+
+ rht_info = ctx_info->rht_info;
+
+ if (res_hndl < MAX_RHT_PER_CONTEXT) {
+ rht_entry = &rht_info->rht_start[res_hndl];
+
+ if (rht_entry->nmask == 0) { /* not open */
+ cxlflash_err("not open rhti %p rhte %p",
+ rht_info, rht_entry);
+ rc = -EINVAL;
+ goto out;
+ }
+
+ if (new_size > rht_entry->lxt_cnt)
+ grow_lxt(afu,
+ lun_info,
+ resize->context_id,
+ res_hndl,
+ rht_entry,
+ new_size - rht_entry->lxt_cnt,
+ &act_new_size);
+ else if (new_size < rht_entry->lxt_cnt)
+ shrink_lxt(afu,
+ lun_info,
+ resize->context_id,
+ res_hndl,
+ rht_entry,
+ rht_entry->lxt_cnt - new_size,
+ &act_new_size);
+ else
+ act_new_size = new_size;
+ } else {
+ cxlflash_err("res_hndl %d invalid", res_hndl);
+ rc = -EINVAL;
+ }
+ resize->hdr.return_flags = 0;
+ resize->last_lba = (((act_new_size * MC_CHUNK_SIZE *
+ lun_info->blk_len) / CXLFLASH_BLOCK_SIZE) - 1);
+
+out:
+ cxlflash_info("resized to %lld returning rc=%d", resize->last_lba, rc);
+ return rc;
+}
+
+/*
+ * NAME: cxlflash_disk_open
+ *
+ * FUNCTION: open a virtual lun of specified size
+ *
+ * INPUTS:
+ * sdev - Pointer to scsi device structure
+ * arg - Pointer to ioctl specific structure
+ *
+ * OUTPUTS:
+ * none
+ *
+ * RETURNS:
+ * 0 - Success
+ * errno - Failure
+ *
+ * NOTES:
+ * When successful:
+ * a. find a free RHT entry
+ *
+ */
+static int cxlflash_disk_open(struct scsi_device *sdev,
+ void *arg, enum open_mode_type mode)
+{
+ struct cxlflash *cxlflash = (struct cxlflash *)sdev->host->hostdata;
+ struct afu *afu = cxlflash->afu;
+ struct lun_info *lun_info = sdev->hostdata;
+
+ struct dk_cxlflash_uvirtual *virt = (struct dk_cxlflash_uvirtual *)arg;
+ struct dk_cxlflash_udirect *pphys = (struct dk_cxlflash_udirect *)arg;
+ struct dk_cxlflash_resize resize;
+
+ u32 perms;
+ u64 context_id;
+ u64 lun_size = 0;
+ u64 last_lba = 0;
+ u64 rsrc_handle = -1;
+
+ int rc = 0;
+
+ struct ctx_info *ctx_info;
+ struct rht_info *rht_info = NULL;
+ struct sisl_rht_entry *rht_entry = NULL;
+
+ if (mode == MODE_VIRTUAL) {
+ context_id = virt->context_id;
+ lun_size = virt->lun_size;
+ /* Initialize to invalid value */
+ virt->rsrc_handle = -1;
+ } else if (mode == MODE_PHYSICAL) {
+ context_id = pphys->context_id;
+ /* Initialize to invalid value */
+ pphys->rsrc_handle = -1;
+ } else {
+ cxlflash_err("unknown mode %d", mode);
+ rc = -EINVAL;
+ goto out;
+ }
+
+ spin_lock(&lun_info->slock);
+ if (lun_info->mode == MODE_NONE)
+ lun_info->mode = mode;
+ else if (lun_info->mode != mode) {
+ cxlflash_err
+ ("disk already opened in mode %d, mode requested %d",
+ lun_info->mode, mode);
+ rc = -EINVAL;
+ spin_unlock(&lun_info->slock);
+ goto out;
+ }
+ spin_unlock(&lun_info->slock);
+
+ cxlflash_info("context=0x%llx ls=0x%llx", context_id, lun_size);
+
+ rht_entry = rhte_checkout(cxlflash, context_id);
+ if (!rht_entry) {
+ cxlflash_err("too many opens for this context");
+ rc = -EMFILE; /* too many opens */
+ goto out;
+ }
+
+ ctx_info = get_validated_context(cxlflash, context_id, false);
+ if (unlikely(!ctx_info)) {
+ cxlflash_err("Invalid context! (%llu)", context_id);
+ rc = -EINVAL;
+ goto out;
+ }
+
+ rht_info = ctx_info->rht_info;
+
+ /* User specified permission on attach */
+ perms = rht_info->perms;
+
+ rsrc_handle = (rht_entry - rht_info->rht_start);
+
+ if (mode == MODE_VIRTUAL) {
+ rht_entry->nmask = MC_RHT_NMASK;
+ rht_entry->fp = SISL_RHT_FP(0U, perms);
+ /* format 0 & perms */
+
+ if (lun_size != 0) {
+ marshall_virt_to_resize(virt, &resize);
+ resize.rsrc_handle = rsrc_handle;
+ rc = cxlflash_vlun_resize(sdev, &resize);
+ if (rc) {
+ cxlflash_err("resize failed rc %d", rc);
+ goto out;
+ }
+ last_lba = resize.last_lba;
+ }
+ virt->hdr.return_flags = 0;
+ virt->last_lba = last_lba;
+ virt->rsrc_handle = rsrc_handle;
+ } else if (mode == MODE_PHYSICAL) {
+ cxlflash_rht_format1(rht_entry, lun_info->lun_id, perms);
+ cxlflash_afu_sync(afu, context_id, rsrc_handle, AFU_LW_SYNC);
+
+ last_lba = lun_info->max_lba;
+ pphys->hdr.return_flags = 0;
+ pphys->last_lba = last_lba;
+ pphys->rsrc_handle = rsrc_handle;
+ }
+
+out:
+ cxlflash_info("returning handle 0x%llx rc=%d llba %lld",
+ rsrc_handle, rc, last_lba);
+ return rc;
+}
+
+/*
+ * NAME: cxlflash_disk_release
+ *
+ * FUNCTION: Close a virtual LBA space setting it to 0 size and
+ * marking the res_hndl as free/closed.
+ *
+ * INPUTS:
+ * sdev - Pointer to scsi device structure
+ * arg - Pointer to ioctl specific structure
+ *
+ * OUTPUTS:
+ * none
+ *
+ * RETURNS:
+ * 0 - Success
+ * errno - Failure
+ *
+ * NOTES:
+ * When successful, the RHT entry is cleared.
+ */
+static int cxlflash_disk_release(struct scsi_device *sdev,
+ struct dk_cxlflash_release *release)
+{
+ struct cxlflash *cxlflash = (struct cxlflash *)sdev->host->hostdata;
+ struct lun_info *lun_info = sdev->hostdata;
+ struct afu *afu = cxlflash->afu;
+
+ struct dk_cxlflash_resize size;
+ res_hndl_t res_hndl = release->rsrc_handle;
+
+ int rc = 0;
+
+ struct ctx_info *ctx_info;
+ struct rht_info *rht_info;
+ struct sisl_rht_entry *rht_entry;
+
+ cxlflash_info("context=0x%llx res_hndl=0x%llx",
+ release->context_id, release->rsrc_handle);
+
+ ctx_info =
+ get_validated_context(cxlflash, release->context_id, false);
+ if (unlikely(!ctx_info)) {
+ cxlflash_err("Invalid context! (%llu)", release->context_id);
+ rc = -EINVAL;
+ goto out;
+ }
+
+ rht_info = ctx_info->rht_info;
+
+ if (res_hndl < MAX_RHT_PER_CONTEXT) {
+ rht_entry = &rht_info->rht_start[res_hndl];
+ if (rht_entry->nmask == 0) { /* not open */
+ rc = -EINVAL;
+ cxlflash_err("not open");
+ 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.
+ */
+ if (lun_info->mode == MODE_VIRTUAL) {
+ marshall_rele_to_resize(release, &size);
+ size.req_size = 0;
+ rc = cxlflash_vlun_resize(sdev, &size);
+ if (rc) {
+ cxlflash_err("resize failed rc %d", rc);
+ goto out;
+ }
+ rhte_checkin(rht_entry);
+ } else if (lun_info->mode == MODE_PHYSICAL) {
+ /*
+ * Clear the Format 1 RHT entry for direct access
+ * (physical LUN) using the synchronization sequence
+ * defined in the SISLite specification.
+ */
+ struct sisl_rht_entry_f1 *rht_entry_f1 =
+ (struct sisl_rht_entry_f1 *)rht_entry;
+
+ rht_entry_f1->valid = 0;
+ smp_wmb();
+
+ rht_entry_f1->lun_id = 0;
+ smp_wmb();
+
+ rht_entry_f1->dw = 0;
+ smp_wmb();
+ cxlflash_afu_sync(afu, release->context_id, res_hndl,
+ AFU_HW_SYNC);
+ }
+
+ /* now the RHT entry is all cleared */
+ rc = 0;
+ rht_info->ref_cnt--;
+ } else {
+ rc = -EINVAL;
+ cxlflash_info("resource handle invalid %d", res_hndl);
+ }
+
+out:
+ cxlflash_info("returning rc=%d", rc);
+ return rc;
+}
+
+/*
+ * NAME: cxlflash_disk_detach
+ *
+ * FUNCTION: Unregister a user AFU context with master.
+ *
+ * INPUTS:
+ * sdev - Pointer to scsi device structure
+ * arg - Pointer to ioctl specific structure
+ *
+ * OUTPUTS:
+ * none
+ *
+ * RETURNS:
+ * 0 - Success
+ * errno - Failure
+ *
+ * NOTES:
+ * When successful:
+ * a. RHT_START, RHT_CNT & CTX_CAP registers for the
+ * context are cleared
+ * b. There is no need to clear RHT entries since
+ * RHT_CNT=0.
+ */
+static int cxlflash_disk_detach(struct scsi_device *sdev,
+ struct dk_cxlflash_detach *detach)
+{
+ struct cxlflash *cxlflash = (struct cxlflash *)sdev->host->hostdata;
+ struct lun_info *lun_info = sdev->hostdata;
+
+ struct dk_cxlflash_release rel;
+ struct ctx_info *ctx_info;
+
+ int i;
+ int rc = 0;
+
+ cxlflash_info("context=0x%llx", detach->context_id);
+
+ ctx_info = get_validated_context(cxlflash, detach->context_id, false);
+ if (unlikely(!ctx_info)) {
+ cxlflash_err("Invalid context! (%llu)", detach->context_id);
+ rc = -EINVAL;
+ goto out;
+ }
+
+ if (ctx_info->ref_cnt-- == 1) {
+
+ /* for any resource still open, deallocate LBAs and close
+ * if nobody else is using it.
+ */
+
+ if (ctx_info->rht_info->ref_cnt-- == 1) {
+ marshall_det_to_rele(detach, &rel);
+ for (i = 0; i < MAX_RHT_PER_CONTEXT; i++) {
+ rel.rsrc_handle = i;
+ cxlflash_disk_release(sdev, &rel);
+ }
+ }
+
+ /* clear RHT registers for this context */
+ writeq_be(0, &ctx_info->ctrl_map->rht_start);
+ writeq_be(0, &ctx_info->ctrl_map->rht_cnt_id);
+ /* drop all capabilities */
+ writeq_be(0, &ctx_info->ctrl_map->ctx_cap);
+ /* close the context */
+ cxlflash->num_user_contexts--;
+ }
+ spin_lock(&lun_info->slock);
+ lun_info->mode = MODE_NONE;
+ spin_unlock(&lun_info->slock);
+
+ cxlflash->per_context[detach->context_id].lfd = -1;
+ cxlflash->per_context[detach->context_id].pid = 0;
+
+out:
+ cxlflash_info("returning rc=%d", rc);
+ return rc;
+}
+
+static int cxlflash_afu_recover(struct scsi_device *sdev,
+ struct dk_cxlflash_recover_afu *recover)
+{
+ struct cxlflash *cxlflash = (struct cxlflash *)sdev->host->hostdata;
+ struct afu *afu = cxlflash->afu;
+ struct ctx_info *ctx_info;
+ long reg;
+ int rc = 0;
+
+ /* Ensure that this process is attached to the context */
+ ctx_info = get_validated_context(cxlflash, recover->context_id, false);
+ if (unlikely(!ctx_info)) {
+ cxlflash_err("Invalid context! (%llu)", recover->context_id);
+ rc = -EINVAL;
+ goto out;
+ }
+
+ reg = readq_be(&afu->ctrl_map->mbox_r); /* Try MMIO */
+ /* MMIO returning 0xff, need to reset */
+ if (reg == -1) {
+ cxlflash_info("afu=%p reason 0x%llx", afu, recover->reason);
+ cxlflash_afu_reset(cxlflash);
+
+ } else {
+ cxlflash_info
+ ("reason 0x%llx MMIO is working, no reset performed",
+ recover->reason);
+ rc = -EINVAL;
+ }
+
+out:
+ return rc;
+}
+
+/*
+ * NAME: clone_lxt()
+ *
+ * FUNCTION: clone a LXT table
+ *
+ * INPUTS:
+ * afu - Pointer to afu struct
+ * ctx_hndl_u - context that owns the destination LXT
+ * res_hndl_u - res_hndl of the destination LXT
+ * rht_entry - destination RHT to clone into
+ * rht_entry_src - source RHT to clone from
+ *
+ * OUTPUTS:
+ *
+ * RETURNS:
+ * 0 - Success
+ * errno - Failure
+ *
+ * NOTES:
+ */
+static int clone_lxt(struct afu *afu,
+ struct blka *blka,
+ ctx_hndl_t ctx_hndl_u,
+ res_hndl_t res_hndl_u,
+ struct sisl_rht_entry *rht_entry,
+ struct sisl_rht_entry *rht_entry_src)
+{
+ struct sisl_lxt_entry *lxt;
+ unsigned int ngrps;
+ u64 aun; /* chunk# allocated by block allocator */
+ int i, j;
+
+ ngrps = LXT_NUM_GROUPS(rht_entry_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, rht_entry_src->lxt_start,
+ (sizeof(*lxt) * rht_entry_src->lxt_cnt));
+
+ /* clone the LBAs in block allocator via ref_cnt */
+ mutex_lock(&blka->mutex);
+ for (i = 0; i < rht_entry_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;
+ }
+
+ smp_wmb(); /* make lxt updates visible */
+
+ /* Now sync up AFU - this can take a while */
+ rht_entry->lxt_start = lxt; /* even if lxt is NULL */
+ smp_wmb();
+
+ rht_entry->lxt_cnt = rht_entry_src->lxt_cnt;
+ smp_wmb();
+
+ cxlflash_afu_sync(afu, ctx_hndl_u, res_hndl_u, AFU_LW_SYNC);
+
+ cxlflash_info("returning");
+ return 0;
+}
+
+/*
+ * NAME: cxlflash_disk_clone
+ *
+ * FUNCTION: Clone a context by making a snapshot copy of another, specified
+ * context. This routine effectively performs cxlflash_disk_open
+ * operations 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.
+ *
+ * INPUTS:
+ * sdev - Pointer to scsi device structure
+ * arg - Pointer to ioctl specific structure
+ *
+ * OUTPUTS:
+ * None
+ *
+ * RETURNS:
+ * 0 - Success
+ * errno - Failure
+ */
+static int cxlflash_disk_clone(struct scsi_device *sdev,
+ struct dk_cxlflash_clone *clone)
+{
+ struct cxlflash *cxlflash = (struct cxlflash *)sdev->host->hostdata;
+ struct lun_info *lun_info = sdev->hostdata;
+ struct blka *blka = &lun_info->blka;
+ struct afu *afu = cxlflash->afu;
+ struct dk_cxlflash_release release = { { 0 }, 0 };
+
+ struct ctx_info *ctx_info_src, *ctx_info_dst;
+ struct rht_info *rht_info_src, *rht_info_dst;
+ u32 perms;
+ int i, j;
+ int rc = 0;
+
+ cxlflash_info("ctx_hdl_src=%llu ctx_hdl_dst=%llu",
+ clone->context_id_src, clone->context_id_dst);
+
+ /* Do not clone yourself */
+ if (clone->context_id_src == clone->context_id_dst) {
+ rc = -EINVAL;
+ goto out;
+ }
+
+ ctx_info_src = get_validated_context(cxlflash,
+ clone->context_id_src, true);
+ ctx_info_dst = get_validated_context(cxlflash,
+ clone->context_id_dst, false);
+ if (unlikely(!ctx_info_src || !ctx_info_dst)) {
+ cxlflash_err("Invalid context! (%llu,%llu)",
+ clone->context_id_src, clone->context_id_dst);
+ rc = -EINVAL;
+ goto out;
+ }
+
+ rht_info_src = ctx_info_src->rht_info;
+ rht_info_dst = ctx_info_dst->rht_info;
+
+ /* Verify there is no open resource handle in the destination context */
+ for (i = 0; i < MAX_RHT_PER_CONTEXT; i++)
+ if (rht_info_dst->rht_start[i].nmask != 0) {
+ rc = -EINVAL;
+ goto out;
+ }
+
+ /* User specified permission on attach */
+ perms = rht_info_dst->perms;
+
+ /*
+ * This loop is equivalent to cxlflash_disk_open & cxlflash_vlun_resize.
+ * Not checking if the source context has anything open or whether
+ * it is even registered. Cleanup when the clone fails.
+ */
+ for (i = 0; i < MAX_RHT_PER_CONTEXT; i++) {
+ rht_info_dst->rht_start[i].nmask =
+ rht_info_src->rht_start[i].nmask;
+ rht_info_dst->rht_start[i].fp =
+ SISL_RHT_FP_CLONE(rht_info_src->rht_start[i].fp, perms);
+
+ rc = clone_lxt(afu, blka, clone->context_id_dst, i,
+ &rht_info_dst->rht_start[i],
+ &rht_info_src->rht_start[i]);
+ if (rc) {
+ marshall_clone_to_rele(clone, &release);
+ for (j = 0; j < i; j++) {
+ release.rsrc_handle = j;
+ cxlflash_disk_release(sdev, &release);
+ }
+
+ rhte_checkin(&rht_info_dst->rht_start[i]);
+ goto out;
+ }
+ }
+
+out:
+ cxlflash_info("returning rc=%d", rc);
+ return rc;
+}
+
+/*
+ * NAME: cxlflash_disk_verify
+ *
+ * FUNCTION: Verify that the LUN is the same, whether its size has changed
+ *
+ * INPUTS:
+ * sdev - Pointer to scsi device structure
+ * arg - Pointer to ioctl specific structure
+ *
+ * OUTPUTS:
+ * none
+ *
+ * RETURNS:
+ * 0 - Success
+ * errno - Failure
+ *
+ * NOTES:
+ * When successful, the RHT entry is cleared.
+ */
+static int cxlflash_disk_verify(struct scsi_device *sdev,
+ struct dk_cxlflash_verify *verify)
+{
+ struct lun_info *lun_info = sdev->hostdata;
+
+ int rc = 0;
+
+ /* XXX: We would have to 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), or read capacity again (in case
+ * the Unit attention was due to a resize)
+ */
+ verify->last_lba = lun_info->max_lba;
+
+ cxlflash_info("returning rc=%d", rc);
+ return rc;
+}
+
+int read_cap16(struct afu *afu, struct lun_info *lun_info, u32 port_sel)
+{
+ struct afu_cmd *cmd;
+ int rc = 0;
+
+ cmd = cxlflash_cmd_checkout(afu);
+ if (unlikely(!cmd)) {
+ cxlflash_err("could not get a free command");
+ return -1;
+ }
+
+ cmd->rcb.req_flags = (SISL_REQ_FLAGS_PORT_LUN_ID |
+ SISL_REQ_FLAGS_SUP_UNDERRUN |
+ SISL_REQ_FLAGS_HOST_READ);
+
+ cmd->rcb.port_sel = port_sel;
+ cmd->rcb.lun_id = lun_info->lun_id;
+ cmd->rcb.data_len = CMD_BUFSIZE;
+ cmd->rcb.data_ea = (u64) cmd->buf;
+ cmd->rcb.timeout = MC_DISCOVERY_TIMEOUT;
+ cmd->internal = true;
+
+ cmd->rcb.cdb[0] = 0x9E; /* read cap(16) */
+ cmd->rcb.cdb[1] = 0x10; /* service action */
+ put_unaligned_be32(CMD_BUFSIZE, &cmd->rcb.cdb[10]);
+
+ cmd->sa.host_use_b[1] = 0; /* reset retry cnt */
+
+ cxlflash_info("sending cmd(0x%x) with RCB EA=%p data EA=0x%llx",
+ cmd->rcb.cdb[0], &cmd->rcb, cmd->rcb.data_ea);
+
+ do {
+ cxlflash_send_cmd(afu, cmd);
+ cxlflash_wait_resp(afu, cmd);
+ } while (cxlflash_check_status(&cmd->sa));
+
+ if (cmd->sa.host_use_b[0] & B_ERROR) {
+ cxlflash_err("command failed");
+ rc = -1;
+ 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.
+ */
+ spin_lock(&lun_info->slock);
+ lun_info->max_lba = swab64(*((u64 *)&cmd->buf[0]));
+ lun_info->blk_len = swab32(*((u32 *)&cmd->buf[8]));
+ spin_unlock(&lun_info->slock);
+
+out:
+ cxlflash_cmd_checkin(cmd);
+
+ cxlflash_info("maxlba=%lld blklen=%d pcmd %p",
+ lun_info->max_lba, lun_info->blk_len, cmd);
+ return rc;
+}
+
+static char *decode_ioctl(int cmd)
+{
+#define _CASE2STR(_x) case _x: return #_x
+
+ switch (cmd) {
+ _CASE2STR(DK_CXLFLASH_ATTACH);
+ _CASE2STR(DK_CXLFLASH_USER_DIRECT);
+ _CASE2STR(DK_CXLFLASH_USER_VIRTUAL);
+ _CASE2STR(DK_CXLFLASH_DETACH);
+ _CASE2STR(DK_CXLFLASH_VLUN_RESIZE);
+ _CASE2STR(DK_CXLFLASH_RELEASE);
+ _CASE2STR(DK_CXLFLASH_CLONE);
+ _CASE2STR(DK_CXLFLASH_VERIFY);
+ }
+
+ return ("UNKNOWN");
+}
+
+static int cxlflash_disk_virtual_open(struct scsi_device *sdev, void *arg)
+{
+ return cxlflash_disk_open(sdev, arg, MODE_VIRTUAL);
+}
+
+static int cxlflash_disk_direct_open(struct scsi_device *sdev, void *arg)
+{
+ return cxlflash_disk_open(sdev, arg, MODE_PHYSICAL);
+}
+
+/**
+ * cxlflash_ioctl - IOCTL handler
+ * @sdev: scsi device struct
+ * @cmd: IOCTL cmd
+ * @arg: IOCTL arg
+ *
+ * Return value:
+ * 0 on success / other on failure
+ **/
+int cxlflash_ioctl(struct scsi_device *sdev, int cmd, void __user *arg)
+{
+ typedef int (*sioctl) (struct scsi_device *, void *);
+
+ struct cxlflash *cxlflash = (struct cxlflash *)sdev->host->hostdata;
+ struct afu *afu = cxlflash->afu;
+ struct dk_cxlflash_hdr *hdr;
+ char buf[MAX_CXLFLASH_IOCTL_SZ];
+ size_t size = 0;
+ int idx;
+ int rc = 0;
+ sioctl do_ioctl = NULL;
+#define IOCTE(_s, _i) sizeof(struct _s), (sioctl)(_i)
+ static const struct {
+ size_t size;
+ sioctl ioctl;
+ } ioctl_tbl[] = { /* NOTE: order matters here */
+ {
+ IOCTE(dk_cxlflash_attach, cxlflash_disk_attach)}, {
+ IOCTE(dk_cxlflash_udirect, cxlflash_disk_direct_open)}, {
+ IOCTE(dk_cxlflash_uvirtual, cxlflash_disk_virtual_open)}, {
+ IOCTE(dk_cxlflash_resize, cxlflash_vlun_resize)}, {
+ IOCTE(dk_cxlflash_release, cxlflash_disk_release)}, {
+ IOCTE(dk_cxlflash_detach, cxlflash_disk_detach)}, {
+ IOCTE(dk_cxlflash_verify, cxlflash_disk_verify)}, {
+ IOCTE(dk_cxlflash_log, NULL)}, {
+ IOCTE(dk_cxlflash_recover_afu, cxlflash_afu_recover)}, {
+ IOCTE(dk_cxlflash_log, NULL)}, {
+ IOCTE(dk_cxlflash_clone, cxlflash_disk_clone)}
+ };
+
+ /* Restrict command set to physical support only for internal LUN */
+ if (internal_lun || afu->internal_lun)
+ switch (cmd) {
+ case DK_CXLFLASH_USER_VIRTUAL:
+ case DK_CXLFLASH_VLUN_RESIZE:
+ case DK_CXLFLASH_RELEASE:
+ case DK_CXLFLASH_CLONE:
+ cxlflash_err("%s not supported for lun_mode=%d",
+ decode_ioctl(cmd), internal_lun);
+ rc = -EINVAL;
+ goto cxlflash_ioctl_exit;
+ }
+
+ switch (cmd) {
+ case DK_CXLFLASH_ATTACH:
+ case DK_CXLFLASH_USER_DIRECT:
+ case DK_CXLFLASH_USER_VIRTUAL:
+ case DK_CXLFLASH_VLUN_RESIZE:
+ case DK_CXLFLASH_RELEASE:
+ case DK_CXLFLASH_DETACH:
+ case DK_CXLFLASH_VERIFY:
+ case DK_CXLFLASH_LOG_EVENT:
+ case DK_CXLFLASH_RECOVER_AFU:
+ case DK_CXLFLASH_QUERY_EXCEPTIONS:
+ case DK_CXLFLASH_CLONE:
+ 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 thru */
+ default:
+ rc = -EINVAL;
+ goto cxlflash_ioctl_exit;
+ }
+
+ if (unlikely(copy_from_user(&buf, arg, size))) {
+ cxlflash_err("copy_from_user() fail! "
+ "size=%lu cmd=%d (%s) arg=%p",
+ size, cmd, decode_ioctl(cmd), arg);
+ rc = -EFAULT;
+ goto cxlflash_ioctl_exit;
+ }
+
+ hdr = (struct dk_cxlflash_hdr *)&buf;
+ if (hdr->version != 0) {
+ cxlflash_err("Version %u not supported for %s",
+ hdr->version, decode_ioctl(cmd));
+ rc = -EINVAL;
+ goto cxlflash_ioctl_exit;
+ }
+
+ rc = do_ioctl(sdev, (void *)&buf);
+ if (likely(!rc))
+ if (unlikely(copy_to_user(arg, &buf, size))) {
+ cxlflash_err("copy_to_user() fail! "
+ "size=%lu cmd=%d (%s) arg=%p",
+ size, cmd, decode_ioctl(cmd), arg);
+ rc = -EFAULT;
+ }
+
+ /* fall thru to exit */
+
+cxlflash_ioctl_exit:
+ cxlflash_info("ioctl %s (%08X) returned rc %d",
+ decode_ioctl(cmd), cmd, rc);
+ return rc;
+}
diff --git a/drivers/scsi/cxlflash/superpipe.h b/drivers/scsi/cxlflash/superpipe.h
new file mode 100644
index 0000000..b3033ae
--- /dev/null
+++ b/drivers/scsi/cxlflash/superpipe.h
@@ -0,0 +1,67 @@
+/*
+ * CXL Flash Device Driver
+ *
+ * Written by: Manoj N. Kumar <manoj@xxxxxxxxxxxxxxxxxx>, IBM Corporation
+ * Matthew R. Ochs <mrochs@xxxxxxxxxxxxxxxxxx>, 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.
+ */
+
+#ifndef _CXLFLASH_SUPERPIPE_H
+#define _CXLFLASH_SUPERPIPE_H
+
+extern u32 checkpid;
+extern u32 internal_lun;
+
+/*----------------------------------------------------------------------------*/
+/* Constants */
+/*----------------------------------------------------------------------------*/
+
+#define SL_INI_SINI_MARKER 0x53494e49
+#define SL_INI_ELMD_MARKER 0x454c4d44
+/*----------------------------------------------------------------------------*/
+/* Types */
+/*----------------------------------------------------------------------------*/
+
+#define MAX_AUN_CLONE_CNT 0xFF
+
+/*
+ * Terminology: use afu (and not adapter) to refer to the HW.
+ * Adapter is the entire slot and includes PSL out of which
+ * only the AFU is visible to user space.
+ */
+
+/* Chunk size parms: note sislite minimum chunk size is
+ 0x10000 LBAs corresponding to a NMASK or 16.
+*/
+#define MC_RHT_NMASK 16 /* in bits */
+#define MC_CHUNK_SIZE (1 << MC_RHT_NMASK) /* in LBAs, see mclient.h */
+#define MC_CHUNK_SHIFT MC_RHT_NMASK /* shift to go from LBA to chunk# */
+#define MC_CHUNK_OFF_MASK (MC_CHUNK_SIZE - 1) /* apply to LBA get offset
+ into a chunk */
+#define LXT_LUNIDX_SHIFT 8 /* LXT entry, shift for LUN index */
+
+/* LXT tables are allocated dynamically in groups. This is done to
+ avoid a malloc/free overhead each time the LXT has to grow
+ or shrink.
+
+ Based on the current lxt_cnt (used), it is always possible to
+ know how many are allocated (used+free). The number of allocated
+ entries is not stored anywhere.
+
+ The LXT table is re-allocated whenever it needs to cross into
+ another group.
+*/
+#define LXT_GROUP_SIZE 8
+#define LXT_NUM_GROUPS(lxt_cnt) (((lxt_cnt) + 7)/8) /* alloc'ed groups */
+
+#define MC_DISCOVERY_TIMEOUT 5 /* 5 secs */
+
+int read_cap16(struct afu *, struct lun_info *, u32);
+void cxlflash_rht_format1(struct sisl_rht_entry *, u64, u32);
+#endif /* ifndef _CXLFLASH_SUPERPIPE_H */
diff --git a/include/uapi/scsi/Kbuild b/include/uapi/scsi/Kbuild
index 75746d5..d791e0a 100644
--- a/include/uapi/scsi/Kbuild
+++ b/include/uapi/scsi/Kbuild
@@ -3,3 +3,4 @@ header-y += fc/
header-y += scsi_bsg_fc.h
header-y += scsi_netlink.h
header-y += scsi_netlink_fc.h
+header-y += cxlflash_ioctl.h
diff --git a/include/uapi/scsi/cxlflash_ioctl.h b/include/uapi/scsi/cxlflash_ioctl.h
new file mode 100644
index 0000000..0e54122
--- /dev/null
+++ b/include/uapi/scsi/cxlflash_ioctl.h
@@ -0,0 +1,133 @@
+/*
+ * CXL Flash Device Driver
+ *
+ * Written by: Manoj N. Kumar <manoj@xxxxxxxxxxxxxxxxxx>, IBM Corporation
+ * Matthew R. Ochs <mrochs@xxxxxxxxxxxxxxxxxx>, 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.
+ */
+
+#ifndef _CXLFLASH_IOCTL_H
+#define _CXLFLASH_IOCTL_H
+
+#include <linux/types.h>
+
+/*
+ * Structure definitions CXL Flash driver superpipe ioctls
+ */
+
+struct dk_cxlflash_hdr {
+ __u16 version; /* Version data */
+ __u16 rsvd[3]; /* Reserved for future use */
+ __u64 flags; /* Input flags */
+ __u64 return_flags; /* Returned flags */
+};
+
+struct dk_cxlflash_attach {
+ struct dk_cxlflash_hdr hdr; /* Common fields */
+ __u64 num_interrupts; /* Requested number of interrupts */
+ __u64 context_id; /* Returned context ID */
+ __u64 mmio_size; /* Returned size of MMIO area */
+ __u64 block_size; /* Returned block size, in bytes */
+ __u64 adap_fd; /* Returned adapter file descriptor */
+ __u64 last_lba; /* Returned last LBA on the device */
+ __u64 max_xfer; /* Returned max transfer size, blocks */
+};
+
+struct dk_cxlflash_detach {
+ struct dk_cxlflash_hdr hdr; /* Common fields */
+ __u64 context_id; /* Context ID to detach */
+};
+
+struct dk_cxlflash_udirect {
+ struct dk_cxlflash_hdr hdr; /* Common fields */
+ __u64 context_id; /* Context ID for the attach */
+ __u64 rsrc_handle; /* Returned resource handle */
+ __u64 last_lba; /* Returned last LBA on the device */
+};
+
+struct dk_cxlflash_uvirtual {
+ struct dk_cxlflash_hdr hdr; /* Common fields */
+ __u64 context_id; /* Context ID for the attach */
+ __u64 lun_size; /* Requested size, blocks */
+ __u64 rsrc_handle; /* Returned resource handle */
+ __u64 last_lba; /* Returned last LBA of LUN */
+};
+
+struct dk_cxlflash_release {
+ struct dk_cxlflash_hdr hdr; /* Common fields */
+ __u64 context_id; /* Context ID for the attach */
+ __u64 rsrc_handle; /* Resource handle to release */
+};
+
+struct dk_cxlflash_resize {
+ struct dk_cxlflash_hdr hdr; /* Common fields */
+ __u64 context_id; /* Context ID of LUN to resize */
+ __u64 rsrc_handle; /* Resource handle of LUN to resize */
+ __u64 req_size; /* New requested size, blocks */
+ __u64 last_lba; /* Returned last LBA of LUN */
+};
+
+struct dk_cxlflash_clone {
+ struct dk_cxlflash_hdr hdr; /* Common fields */
+ __u64 context_id_src; /* Context ID to clone from */
+ __u64 context_id_dst; /* Context ID to clone to */
+};
+
+struct dk_cxlflash_verify {
+ struct dk_cxlflash_hdr hdr; /* Common fields */
+ __u64 rsrc_handle; /* Resource handle of LUN */
+ __u64 hint; /* Reasons for verify */
+ __u64 last_lba; /* Returned last LBA of device */
+};
+
+struct dk_cxlflash_log {
+ struct dk_cxlflash_hdr hdr; /* Common fields */
+ __u64 rsrc_handle; /* Resource handle to log err against */
+ __u64 reason; /* Reason code for error */
+ __u8 sense_data[256]; /* Sense data to include in error */
+};
+
+struct dk_cxlflash_recover_afu {
+ struct dk_cxlflash_hdr hdr; /* Common fields */
+ __u64 context_id; /* Context ID of LUN to resize */
+ __u64 rsrc_handle; /* Resource handle for LUN to recover */
+ __u64 reason; /* Reason for recovery request */
+};
+
+union cxlflash_ioctls {
+ struct dk_cxlflash_attach attach;
+ struct dk_cxlflash_detach detach;
+ struct dk_cxlflash_udirect udirect;
+ struct dk_cxlflash_uvirtual uvirtual;
+ struct dk_cxlflash_release release;
+ struct dk_cxlflash_resize resize;
+ struct dk_cxlflash_clone clone;
+ struct dk_cxlflash_verify verify;
+ struct dk_cxlflash_log log;
+ struct dk_cxlflash_recover_afu recover_afu;
+};
+
+#define MAX_CXLFLASH_IOCTL_SZ (sizeof(union cxlflash_ioctls))
+
+
+#define CXL_MAGIC 0xCA
+
+#define DK_CXLFLASH_ATTACH _IOW(CXL_MAGIC, 0x80, struct dk_cxlflash_attach)
+#define DK_CXLFLASH_USER_DIRECT _IOW(CXL_MAGIC, 0x81, struct dk_cxlflash_udirect)
+#define DK_CXLFLASH_USER_VIRTUAL _IOW(CXL_MAGIC, 0x82, struct dk_cxlflash_uvirtual)
+#define DK_CXLFLASH_VLUN_RESIZE _IOW(CXL_MAGIC, 0x83, struct dk_cxlflash_resize)
+#define DK_CXLFLASH_RELEASE _IOW(CXL_MAGIC, 0x84, struct dk_cxlflash_release)
+#define DK_CXLFLASH_DETACH _IOW(CXL_MAGIC, 0x85, struct dk_cxlflash_detach)
+#define DK_CXLFLASH_VERIFY _IOW(CXL_MAGIC, 0x86, struct dk_cxlflash_verify)
+#define DK_CXLFLASH_LOG_EVENT _IOW(CXL_MAGIC, 0x87, struct dk_cxlflash_log)
+#define DK_CXLFLASH_RECOVER_AFU _IOW(CXL_MAGIC, 0x88, struct dk_cxlflash_recover_afu)
+#define DK_CXLFLASH_QUERY_EXCEPTIONS _IOW(CXL_MAGIC, 0x89, struct dk_cxlflash_log)
+#define DK_CXLFLASH_CLONE _IOW(CXL_MAGIC, 0x8A, struct dk_cxlflash_clone)
+
+#endif /* ifndef _CXLFLASH_IOCTL_H */
--
2.1.0
--
To unsubscribe from this list: send the line "unsubscribe linux-scsi" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
